Context Navigation

source: trunk/FACT++/gui/FactGui.h@ 12328

Visit:

Last change on this file since 12328 was 12328, checked in by tbretz, 13 years ago
Renamed FTM::kTakingData to FTM::kTriggerOn
File size: 136.4 KB

Line
1	#ifndef FACT_FactGui
2	#define FACT_FactGui
3
4	#include "MainWindow.h"
5
6	#include <iomanip>
7	#include <valarray>
8
9	#include <boost/bind.hpp>
10
11	#include <QTimer>
12	#include <QStandardItemModel>
13
14	#include "CheckBoxDelegate.h"
15
16	#include "src/Dim.h"
17	#include "src/Converter.h"
18	#include "src/Configuration.h"
19	#include "src/HeadersFTM.h"
20	#include "src/HeadersFAD.h"
21	#include "src/HeadersBIAS.h"
22	#include "src/DimNetwork.h"
23	#include "src/tools.h"
24	#include "src/FAD.h"
25	#include "src/PixelMap.h"
26
27
28	#include "TROOT.h"
29	#include "TSystem.h"
30	#include "TGraph.h"
31	#include "TGraphErrors.h"
32	#include "TH2.h"
33	#include "TBox.h"
34	#include "TStyle.h"
35	#include "TMarker.h"
36	#include "TColor.h"
37
38	#include "QCameraWidget.h"
39
40	using namespace std;
41
42	// #########################################################################
43
44	/*
45	class Camera : public TObject
46	{
47	typedef pair<double,double> Position;
48	typedef vector<Position> Positions;
49
50	Positions fGeom;
51
52	void CreatePalette()
53	{
54
55	double ss[5] = {0.00, 0.25, 0.50, 0.75, 1.00};
56	double rr[5] = {0.15, 0.00, 0.00, 1.00, 0.85};
57	double gg[5] = {0.15, 0.00, 1.00, 0.00, 0.85};
58	double bb[5] = {0.15, 1.00, 0.00, 0.00, 0.85};
59
60	const Int_t nn = 1440;
61
62	Int_t idx = TColor::CreateGradientColorTable(5, ss, rr, gg, bb, nn);
63	for (int i=0; i<nn; i++)
64	fPalette.push_back(idx++);
65	}
66
67	void CreateGeometry()
68	{
69	const double gsSin60 = sqrt(3.)/2;
70
71	const int rings = 23;
72
73	// add the first pixel to the list
74
75	fGeom.push_back(make_pair(0, -0.5));
76
77	for (int ring=1; ring<=rings; ring++)
78	{
79	for (int s=0; s<6; s++)
80	{
81	for (int i=1; i<=ring; i++)
82	{
83	double xx, yy;
84	switch (s)
85	{
86	case 0: // Direction South East
87	xx = (ring+i)*0.5;
88	yy = (-ring+i)*gsSin60;
89	break;
90
91	case 1: // Direction North East
92	xx = ring-i*0.5;
93	yy = i*gsSin60;
94	break;
95
96	case 2: // Direction North
97	xx = ring*0.5-i;
98	yy = ring*gsSin60;
99	break;
100
101	case 3: // Direction North West
102	xx = -(ring+i)*0.5;
103	yy = (ring-i)*gsSin60;
104	break;
105
106	case 4: // Direction South West
107	xx = 0.5*i-ring;
108	yy = -i*gsSin60;
109	break;
110
111	case 5: // Direction South
112	xx = i-ring*0.5;
113	yy = -ring*gsSin60;
114	break;
115	}
116
117	if (xxxx + yyyy - xx > 395.75)
118	continue;
119
120	fGeom.push_back(make_pair(yy, xx-0.5));
121	}
122	}
123	}
124	}
125
126	valarray<double> fData;
127	vector<bool> fBold;
128	vector<bool> fEnable;
129
130	int fWhite;
131
132	int64_t fMin;
133	int64_t fMax;
134
135	public:
136	Camera() : fData(1440), fBold(1440), fEnable(1440), fWhite(-1), fMin(-1), fMax(-1)
137	{
138	CreatePalette();
139	CreateGeometry();
140
141	for (int i=0; i<1440; i++)
142	{
143	fData[i] = i;
144	fBold[i]=false;
145	fEnable[i]=true;
146	}
147	}
148
149	void Reset() { fBold.assign(1440, false); }
150
151	void SetBold(int idx) { fBold[idx]=true; }
152	void SetWhite(int idx) { fWhite=idx; }
153	void SetEnable(int idx, bool b) { fEnable[idx]=b; }
154	void Toggle(int idx) { fEnable[idx]=!fEnable[idx]; }
155	double GetData(int idx) const { return fData[idx]; }
156	void SetMin(int64_t min) { fMin=min; }
157	void SetMax(int64_t max) { fMax=max; }
158
159	const char *GetName() const { return "Camera"; }
160
161	vector<Int_t> fPalette;
162
163	void Paint(const Position &p)
164	{
165	static const Double_t fgCos60 = 0.5; // TMath::Cos(60/TMath::RadToDeg());
166	static const Double_t fgSin60 = sqrt(3.)/2; // TMath::Sin(60/TMath::RadToDeg());
167
168	static const Double_t fgDy[6] = { fgCos60, 0., -fgCos60, -fgCos60, 0., fgCos60 };
169	static const Double_t fgDx[6] = { fgSin60/3, fgSin602/3, fgSin60/3, -fgSin60/3, -fgSin602/3, -fgSin60/3 };
170
171	//
172	// calculate the positions of the pixel corners
173	//
174	static Double_t x[7], y[7];
175	for (Int_t i=0; i<7; i++)
176	{
177	x[i] = p.first + fgDx[i%6];
178	y[i] = p.second + fgDy[i%6];
179	}
180
181	gPad->PaintFillArea(6, x, y);
182	gPad->PaintPolyLine(7, x, y);
183	}
184
185	int GetCol(double dmin, double val, double dmax, bool enable)
186	{
187	if (!enable)
188	return kWhite;
189
190	if (val<dmin)
191	return kBlue+4;//kBlack;
192
193	if (val>dmax)
194	return kRed+4;//kWhite;
195
196	const double min = dmin;
197	const double scale = dmax==dmin ? 1 : dmax-dmin;
198
199	const int col = (val-min)/scale*(fPalette.size()-1);
200
201	return gStyle->GetColorPalette(col);
202	}
203
204	void Paint(Option_t *)
205	{
206	gStyle->SetPalette(fPalette.size(), fPalette.data());
207
208	const double r = double(gPad->GetWw())/gPad->GetWh();
209	const double max = 20.5; // 20.5 rings in x and y
210
211	if (r>1)
212	gPad->Range(-rmax, -max, rmax, max);
213	else
214	gPad->Range(-max, -max/r, max, max/r);
215
216	Double_t x1, x2, y1, y2;
217	gPad->GetRange(x1, x2, y1, y2);
218
219	double dmin = fData[0];
220	double dmax = fData[0];
221
222	for (unsigned int i=0; i<fData.size(); i++)
223	{
224	if (!fEnable[i])
225	continue;
226
227	if (fData[i]>dmax)
228	dmax = fData[i];
229	if (fData[i]<dmin)
230	dmin = fData[i];
231	}
232
233	if (fMin>=0)
234	dmin = fMin;
235	if (fMax>=0)
236	dmax = fMax;
237
238	// const double min = dmin;
239	// const double scale = dmax==dmin ? 1 : dmax-dmin;
240
241	TAttFill fill(0, 1001);
242	TAttLine line;
243
244	int cnt=0;
245	for (Positions::iterator p=fGeom.begin(); p!=fGeom.end(); p++, cnt++)
246	{
247	if (fBold[cnt])
248	continue;
249
250	const int col = GetCol(dmin, fData[cnt], dmax, fEnable[cnt]);
251
252	fill.SetFillColor(col);
253	fill.Modify();
254
255	Paint(*p);
256	}
257
258	line.SetLineWidth(2);
259	line.Modify();
260
261	cnt = 0;
262	for (Positions::iterator p=fGeom.begin(); p!=fGeom.end(); p++, cnt++)
263	{
264	if (!fBold[cnt])
265	continue;
266
267	const int col = GetCol(dmin, fData[cnt], dmax, fEnable[cnt]);
268
269	fill.SetFillColor(col);
270	fill.Modify();
271
272	Paint(*p);
273	}
274
275	TMarker m(0,0,kStar);
276	m.DrawMarker(0, 0);
277
278	if (fWhite<0)
279	return;
280
281	const Position &p = fGeom[fWhite];
282
283	line.SetLineColor(kWhite);
284	line.Modify();
285
286	const int col = GetCol(dmin, fData[fWhite], dmax, fEnable[fWhite]);
287
288	fill.SetFillColor(col);
289	fill.Modify();
290
291	Paint(p);
292	}
293
294	int GetIdx(float px, float py) const
295	{
296	static const double sqrt3 = sqrt(3);
297
298	int idx = 0;
299	for (Positions::const_iterator p=fGeom.begin(); p!=fGeom.end(); p++, idx++)
300	{
301	const Double_t dy = py - p->second;
302	if (fabs(dy)>0.5)
303	continue;
304
305	const Double_t dx = px - p->first;
306
307	if (TMath::Abs(dy + dx*sqrt3) > 1)
308	continue;
309
310	if (TMath::Abs(dy - dx*sqrt3) > 1)
311	continue;
312
313	return idx;
314	}
315	return -1;
316	}
317
318	char *GetObjectInfo(Int_t px, Int_t py) const
319	{
320	static stringstream stream;
321	static string str;
322
323	const float x = gPad->AbsPixeltoX(px);
324	const float y = gPad->AbsPixeltoY(py);
325
326	const int idx = GetIdx(x, y);
327
328	stream.seekp(0);
329	if (idx>=0)
330	{
331	stream << "Pixel=" << idx << " Data=" << fData[idx] << '\0';
332	}
333
334	str = stream.str();
335	return const_cast<char*>(str.c_str());
336	}
337
338	Int_t DistancetoPrimitive(Int_t px, Int_t py)
339	{
340	const float x = gPad->AbsPixeltoX(px);
341	const float y = gPad->AbsPixeltoY(py);
342
343	return GetIdx(x, y)>=0 ? 0 : 99999;
344	}
345
346	void SetData(const valarray<double> &data)
347	{
348	fData = data;
349	}
350
351	void SetData(const float *data)
352	{
353	for (int i=0; i<1440; i++)
354	fData[i] = data[i];
355	}
356	};
357	*/
358	// #########################################################################
359
360	class FactGui : public MainWindow, public DimNetwork
361	{
362	private:
363	class FunctionEvent : public QEvent
364	{
365	public:
366	boost::function<void(const QEvent &)> fFunction;
367
368	FunctionEvent(const boost::function<void(const QEvent &)> &f)
369	: QEvent((QEvent::Type)QEvent::registerEventType()),
370	fFunction(f) { }
371
372	bool Exec() { fFunction(*this); return true; }
373	};
374
375	valarray<int8_t> fFtuStatus;
376
377	PixelMap fPixelMap;
378
379	//vector<int> fPixelMapHW; // Software -> Hardware
380	vector<int> fPatchMapHW; // Software -> Hardware
381
382	bool fInChoosePatchTH; // FIXME. Find a better solution
383	bool fInChooseBiasHv; // FIXME. Find a better solution
384	bool fInChooseBiasCam; // FIXME. Find a better solution
385
386	DimStampedInfo fDimDNS;
387
388	DimStampedInfo fDimLoggerStats;
389	DimStampedInfo fDimLoggerFilenameNight;
390	DimStampedInfo fDimLoggerFilenameRun;
391	DimStampedInfo fDimLoggerNumSubs;
392
393	DimStampedInfo fDimFtmPassport;
394	DimStampedInfo fDimFtmTriggerRates;
395	DimStampedInfo fDimFtmError;
396	DimStampedInfo fDimFtmFtuList;
397	DimStampedInfo fDimFtmStaticData;
398	DimStampedInfo fDimFtmDynamicData;
399	DimStampedInfo fDimFtmCounter;
400
401	DimStampedInfo fDimFadWriteStats;
402	DimStampedInfo fDimFadStartRun;
403	DimStampedInfo fDimFadRuns;
404	DimStampedInfo fDimFadEvents;
405	DimStampedInfo fDimFadRawData;
406	DimStampedInfo fDimFadEventData;
407	DimStampedInfo fDimFadConnections;
408	DimStampedInfo fDimFadFwVersion;
409	DimStampedInfo fDimFadRunNumber;
410	DimStampedInfo fDimFadDNA;
411	DimStampedInfo fDimFadTemperature;
412	DimStampedInfo fDimFadPrescaler;
413	DimStampedInfo fDimFadRefClock;
414	DimStampedInfo fDimFadRoi;
415	DimStampedInfo fDimFadDac;
416	DimStampedInfo fDimFadDrsCalibration;
417	DimStampedInfo fDimFadStatus;
418	DimStampedInfo fDimFadStatistics1;
419	DimStampedInfo fDimFadStatistics2;
420
421	DimStampedInfo fDimFscTemp;
422	DimStampedInfo fDimFscVolt;
423	DimStampedInfo fDimFscCurrent;
424	DimStampedInfo fDimFscHumidity;
425
426	DimStampedInfo fDimBiasVolt;
427	DimStampedInfo fDimBiasCurrent;
428
429	DimStampedInfo fDimFeedbackDeviation;
430	DimStampedInfo fDimFeedbackReference;
431
432	DimStampedInfo fDimRateScan;
433
434	map<string, DimInfo*> fServices;
435
436	// ========================== LED Colors ================================
437
438	enum LedColor_t
439	{
440	kLedRed,
441	kLedGreen,
442	kLedGreenWarn,
443	kLedGreenCheck,
444	kLedGreenBar,
445	kLedYellow,
446	kLedOrange,
447	kLedGray,
448	kLedWarnBorder,
449	kLedWarn,
450	kLedWarnTriangleBorder,
451	kLedWarnTriangle,
452	kLedInProgress,
453	};
454
455	void SetLedColor(QPushButton *button, LedColor_t col, const Time &t)
456	{
457	switch (col)
458	{
459	case kLedRed:
460	button->setIcon(QIcon(":/Resources/icons/red circle 1.png"));
461	break;
462
463	case kLedGreen:
464	button->setIcon(QIcon(":/Resources/icons/green circle 1.png"));
465	break;
466
467	case kLedGreenBar:
468	button->setIcon(QIcon(":/Resources/icons/green bar.png"));
469	break;
470
471	case kLedGreenWarn:
472	button->setIcon(QIcon(":/Resources/icons/green warn.png"));
473	break;
474
475	case kLedGreenCheck:
476	button->setIcon(QIcon(":/Resources/icons/green check.png"));
477	break;
478
479	case kLedYellow:
480	button->setIcon(QIcon(":/Resources/icons/yellow circle 1.png"));
481	break;
482
483	case kLedOrange:
484	button->setIcon(QIcon(":/Resources/icons/orange circle 1.png"));
485	break;
486
487	case kLedGray:
488	button->setIcon(QIcon(":/Resources/icons/gray circle 1.png"));
489	break;
490
491	case kLedWarnBorder:
492	button->setIcon(QIcon(":/Resources/icons/warning 1.png"));
493	break;
494
495	case kLedWarn:
496	button->setIcon(QIcon(":/Resources/icons/warning 2.png"));
497	break;
498
499	case kLedWarnTriangle:
500	button->setIcon(QIcon(":/Resources/icons/warning 3.png"));
501	break;
502
503	case kLedWarnTriangleBorder:
504	button->setIcon(QIcon(":/Resources/icons/warning 4.png"));
505	break;
506
507	case kLedInProgress:
508	button->setIcon(QIcon(":/Resources/icons/in progress.png"));
509	break;
510
511	}
512
513	//button->setToolTip("Last change: "+QDateTime::currentDateTimeUtc().toString()+" UTC");
514	button->setToolTip(("Last change: "+t.GetAsStr()+" (UTC)").c_str());
515	}
516
517	// ===================== Services and Commands ==========================
518
519	QStandardItem *AddServiceItem(const std::string &server, const std::string &service, bool iscmd)
520	{
521	QListView *servers = iscmd ? fDimCmdServers : fDimSvcServers;
522	QListView *services = iscmd ? fDimCmdCommands : fDimSvcServices;
523	QListView *description = iscmd ? fDimCmdDescription : fDimSvcDescription;
524
525	QStandardItemModel m = dynamic_cast<QStandardItemModel>(servers->model());
526	if (!m)
527	{
528	m = new QStandardItemModel(this);
529	servers->setModel(m);
530	services->setModel(m);
531	description->setModel(m);
532	}
533
534	QList<QStandardItem*> l = m->findItems(server.c_str());
535
536	if (l.size()>1)
537	{
538	cout << "hae" << endl;
539	return 0;
540	}
541
542	QStandardItem *col = l.size()==0 ? NULL : l[0];
543
544	if (!col)
545	{
546	col = new QStandardItem(server.c_str());
547	m->appendRow(col);
548
549	if (!services->rootIndex().isValid())
550	{
551	services->setRootIndex(col->index());
552	servers->setCurrentIndex(col->index());
553	}
554	}
555
556	QStandardItem *item = 0;
557	for (int i=0; i<col->rowCount(); i++)
558	{
559	QStandardItem *coli = col->child(i);
560	if (coli->text().toStdString()==service)
561	return coli;
562	}
563
564	item = new QStandardItem(service.c_str());
565	col->appendRow(item);
566	col->sortChildren(0);
567
568	if (!description->rootIndex().isValid())
569	{
570	description->setRootIndex(item->index());
571	services->setCurrentIndex(item->index());
572	}
573
574	if (!iscmd)
575	item->setCheckable(true);
576
577	return item;
578	}
579
580	void AddDescription(QStandardItem *item, const vector<Description> &vec)
581	{
582	if (!item)
583	return;
584	if (vec.size()==0)
585	return;
586
587	item->setToolTip(vec[0].comment.c_str());
588
589	const string str = Description::GetHtmlDescription(vec);
590
591	QStandardItem *desc = new QStandardItem(str.c_str());
592	desc->setSelectable(false);
593	item->setChild(0, 0, desc);
594	}
595
596	void AddServer(const std::string &s)
597	{
598	DimNetwork::AddServer(s);
599
600	QApplication::postEvent(this,
601	new FunctionEvent(boost::bind(&FactGui::handleAddServer, this, s)));
602	}
603
604	void AddService(const std::string &server, const std::string &service, const std::string &fmt, bool iscmd)
605	{
606	QApplication::postEvent(this,
607	new FunctionEvent(boost::bind(&FactGui::handleAddService, this, server, service, fmt, iscmd)));
608	}
609
610	void RemoveService(std::string server, std::string service, bool iscmd)
611	{
612	UnsubscribeService(server+'/'+service, true);
613
614	QApplication::postEvent(this,
615	new FunctionEvent(boost::bind(&FactGui::handleRemoveService, this, server, service, iscmd)));
616	}
617
618	void RemoveAllServices(const std::string &server)
619	{
620	UnsubscribeAllServices(server);
621
622	QApplication::postEvent(this,
623	new FunctionEvent(boost::bind(&FactGui::handleRemoveAllServices, this, server)));
624	}
625
626	void AddDescription(const std::string &server, const std::string &service, const vector<Description> &vec)
627	{
628	QApplication::postEvent(this,
629	new FunctionEvent(boost::bind(&FactGui::handleAddDescription, this, server, service, vec)));
630	}
631
632	// ======================================================================
633
634	void handleAddServer(const std::string &server)
635	{
636	const State s = GetState(server, GetCurrentState(server));
637	handleStateChanged(Time(), server, s);
638	}
639
640	void handleAddService(const std::string &server, const std::string &service, const std::string &/fmt/, bool iscmd)
641	{
642	QStandardItem *item = AddServiceItem(server, service, iscmd);
643	const vector<Description> v = GetDescription(server, service);
644	AddDescription(item, v);
645	}
646
647	void handleRemoveService(const std::string &server, const std::string &service, bool iscmd)
648	{
649	QListView *servers = iscmd ? fDimCmdServers : fDimSvcServers;
650
651	QStandardItemModel m = dynamic_cast<QStandardItemModel>(servers->model());
652	if (!m)
653	return;
654
655	QList<QStandardItem*> l = m->findItems(server.c_str());
656	if (l.size()!=1)
657	return;
658
659	for (int i=0; i<l[0]->rowCount(); i++)
660	{
661	QStandardItem *row = l[0]->child(i);
662	if (row->text().toStdString()==service)
663	{
664	l[0]->removeRow(row->index().row());
665	return;
666	}
667	}
668	}
669
670	void handleRemoveAllServices(const std::string &server)
671	{
672	handleStateChanged(Time(), server, State(-2, "Offline", "No connection via DIM."));
673
674	QStandardItemModel *m = 0;
675	if ((m=dynamic_cast<QStandardItemModel*>(fDimCmdServers->model())))
676	{
677	QList<QStandardItem*> l = m->findItems(server.c_str());
678	if (l.size()==1)
679	m->removeRow(l[0]->index().row());
680	}
681
682	if ((m = dynamic_cast<QStandardItemModel*>(fDimSvcServers->model())))
683	{
684	QList<QStandardItem*> l = m->findItems(server.c_str());
685	if (l.size()==1)
686	m->removeRow(l[0]->index().row());
687	}
688	}
689
690	void handleAddDescription(const std::string &server, const std::string &service, const vector<Description> &vec)
691	{
692	const bool iscmd = IsCommand(server, service)==true;
693
694	QStandardItem *item = AddServiceItem(server, service, iscmd);
695	AddDescription(item, vec);
696	}
697
698	// ======================================================================
699
700	void SubscribeService(const string &service)
701	{
702	if (fServices.find(service)!=fServices.end())
703	{
704	cerr << "ERROR - We are already subscribed to " << service << endl;
705	return;
706	}
707
708	fServices[service] = new DimStampedInfo(service.c_str(), (void*)NULL, 0, this);
709	}
710
711	void UnsubscribeService(const string &service, bool allow_unsubscribed=false)
712	{
713	const map<string,DimInfo*>::iterator i=fServices.find(service);
714
715	if (i==fServices.end())
716	{
717	if (!allow_unsubscribed)
718	cerr << "ERROR - We are not subscribed to " << service << endl;
719	return;
720	}
721
722	delete i->second;
723
724	fServices.erase(i);
725	}
726
727	void UnsubscribeAllServices(const string &server)
728	{
729	for (map<string,DimInfo*>::iterator i=fServices.begin();
730	i!=fServices.end(); i++)
731	if (i->first.substr(0, server.length()+1)==server+'/')
732	{
733	delete i->second;
734	fServices.erase(i);
735	}
736	}
737
738	// ======================================================================
739
740	struct DimData
741	{
742	const int qos;
743	const string name;
744	const string format;
745	const vector<char> data;
746	const Time time;
747
748	Time extract(DimInfo *inf) const
749	{
750	// Must be called in exactly this order!
751	const int tsec = inf->getTimestamp();
752	const int tms = inf->getTimestampMillisecs();
753
754	return Time(tsec, tms*1000);
755	}
756
757	// DimInfo *info; // this is ONLY for a fast check of the type of the DimData!!
758
759	DimData(DimInfo *inf) :
760	qos(inf->getQuality()),
761	name(inf->getName()),
762	format(inf->getFormat()),
763	data(inf->getString(), inf->getString()+inf->getSize()),
764	time(extract(inf))/*,
765	info(inf)*/
766	{
767	}
768
769	template<typename T>
770	T get(uint32_t offset=0) const { return reinterpret_cast<const T>(data.data()+offset); }
771
772	template<typename T>
773	const T ptr(uint32_t offset=0) const { return reinterpret_cast<const T>(data.data()+offset); }
774
775	template<typename T>
776	const T &ref(uint32_t offset=0) const { return reinterpret_cast<const T>(data.data()+offset); }
777
778	// vector<char> vec(int b) const { return vector<char>(data.begin()+b, data.end()); }
779	// string str(unsigned int b) const { return b>=data.size()?string():string(data.data()+b, data.size()-b); }
780	const char c_str() const { return (char)data.data(); }
781	/*
782	vector<boost::any> any() const
783	{
784	const Converter conv(format);
785	conv.Print();
786	return conv.GetAny(data.data(), data.size());
787	}*/
788	size_t size() const { return data.size(); }
789	};
790
791	// ======================= DNS ==========================================
792
793	void handleDimDNS(const DimData &d)
794	{
795	const int version = d.size()!=4 ? 0 : d.get<uint32_t>();
796
797	ostringstream str;
798	str << "V" << version/100 << 'r' << version%100;
799
800	ostringstream dns;
801	dns << (version==0?"No connection":"Connection");
802	dns << " to DIM DNS (" << getenv("DIM_DNS_NODE") << ")";
803	dns << (version==0?".":" established.");
804
805	fStatusDNSLabel->setText(version==0?"Offline":str.str().c_str());
806	fStatusDNSLabel->setToolTip(dns.str().c_str());
807
808	SetLedColor(fStatusDNSLed, version==0 ? kLedRed : kLedGreen, Time());
809
810	fShutdown->setEnabled(version!=0);
811	fShutdownAll->setEnabled(version!=0);
812	}
813
814
815	// ======================= Logger =======================================
816
817	void handleLoggerStats(const DimData &d)
818	{
819	const bool connected = d.size()!=0;
820
821	fLoggerET->setEnabled(connected);
822	fLoggerRate->setEnabled(connected);
823	fLoggerWritten->setEnabled(connected);
824	fLoggerFreeSpace->setEnabled(connected);
825	fLoggerSpaceLeft->setEnabled(connected);
826
827	if (!connected)
828	return;
829
830	const uint64_t *vals = d.ptr<uint64_t>();
831
832	const size_t space = vals[0];
833	const size_t written = vals[1];
834	const size_t rate = float(vals[2])/vals[3];
835
836	fLoggerFreeSpace->setSuffix(" MB");
837	fLoggerFreeSpace->setDecimals(0);
838	fLoggerFreeSpace->setValue(space*1e-6);
839
840	if (space> 1000000) // > 1GB
841	{
842	fLoggerFreeSpace->setSuffix(" GB");
843	fLoggerFreeSpace->setDecimals(2);
844	fLoggerFreeSpace->setValue(space*1e-9);
845	}
846	if (space>= 3000000) // >= 3GB
847	{
848	fLoggerFreeSpace->setSuffix(" GB");
849	fLoggerFreeSpace->setDecimals(1);
850	fLoggerFreeSpace->setValue(space*1e-9);
851	}
852	if (space>=100000000) // >= 100GB
853	{
854	fLoggerFreeSpace->setSuffix(" GB");
855	fLoggerFreeSpace->setDecimals(0);
856	fLoggerFreeSpace->setValue(space*1e-9);
857	}
858
859	fLoggerET->setTime(QTime().addSecs(rate>0?space/rate:0));
860	fLoggerRate->setValue(rate*1e-3); // kB/s
861	fLoggerWritten->setValue(written*1e-6);
862
863	fLoggerRate->setSuffix(" kB/s");
864	fLoggerRate->setDecimals(2);
865	fLoggerRate->setValue(rate);
866	if (rate> 2) // > 2kB/s
867	{
868	fLoggerRate->setSuffix(" kB/s");
869	fLoggerRate->setDecimals(1);
870	fLoggerRate->setValue(rate);
871	}
872	if (rate>=100) // >100kB/s
873	{
874	fLoggerRate->setSuffix(" kB/s");
875	fLoggerRate->setDecimals(0);
876	fLoggerRate->setValue(rate);
877	}
878	if (rate>=1000) // >100kB/s
879	{
880	fLoggerRate->setSuffix(" MB/s");
881	fLoggerRate->setDecimals(2);
882	fLoggerRate->setValue(rate*1e-3);
883	}
884	if (rate>=10000) // >1MB/s
885	{
886	fLoggerRate->setSuffix(" MB/s");
887	fLoggerRate->setDecimals(1);
888	fLoggerRate->setValue(rate*1e-3);
889	}
890	if (rate>=100000) // >10MB/s
891	{
892	fLoggerRate->setSuffix(" MB/s");
893	fLoggerRate->setDecimals(0);
894	fLoggerRate->setValue(rate*1e-3);
895	}
896
897	if (space/1000000>static_cast<size_t>(fLoggerSpaceLeft->maximum()))
898	fLoggerSpaceLeft->setValue(fLoggerSpaceLeft->maximum()); // GB
899	else
900	fLoggerSpaceLeft->setValue(space/1000000); // MB
901	}
902
903	void handleLoggerFilenameNight(const DimData &d)
904	{
905	const bool connected = d.size()!=0;
906
907	fLoggerFilenameNight->setEnabled(connected);
908	if (!connected)
909	return;
910
911	fLoggerFilenameNight->setText(d.c_str()+4);
912
913	const uint32_t files = d.get<uint32_t>();
914
915	SetLedColor(fLoggerLedLog, files&1 ? kLedGreen : kLedGray, d.time);
916	SetLedColor(fLoggerLedRep, files&2 ? kLedGreen : kLedGray, d.time);
917	SetLedColor(fLoggerLedFits, files&4 ? kLedGreen : kLedGray, d.time);
918	}
919
920	void handleLoggerFilenameRun(const DimData &d)
921	{
922	const bool connected = d.size()!=0;
923
924	fLoggerFilenameRun->setEnabled(connected);
925	if (!connected)
926	return;
927
928	fLoggerFilenameRun->setText(d.c_str()+4);
929
930	const uint32_t files = d.get<uint32_t>();
931
932	SetLedColor(fLoggerLedLog, files&1 ? kLedGreen : kLedGray, d.time);
933	SetLedColor(fLoggerLedRep, files&2 ? kLedGreen : kLedGray, d.time);
934	SetLedColor(fLoggerLedFits, files&4 ? kLedGreen : kLedGray, d.time);
935	}
936
937	void handleLoggerNumSubs(const DimData &d)
938	{
939	const bool connected = d.size()!=0;
940
941	fLoggerSubscriptions->setEnabled(connected);
942	fLoggerOpenFiles->setEnabled(connected);
943	if (!connected)
944	return;
945
946	const uint32_t *vals = d.ptr<uint32_t>();
947
948	fLoggerSubscriptions->setValue(vals[0]);
949	fLoggerOpenFiles->setValue(vals[1]);
950	}
951
952
953	// ===================== All ============================================
954
955	bool CheckSize(const DimData &d, size_t sz, bool print=true) const
956	{
957	if (d.size()==0)
958	return false;
959
960	if (d.size()!=sz)
961	{
962	if (print)
963	cerr << "Size mismatch in " << d.name << ": Found=" << d.size() << " Expected=" << sz << endl;
964	return false;
965	}
966
967	return true;
968	}
969
970	// ===================== FAD ============================================
971
972	void handleFadWriteStats(const DimData &d)
973	{
974	const bool connected = d.size()!=0;
975
976	fEvtBuilderET->setEnabled(connected);
977	fEvtBuilderRate->setEnabled(connected);
978	fEvtBuilderWritten->setEnabled(connected);
979	fEvtBuilderFreeSpace->setEnabled(connected);
980	fEvtBuilderSpaceLeft->setEnabled(connected);
981
982	if (!connected)
983	return;
984
985	const uint64_t *vals = d.ptr<uint64_t>();
986
987	const size_t space = vals[0];
988	const size_t written = vals[1];
989	const size_t rate = float(vals[2])/vals[3];
990
991	fEvtBuilderFreeSpace->setSuffix(" MB");
992	fEvtBuilderFreeSpace->setDecimals(0);
993	fEvtBuilderFreeSpace->setValue(space*1e-6);
994
995	if (space> 1000000) // > 1GB
996	{
997	fEvtBuilderFreeSpace->setSuffix(" GB");
998	fEvtBuilderFreeSpace->setDecimals(2);
999	fEvtBuilderFreeSpace->setValue(space*1e-9);
1000	}
1001	if (space>= 3000000) // >= 3GB
1002	{
1003	fEvtBuilderFreeSpace->setSuffix(" GB");
1004	fEvtBuilderFreeSpace->setDecimals(1);
1005	fEvtBuilderFreeSpace->setValue(space*1e-9);
1006	}
1007	if (space>=100000000) // >= 100GB
1008	{
1009	fEvtBuilderFreeSpace->setSuffix(" GB");
1010	fEvtBuilderFreeSpace->setDecimals(0);
1011	fEvtBuilderFreeSpace->setValue(space*1e-9);
1012	}
1013
1014	fEvtBuilderET->setTime(QTime().addSecs(rate>0?space/rate:0));
1015	fEvtBuilderRate->setValue(rate*1e-3); // kB/s
1016	fEvtBuilderWritten->setValue(written*1e-6);
1017
1018	fEvtBuilderRate->setSuffix(" kB/s");
1019	fEvtBuilderRate->setDecimals(2);
1020	fEvtBuilderRate->setValue(rate);
1021	if (rate> 2) // > 2kB/s
1022	{
1023	fEvtBuilderRate->setSuffix(" kB/s");
1024	fEvtBuilderRate->setDecimals(1);
1025	fEvtBuilderRate->setValue(rate);
1026	}
1027	if (rate>=100) // >100kB/s
1028	{
1029	fEvtBuilderRate->setSuffix(" kB/s");
1030	fEvtBuilderRate->setDecimals(0);
1031	fEvtBuilderRate->setValue(rate);
1032	}
1033	if (rate>=1000) // >100kB/s
1034	{
1035	fEvtBuilderRate->setSuffix(" MB/s");
1036	fEvtBuilderRate->setDecimals(2);
1037	fEvtBuilderRate->setValue(rate*1e-3);
1038	}
1039	if (rate>=10000) // >1MB/s
1040	{
1041	fEvtBuilderRate->setSuffix(" MB/s");
1042	fEvtBuilderRate->setDecimals(1);
1043	fEvtBuilderRate->setValue(rate*1e-3);
1044	}
1045	if (rate>=100000) // >10MB/s
1046	{
1047	fEvtBuilderRate->setSuffix(" MB/s");
1048	fEvtBuilderRate->setDecimals(0);
1049	fEvtBuilderRate->setValue(rate*1e-3);
1050	}
1051
1052	if (space/1000000>static_cast<size_t>(fEvtBuilderSpaceLeft->maximum()))
1053	fEvtBuilderSpaceLeft->setValue(fEvtBuilderSpaceLeft->maximum()); // GB
1054	else
1055	fEvtBuilderSpaceLeft->setValue(space/1000000); // MB
1056	}
1057
1058	void handleFadRuns(const DimData &d)
1059	{
1060	if (d.size()==0)
1061	return;
1062
1063	if (d.size()<20)
1064	{
1065	cerr << "Size mismatch in " << d.name << ": Found=" << d.size() << " Expected>=20" << endl;
1066	return;
1067	}
1068
1069	const uint32_t *ptr = d.ptr<uint32_t>();
1070
1071	fEvtBldOpenFiles->setValue(ptr[0]);
1072	fEvtBldOpenStreams->setValue(ptr[0]);
1073	fEvtBldRunNumberMin->setValue(ptr[1]);
1074	fEvtBldRunNumberMax->setValue(ptr[2]);
1075	fEvtBldLastOpened->setValue(ptr[3]);
1076	fEvtBldLastClosed->setValue(ptr[4]);
1077
1078	if (d.size()>=20)
1079	fEvtBldFilename->setText(d.ptr<char>(20));
1080
1081	if (ptr[0]==0)
1082	fEvtBldFilename->setText("");
1083	}
1084
1085	void handleFadStartRun(const DimData &d)
1086	{
1087	if (!CheckSize(d, 16))
1088	return;
1089
1090	const int64_t *runs = d.ptr<int64_t>();
1091
1092	fFadRunNoCur->setValue(runs[0]);
1093	fFadRunNoNext->setValue(runs[1]);
1094	fFadRunNoCur->setEnabled(runs[0]>=0);
1095	//fMcpStopRun->setEnabled(runs[0]>=0);
1096
1097	}
1098
1099	void handleFadEvents(const DimData &d)
1100	{
1101	if (!CheckSize(d, 16))
1102	return;
1103
1104	const uint32_t *ptr = d.ptr<uint32_t>();
1105
1106	fEvtsSuccessCurRun->setValue(ptr[0]);
1107	fEvtsSuccessTotal->setValue(ptr[1]);
1108	fEvtBldEventId->setValue(ptr[2]);
1109	fFadEvtCounter->setValue(ptr[2]);
1110	fEvtBldTriggerId->setValue(ptr[3]);
1111	}
1112
1113	void handleFadTemperature(const DimData &d)
1114	{
1115	if (d.size()==0)
1116	{
1117	fFadTempMin->setEnabled(false);
1118	fFadTempMax->setEnabled(false);
1119	SetLedColor(fFadLedTemp, kLedGray, d.time);
1120	return;
1121	}
1122
1123	if (!CheckSize(d, 82*sizeof(float)))
1124	return;
1125
1126	const float *ptr = d.ptr<float>();
1127
1128	fFadTempMin->setEnabled(true);
1129	fFadTempMax->setEnabled(true);
1130
1131	fFadTempMin->setValue(ptr[0]);
1132	fFadTempMax->setValue(ptr[41]);
1133
1134	handleFadToolTip(d.time, fFadTempMin, ptr+1);
1135	handleFadToolTip(d.time, fFadTempMax, ptr+42);
1136	}
1137
1138	void handleFadRefClock(const DimData &d)
1139	{
1140	if (d.size()==0)
1141	{
1142	fFadRefClockMin->setEnabled(false);
1143	fFadRefClockMax->setEnabled(false);
1144	SetLedColor(fFadLedRefClock, kLedGray, d.time);
1145	return;
1146	}
1147
1148	if (!CheckSize(d, 42*sizeof(uint32_t)))
1149	return;
1150
1151	const uint32_t *ptr = d.ptr<uint32_t>();
1152
1153	fFadRefClockMin->setEnabled(true);
1154	fFadRefClockMax->setEnabled(true);
1155
1156	fFadRefClockMin->setValue(ptr[40]*2.048);
1157	fFadRefClockMax->setValue(ptr[41]*2.048);
1158
1159	const int64_t diff = int64_t(ptr[41]) - int64_t(ptr[40]);
1160
1161	SetLedColor(fFadLedRefClock, abs(diff)>3?kLedRed:kLedGreen, d.time);
1162
1163	handleFadToolTip(d.time, fFadLedRefClock, ptr);
1164	}
1165
1166	void handleFadRoi(const DimData &d)
1167	{
1168	if (d.size()==0)
1169	{
1170	fFadRoi->setEnabled(false);
1171	fFadRoiCh9->setEnabled(false);
1172	SetLedColor(fFadLedRoi, kLedGray, d.time);
1173	return;
1174	}
1175
1176	if (!CheckSize(d, 2*sizeof(uint16_t)))
1177	return;
1178
1179	const uint16_t *ptr = d.ptr<uint16_t>();
1180
1181	fFadRoi->setEnabled(true);
1182	fFadRoiCh9->setEnabled(true);
1183
1184	fFadRoi->setValue(ptr[0]);
1185	fFadRoiCh9->setValue(ptr[1]);
1186
1187	SetLedColor(fFadLedRoi, kLedGray, d.time);
1188	}
1189
1190	void handleDac(QPushButton led, QSpinBox box, const DimData &d, int idx)
1191	{
1192	if (d.size()==0)
1193	{
1194	box->setEnabled(false);
1195	SetLedColor(led, kLedGray, d.time);
1196	return;
1197	}
1198
1199	const uint16_t ptr = d.ptr<uint16_t>()+idx42;
1200
1201	box->setEnabled(true);
1202	box->setValue(ptr[40]==ptr[41]?ptr[40]:0);
1203
1204	SetLedColor(led, ptr[40]==ptr[41]?kLedGreen:kLedOrange, d.time);
1205	handleFadToolTip(d.time, led, ptr);
1206	}
1207
1208	void handleFadDac(const DimData &d)
1209	{
1210	if (!CheckSize(d, 842sizeof(uint16_t)) && !d.size()==0)
1211	return;
1212
1213	handleDac(fFadLedDac0, fFadDac0, d, 0);
1214	handleDac(fFadLedDac1, fFadDac1, d, 1);
1215	handleDac(fFadLedDac2, fFadDac2, d, 2);
1216	handleDac(fFadLedDac3, fFadDac3, d, 3);
1217	handleDac(fFadLedDac4, fFadDac4, d, 4);
1218	handleDac(fFadLedDac5, fFadDac5, d, 5);
1219	handleDac(fFadLedDac6, fFadDac6, d, 6);
1220	handleDac(fFadLedDac7, fFadDac7, d, 7);
1221	}
1222
1223	EVENT *fEventData;
1224
1225	void DrawHorizontal(TH1 *hf, double xmax, TH1 &h, double scale)
1226	{
1227	for (Int_t i=1;i<=h.GetNbinsX();i++)
1228	{
1229	if (h.GetBinContent(i)<0.5 \|\| h.GetBinContent(i)>h.GetEntries()-0.5)
1230	continue;
1231
1232	TBox * box=new TBox(xmax, h.GetBinLowEdge(i),
1233	xmax+h.GetBinContent(i)*scale,
1234	h.GetBinLowEdge(i+1));
1235
1236	box->SetFillStyle(0);
1237	box->SetLineColor(h.GetLineColor());
1238	box->SetLineStyle(kSolid);
1239	box->SetBit(kCannotPick\|kNoContextMenu);
1240	//box->Draw();
1241
1242	hf->GetListOfFunctions()->Add(box);
1243	}
1244	}
1245
1246	void DisplayEventData()
1247	{
1248	if (!fEventData)
1249	return;
1250
1251	#ifdef HAVE_ROOT
1252	TCanvas *c = fAdcDataCanv->GetCanvas();
1253
1254	TH1 hf = dynamic_cast<TH1>(c->FindObject("Frame"));
1255	TH1 h = dynamic_cast<TH1>(c->FindObject("EventData"));
1256	TH1 d0 = dynamic_cast<TH1>(c->FindObject("DrsCalib0"));
1257	TH1 d1 = dynamic_cast<TH1>(c->FindObject("DrsCalib1"));
1258	TH1 d2 = dynamic_cast<TH1>(c->FindObject("DrsCalib2"));
1259
1260	const int roi = fAdcPhysical->isChecked() ? 1024 : (fEventData->Roi>0 ? fEventData->Roi : 1);
1261
1262	if ((hf && hf->GetNbinsX()!=roi) \|\|
1263	(dynamic_cast<TH2*>(h) && !fAdcPersistent->isChecked()) \|\|
1264	(!dynamic_cast<TH2*>(h) && fAdcPersistent->isChecked()))
1265	{
1266	delete hf;
1267	delete h;
1268	delete d0;
1269	delete d1;
1270	delete d2;
1271	d0 = 0;
1272	d1 = 0;
1273	d2 = 0;
1274	hf = 0;
1275	}
1276
1277	c->cd();
1278
1279	if (!hf)
1280	{
1281	hf = new TH1F("Frame", "", roi, -0.5, roi-0.5);
1282	hf->SetDirectory(0);
1283	hf->SetBit(kCanDelete);
1284	hf->SetStats(kFALSE);
1285	hf->SetYTitle("Voltage [mV]");
1286	hf->GetXaxis()->CenterTitle();
1287	hf->GetYaxis()->CenterTitle();
1288	hf->SetMinimum(-1250);
1289	hf->SetMaximum(2150);
1290
1291	if (!fAdcPersistent->isChecked())
1292	h = new TH1F("EventData", "", roi, -0.5, roi-0.5);
1293	else
1294	{
1295	h = new TH2F("EventData", "", roi, -0.5, roi-0.5, 6751, -2350.52000/4096, 4400.52000/4096);
1296	h->SetContour(50);
1297	gStyle->SetPalette(1, 0);
1298	}
1299
1300	h->SetDirectory(0);
1301	h->SetBit(kCanDelete);
1302	h->SetMarkerStyle(kFullDotMedium);
1303	h->SetMarkerColor(kBlue);
1304
1305	hf->Draw("");
1306
1307	if (dynamic_cast<TH2*>(h))
1308	h->Draw("col same");
1309	}
1310
1311	if (d0 && !(fDrsCalibBaselineOn->isChecked() && fDrsCalibBaseline->value()>0))
1312	{
1313	delete d0;
1314	d0 = 0;
1315	}
1316	if (d1 && !(fDrsCalibGainOn->isChecked() && fDrsCalibGain->value()>0))
1317	{
1318	delete d1;
1319	d1 = 0;
1320	}
1321	if (d2 && !(fDrsCalibTrgOffsetOn->isChecked() && fDrsCalibTrgOffset->value()>0))
1322	{
1323	delete d2;
1324	d2 = 0;
1325	}
1326
1327	if (!d0 && fDrsCalibBaselineOn->isChecked() && fDrsCalibBaseline->value()>0)
1328	{
1329	d0 = new TH1F("DrsCalib0", "", roi, -0.5, roi-0.5);
1330	d0->SetDirectory(0);
1331	d0->SetBit(kCanDelete);
1332	d0->SetMarkerStyle(kFullDotSmall);
1333	d0->SetMarkerColor(kRed);
1334	d0->SetLineColor(kRed);
1335	d0->Draw("PEX0same");
1336	}
1337
1338	if (!d1 && fDrsCalibGainOn->isChecked() && fDrsCalibGain->value()>0)
1339	{
1340	d1 = new TH1F("DrsCalib1", "", roi, -0.5, roi-0.5);
1341	d1->SetDirectory(0);
1342	d1->SetBit(kCanDelete);
1343	d1->SetMarkerStyle(kFullDotSmall);
1344	d1->SetMarkerColor(kMagenta);
1345	d1->SetLineColor(kMagenta);
1346	d1->Draw("PEX0same");
1347	}
1348
1349	if (!d2 && fDrsCalibTrgOffsetOn->isChecked() && fDrsCalibTrgOffset->value()>0)
1350	{
1351	d2 = new TH1F("DrsCalib2", "", roi, -0.5, roi-0.5);
1352	d2->SetDirectory(0);
1353	d2->SetBit(kCanDelete);
1354	d2->SetMarkerStyle(kFullDotSmall);
1355	d2->SetMarkerColor(kGreen);
1356	d2->SetLineColor(kGreen);
1357	d2->Draw("PEX0same");
1358	}
1359
1360	if (!dynamic_cast<TH2*>(h) && !c->GetListOfPrimitives()->FindObject(h))
1361	h->Draw("PLsame");
1362
1363	// -----------------------------------------------------------
1364
1365	const uint32_t p =
1366	fAdcChannel->value() +
1367	fAdcChip->value() * 9+
1368	fAdcBoard->value() * 36+
1369	fAdcCrate->value() *360;
1370
1371	ostringstream str;
1372	str << "CBPX = " << fAdcCrate->value() << '\|' << fAdcBoard->value() << '\|' << fAdcChip->value() << '\|' << fAdcChannel->value() << " (" << p << ")";
1373	str << " EventNum = " << fEventData->EventNum;
1374	str << " TriggerNum = " << fEventData->TriggerNum;
1375	str << " TriggerType = " << fEventData->TriggerType;
1376	str << " BoardTime = " << fEventData->BoardTime[fAdcBoard->value()+fAdcCrate->value()*10];
1377	str << " (" << Time(fEventData->PCTime, fEventData->PCUsec) << ")";
1378	hf->SetTitle(str.str().c_str());
1379	str.str("");
1380	str << "ADC Pipeline (start cell: " << fEventData->StartPix[p] << ")";
1381	hf->SetXTitle(str.str().c_str());
1382
1383	// -----------------------------------------------------------
1384
1385	const int16_t start = fEventData->StartPix[p];
1386
1387	fDrsCalibBaseline->setEnabled(fDrsCalibBaseline->value()>0);
1388	fDrsCalibGain->setEnabled(fDrsCalibGain->value()>0);
1389	fDrsCalibTrgOffset->setEnabled(fDrsCalibTrgOffset->value()>0);
1390
1391	if (d0)//fDrsCalibBaseline->value()==0 \|\| start<0)
1392	d0->Reset();
1393	if (d1)//fDrsCalibGain->value()==0 \|\| start<0)
1394	d1->Reset();
1395	if (d2)//fDrsCalibTrgOffset->value()==0 \|\| start<0)
1396	d2->Reset();
1397
1398	if (!dynamic_cast<TH2*>(h))
1399	h->Reset();
1400	if (d0)
1401	d0->SetEntries(0);
1402	if (d1)
1403	d1->SetEntries(0);
1404	if (d2)
1405	d2->SetEntries(0);
1406
1407	for (int i=0; i<fEventData->Roi; i++)
1408	{
1409	// FIXME: physcial: i -> (i+start)%1024
1410	// FIXME: logical: i -> i
1411
1412	const int ii = fAdcPhysical->isChecked() ? (i+start)%1024 : i;
1413
1414	//if (dynamic_cast<TH2*>(h))
1415	h->Fill(ii, reinterpret_cast<float>(fEventData->Adc_Data)[pfEventData->Roi+i]);
1416	//else
1417	// h->SetBinContent(i+1, reinterpret_cast<float>(fEventData->Adc_Data)[pfEventData->Roi+i]);
1418	if (start<0)
1419	continue;
1420
1421	if (d0)
1422	{
1423	d0->SetBinContent(ii+1, fDrsCalibration[144010240 + p*1024+(start+i)%1024]);
1424	d0->SetBinError(ii+1, fDrsCalibration[144010241 + p*1024+(start+i)%1024]);
1425
1426	}
1427	if (d1)
1428	{
1429	d1->SetBinContent(ii+1, fDrsCalibration[144010242 + p*1024+(start+i)%1024]);
1430	d1->SetBinError(ii+1, fDrsCalibration[144010243 + p*1024+(start+i)%1024]);
1431	}
1432	if (d2)
1433	{
1434	d2->SetBinContent(ii+1, fDrsCalibration[144010244 + p*1024 + i]);
1435	d2->SetBinError(ii+1, fDrsCalibration[144010245 + p*1024 + i]);
1436	}
1437	}
1438
1439	// -----------------------------------------------------------
1440	if (fAdcDynamicScale->isEnabled() && fAdcDynamicScale->isChecked())
1441	{
1442	h->SetMinimum();
1443	h->SetMaximum();
1444
1445	hf->SetMinimum(h->GetMinimum());
1446	hf->SetMaximum(h->GetMaximum());
1447	}
1448	if (fAdcManualScale->isEnabled() && fAdcManualScale->isChecked())
1449	{
1450	if (h->GetMinimumStored()==-1111)
1451	{
1452	h->SetMinimum(-1150);//-1026);
1453	hf->SetMinimum(-1150);//-1026);
1454	}
1455	if (h->GetMaximumStored()==-1111)
1456	{
1457	h->SetMaximum(2150);//1025);
1458	hf->SetMaximum(2150);//1025);
1459	}
1460	}
1461
1462	if (fAdcAutoScale->isEnabled() && fAdcAutoScale->isChecked())
1463	{
1464	h->SetMinimum();
1465	h->SetMaximum();
1466
1467	if (h->GetMinimum()<hf->GetMinimum())
1468	hf->SetMinimum(h->GetMinimum());
1469	if (h->GetMaximum()>hf->GetMaximum())
1470	hf->SetMaximum(h->GetMaximum());
1471	}
1472
1473	if (dynamic_cast<TH2*>(h))
1474	{
1475	h->SetMinimum();
1476	h->SetMaximum();
1477	}
1478
1479	// -----------------------------------------------------------
1480
1481	const int imin = ceil(hf->GetMinimum());
1482	const int imax = floor(hf->GetMaximum());
1483
1484	TH1S hd("", "", imax-imin+1, imin-0.5, imax+0.5);
1485	hd.SetDirectory(0);
1486	TH1S h0("", "", imax-imin+1, imin-0.5, imax+0.5);
1487	h0.SetDirectory(0);
1488	TH1S h1("", "", imax-imin+1, imin-0.5, imax+0.5);
1489	h1.SetDirectory(0);
1490	TH1S h2("", "", imax-imin+1, imin-0.5, imax+0.5);
1491	h2.SetDirectory(0);
1492	hd.SetLineColor(h->GetLineColor());
1493	if (d0)
1494	h0.SetLineColor(d0->GetLineColor());
1495	if (d1)
1496	h1.SetLineColor(d1->GetLineColor());
1497	if (d2)
1498	h2.SetLineColor(d2->GetLineColor());
1499
1500	for (int i=0; i<fEventData->Roi; i++)
1501	{
1502	if (!dynamic_cast<TH2*>(h))
1503	hd.Fill(h->GetBinContent(i+1));
1504	if (d0)
1505	h0.Fill(d0->GetBinContent(i+1));
1506	if (d1)
1507	h1.Fill(d1->GetBinContent(i+1));
1508	if (d2)
1509	h2.Fill(d2->GetBinContent(i+1));
1510	}
1511
1512	double mm = hd.GetMaximum(hd.GetEntries());
1513	if (h0.GetMaximum(h0.GetEntries())>mm)
1514	mm = h0.GetMaximum();
1515	if (h1.GetMaximum(h1.GetEntries())>mm)
1516	mm = h1.GetMaximum();
1517	if (h2.GetMaximum(h2.GetEntries())>mm)
1518	mm = h2.GetMaximum();
1519
1520	TIter Next(hf->GetListOfFunctions());
1521	TObject *obj = 0;
1522	while ((obj=Next()))
1523	if (dynamic_cast<TBox*>(obj))
1524	delete hf->GetListOfFunctions()->Remove(obj);
1525
1526	const double l = h->GetBinLowEdge(h->GetXaxis()->GetLast()+1);
1527	const double m = c->GetX2();
1528
1529	const double scale = 0.9*(m-l)/mm;
1530
1531	c->cd();
1532
1533	DrawHorizontal(hf, l, h2, scale);
1534	DrawHorizontal(hf, l, h1, scale);
1535	DrawHorizontal(hf, l, h0, scale);
1536	DrawHorizontal(hf, l, hd, scale);
1537
1538	// -----------------------------------------------------------
1539
1540	c->Modified();
1541	c->Update();
1542	#endif
1543	}
1544
1545	void handleFadRawData(const DimData &d)
1546	{
1547	if (d.size()==0)
1548	return;
1549
1550	if (fAdcStop->isChecked())
1551	return;
1552
1553	const EVENT &dat = d.ref<EVENT>();
1554
1555	if (d.size()<sizeof(EVENT))
1556	{
1557	cerr << "Size mismatch in " << d.name << ": Found=" << d.size() << " Expected>=" << sizeof(EVENT) << endl;
1558	return;
1559	}
1560
1561	if (d.size()!=sizeof(EVENT)+dat.Roi41440)
1562	{
1563	cerr << "Size mismatch in " << d.name << ": Found=" << d.size() << " Expected=" << dat.Roi41440+sizeof(EVENT) << " [roi=" << dat.Roi << "]" << endl;
1564	return;
1565	}
1566
1567	delete fEventData;
1568	fEventData = reinterpret_cast<EVENT*>(new char[d.size()]);
1569	memcpy(fEventData, d.ptr<void>(), d.size());
1570
1571	DisplayEventData();
1572	}
1573
1574	void handleFadEventData(const DimData &d)
1575	{
1576	if (!CheckSize(d, 41440sizeof(float)))
1577	return;
1578
1579	const float *ptr = d.ptr<float>();
1580
1581	valarray<double> arr1(1440);
1582	valarray<double> arr2(1440);
1583	valarray<double> arr3(1440);
1584	valarray<double> arr4(1440);
1585
1586	for (vector<PixelMapEntry>::const_iterator it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
1587	{
1588	arr1[it->index] = ptr[0*1440+it->hw()];
1589	arr2[it->index] = ptr[1*1440+it->hw()];
1590	arr3[it->index] = ptr[2*1440+it->hw()];
1591	arr4[it->index] = ptr[3*1440+it->hw()];
1592	}
1593
1594	fEventCanv1->SetData(arr1);
1595	fEventCanv2->SetData(arr2);
1596	fEventCanv3->SetData(arr3);
1597	fEventCanv4->SetData(arr4);
1598
1599	fEventCanv1->updateCamera();
1600	fEventCanv2->updateCamera();
1601	fEventCanv3->updateCamera();
1602	fEventCanv4->updateCamera();
1603	}
1604
1605	vector<float> fDrsCalibration;
1606
1607	void handleFadDrsCalibration(const DimData &d)
1608	{
1609	if (d.size()==0)
1610	{
1611	fDrsCalibBaseline->setValue(0);
1612	fDrsCalibGain->setValue(0);
1613	fDrsCalibTrgOffset->setValue(0);
1614	fDrsCalibration.assign(102414406, 0);
1615	DisplayEventData();
1616	return;
1617	}
1618
1619	if (!CheckSize(d, 102414406sizeof(float)+3sizeof(uint32_t)))
1620	// Do WHAT?
1621	return;
1622
1623	const uint32_t *run = d.ptr<uint32_t>();
1624
1625	fDrsCalibBaseline->setValue(run[0]);
1626	fDrsCalibGain->setValue(run[1]);
1627	fDrsCalibTrgOffset->setValue(run[2]);
1628
1629	const float dat = d.ptr<float>(sizeof(uint32_t)3);
1630	fDrsCalibration.assign(dat, dat+102414406);
1631
1632	DisplayEventData();
1633	}
1634
1635	// vector<uint8_t> fFadConnections;
1636
1637	void handleFadConnections(const DimData &d)
1638	{
1639	if (!CheckSize(d, 41))
1640	{
1641	fStatusEventBuilderLabel->setText("Offline");
1642	fStatusEventBuilderLabel->setToolTip("FADs or fadctrl seems to be offline.");
1643	fEvtBldWidget->setEnabled(false);
1644
1645	SetLedColor(fStatusEventBuilderLed, kLedGray, d.time);
1646	return;
1647	}
1648
1649	const uint8_t *ptr = d.ptr<uint8_t>();
1650
1651	for (int i=0; i<40; i++)
1652	{
1653	const uint8_t stat1 = ptr[i]&3;
1654	const uint8_t stat2 = ptr[i]>>3;
1655
1656	if (stat1==0 && stat2==0)
1657	{
1658	SetLedColor(fFadLED[i], kLedGray, d.time);
1659	continue;
1660	}
1661	if (stat1>=2 && stat2==8)
1662	{
1663	SetLedColor(fFadLED[i], stat1==2?kLedGreen:kLedGreenCheck, d.time);
1664	continue;
1665	}
1666
1667	if (stat1==1 && stat2==1)
1668	SetLedColor(fFadLED[i], kLedRed, d.time);
1669	else
1670	SetLedColor(fFadLED[i], kLedOrange, d.time);
1671	}
1672
1673
1674	const bool runs = ptr[40]!=0;
1675
1676	fStatusEventBuilderLabel->setText(runs?"Running":"Not running");
1677	fStatusEventBuilderLabel->setToolTip(runs?"Event builder thread running.":"Event builder thread stopped.");
1678	fEvtBldWidget->setEnabled(runs);
1679
1680	SetLedColor(fStatusEventBuilderLed, runs?kLedGreen:kLedRed, d.time);
1681
1682	// fFadConnections.assign(ptr, ptr+40);
1683	}
1684
1685	template<typename T>
1686	void handleFadToolTip(const Time &time, QWidget w, T ptr)
1687	{
1688	ostringstream tip;
1689	tip << "<table border='1'><tr><th colspan='11'>" << time.GetAsStr() << " (UTC)</th></tr><tr><th></th>";
1690	for (int b=0; b<10; b++)
1691	tip << "<th>" << b << "</th>";
1692	tip << "</tr>";
1693
1694	for (int c=0; c<4; c++)
1695	{
1696	tip << "<tr><th>" << c << "</th>";
1697	for (int b=0; b<10; b++)
1698	tip << "<td>" << ptr[c*10+b] << "</td>";
1699	tip << "</tr>";
1700	}
1701	tip << "</table>";
1702
1703	w->setToolTip(tip.str().c_str());
1704	}
1705
1706	template<typename T, class S>
1707	void handleFadMinMax(const DimData &d, QPushButton led, S wmin, S *wmax=0)
1708	{
1709	if (!CheckSize(d, 42*sizeof(T)))
1710	return;
1711
1712	const T *ptr = d.ptr<T>();
1713	const T min = ptr[40];
1714	const T max = ptr[41];
1715
1716	if (max==0 && min>max)
1717	SetLedColor(led, kLedGray, d.time);
1718	else
1719	SetLedColor(led, min==max?kLedGreen: kLedOrange, d.time);
1720
1721	if (!wmax && max!=min)
1722	wmin->setValue(0);
1723	else
1724	wmin->setValue(min);
1725
1726	if (wmax)
1727	wmax->setValue(max);
1728
1729	handleFadToolTip(d.time, led, ptr);
1730	}
1731
1732	void handleFadFwVersion(const DimData &d)
1733	{
1734	handleFadMinMax<float, QDoubleSpinBox>(d, fFadLedFwVersion, fFadFwVersion);
1735	}
1736
1737	void handleFadRunNumber(const DimData &d)
1738	{
1739	handleFadMinMax<uint32_t, QSpinBox>(d, fFadLedRunNumber, fFadRunNumber);
1740	}
1741
1742	void handleFadPrescaler(const DimData &d)
1743	{
1744	handleFadMinMax<uint16_t, QSpinBox>(d, fFadLedPrescaler, fFadPrescaler);
1745	}
1746
1747	void handleFadDNA(const DimData &d)
1748	{
1749	if (!CheckSize(d, 40*sizeof(uint64_t)))
1750	return;
1751
1752	const uint64_t *ptr = d.ptr<uint64_t>();
1753
1754	ostringstream tip;
1755	tip << "<table width='100%'>";
1756	tip << "<tr><th>Crate</th><td></td><th>Board</th><td></td><th>DNA</th></tr>";
1757
1758	for (int i=0; i<40; i++)
1759	{
1760	tip << dec;
1761	tip << "<tr>";
1762	tip << "<td align='center'>" << i/10 << "</td><td>:</td>";
1763	tip << "<td align='center'>" << i%10 << "</td><td>:</td>";
1764	tip << hex;
1765	tip << "<td>0x" << setfill('0') << setw(16) << ptr[i] << "</td>";
1766	tip << "</tr>";
1767	}
1768	tip << "</table>";
1769
1770	fFadDNA->setText(tip.str().c_str());
1771	}
1772
1773	void SetFadLed(QPushButton *led, const DimData &d, uint16_t bitmask, bool invert=false)
1774	{
1775	if (d.size()==0)
1776	{
1777	SetLedColor(led, kLedGray, d.time);
1778	return;
1779	}
1780
1781	const bool quality = d.ptr<uint16_t>()[0]&bitmask;
1782	const bool value = d.ptr<uint16_t>()[1]&bitmask;
1783	const uint16_t *ptr = d.ptr<uint16_t>()+2;
1784
1785	SetLedColor(led, quality?kLedOrange:(value^invert?kLedGreen:kLedGreenBar), d.time);
1786
1787	ostringstream tip;
1788	tip << "<table border='1'><tr><th colspan='11'>" << d.time.GetAsStr() << " (UTC)</th></tr><tr><th></th>";
1789	for (int b=0; b<10; b++)
1790	tip << "<th>" << b << "</th>";
1791	tip << "</tr>";
1792
1793	/*
1794	tip << "<tr>" << hex;
1795	tip << "<th>" << d.ptr<uint16_t>()[0] << " " << (d.ptr<uint16_t>()[0]&bitmask) << "</th>";
1796	tip << "<th>" << d.ptr<uint16_t>()[1] << " " << (d.ptr<uint16_t>()[1]&bitmask) << "</th>";
1797	tip << "</tr>";
1798	*/
1799
1800	for (int c=0; c<4; c++)
1801	{
1802	tip << "<tr><th>" << dec << c << "</th>" << hex;
1803	for (int b=0; b<10; b++)
1804	{
1805	tip << "<td>"
1806	<< (ptr[c*10+b]&bitmask)
1807	<< "</td>";
1808	}
1809	tip << "</tr>";
1810	}
1811	tip << "</table>";
1812
1813	led->setToolTip(tip.str().c_str());
1814	}
1815
1816	void handleFadStatus(const DimData &d)
1817	{
1818	if (d.size()!=0 && !CheckSize(d, 42*sizeof(uint16_t)))
1819	return;
1820
1821	SetFadLed(fFadLedDrsEnabled, d, FAD::EventHeader::kDenable);
1822	SetFadLed(fFadLedDrsWrite, d, FAD::EventHeader::kDwrite);
1823	SetFadLed(fFadLedDcmLocked, d, FAD::EventHeader::kDcmLocked);
1824	SetFadLed(fFadLedDcmReady, d, FAD::EventHeader::kDcmReady);
1825	SetFadLed(fFadLedSpiSclk, d, FAD::EventHeader::kSpiSclk);
1826	SetFadLed(fFadLedRefClockTooLow, d, FAD::EventHeader::kRefClkTooLow, true);
1827	SetFadLed(fFadLedBusyOn, d, FAD::EventHeader::kBusyOn);
1828	SetFadLed(fFadLedBusyOff, d, FAD::EventHeader::kBusyOff);
1829	SetFadLed(fFadLedTriggerLine, d, FAD::EventHeader::kTriggerLine);
1830	SetFadLed(fFadLedContTrigger, d, FAD::EventHeader::kContTrigger);
1831	SetFadLed(fFadLedSocket, d, FAD::EventHeader::kSock17);
1832	SetFadLed(fFadLedPllLock, d, 0xf000);
1833	}
1834
1835	void handleFadStatistics1(const DimData &d)
1836	{
1837	if (!CheckSize(d, sizeof(GUI_STAT)))
1838	return;
1839
1840	const GUI_STAT &stat = d.ref<GUI_STAT>();
1841
1842	/*
1843	//info about status of the main threads
1844	int32_t readStat ; //read thread
1845	int32_t procStat ; //processing thread(s)
1846	int32_t writStat ; //write thread
1847	*/
1848
1849	fFadBufferMax->setValue(stat.totMem/1000000);
1850	fFadBuffer->setMaximum(stat.totMem/100);
1851	fFadBuffer->setValue((stat.maxMem>stat.totMem?stat.totMem:stat.maxMem)/100); // Max mem used in last second
1852
1853	uint32_t sum = 0;
1854	int32_t min = 0x7fffff;
1855	int32_t max = 0;
1856
1857	int cnt = 0;
1858	int err = 0;
1859
1860	for (int i=0; i<40; i++)
1861	{
1862	if (stat.numConn[i]!=7)
1863	continue;
1864
1865	cnt++;
1866
1867	sum += stat.rateBytes[i];
1868	err += stat.errConn[i];
1869
1870	if (stat.rateBytes[i]<min)
1871	min = stat.rateBytes[i];
1872	if (stat.rateBytes[i]>max)
1873	max = stat.rateBytes[i];
1874	}
1875
1876	fFadEvtConn->setValue(cnt);
1877	fFadEvtConnErr->setValue(err);
1878
1879	fFadEvtBufNew->setValue(stat.bufNew); // Incomplete in buffer
1880	fFadEvtBufEvt->setValue(stat.bufEvt); // Complete in buffer
1881	fFadEvtBufMax->setValue(stat.maxEvt); // Complete in buffer
1882	fFadEvtWrite->setValue(stat.evtWrite-stat.evtSkip-stat.evtErr);
1883	fFadEvtSkip->setValue(stat.evtSkip);
1884	fFadEvtErr->setValue(stat.evtErr);
1885
1886	if (stat.deltaT==0)
1887	return;
1888
1889	fFadEthernetRateMin->setValue(min/stat.deltaT);
1890	fFadEthernetRateMax->setValue(max/stat.deltaT);
1891	fFadEthernetRateTot->setValue(sum/stat.deltaT);
1892	fFadEthernetRateAvg->setValue(cnt==0 ? 0 : sum/cnt/stat.deltaT);
1893	fFadEvtRateNew->setValue(1000*stat.rateNew/stat.deltaT);
1894	fFadEvtRateWrite->setValue(1000*stat.rateWrite/stat.deltaT);
1895
1896	fFadTransmission->setValue(fFadEvtRateNew->value());
1897	fFadEthernet->setValue(fFadEthernetRateTot->value());
1898	fFadWriteRate->setValue(fFadEvtRateWrite->value());
1899	}
1900
1901	void handleFadStatistics2(const DimData &d)
1902	{
1903	if (!CheckSize(d, sizeof(EVT_STAT)))
1904	return;
1905
1906	//const EVT_STAT &stat = d.ref<EVT_STAT>();
1907
1908	/*
1909	//some info about what happened since start of program (or last 'reset')
1910	uint32_t reset ; //#if increased, reset all counters
1911	uint32_t numRead[MAX_SOCK] ; //how often succesfull read from N sockets per loop
1912
1913	uint64_t gotByte[NBOARDS] ; //#Bytes read per Board
1914	uint32_t gotErr[NBOARDS] ; //#Communication Errors per Board
1915
1916	uint32_t evtGet; //#new Start of Events read
1917	uint32_t evtTot; //#complete Events read
1918
1919	uint32_t evtErr; //#Events with Errors
1920	uint32_t evtSkp; //#Events incomplete (timeout)
1921
1922
1923	uint32_t procTot; //#Events processed
1924	uint32_t procErr; //#Events showed problem in processing
1925	uint32_t procTrg; //#Events accepted by SW trigger
1926	uint32_t procSkp; //#Events rejected by SW trigger
1927
1928	uint32_t feedTot; //#Events used for feedBack system
1929	uint32_t feedErr; //#Events rejected by feedBack
1930
1931	uint32_t wrtTot; //#Events written to disk
1932	uint32_t wrtErr; //#Events with write-error
1933
1934	uint32_t runOpen; //#Runs opened
1935	uint32_t runClose; //#Runs closed
1936	uint32_t runErr; //#Runs with open/close errors
1937
1938
1939	//info about current connection status
1940	uint8_t numConn[NBOARDS] ; //#Sockets succesfully open per board
1941	*/
1942	}
1943
1944	// ===================== FTM ============================================
1945
1946	FTM::DimTriggerRates fTriggerRates;
1947
1948	void UpdateTriggerRate(const FTM::DimTriggerRates &sdata)
1949	{
1950	#ifdef HAVE_ROOT
1951	TCanvas *c = fFtmRateCanv->GetCanvas();
1952
1953	TH1 h = (TH1)c->FindObject("TimeFrame");
1954
1955	if (sdata.fTriggerRate<0)
1956	{
1957	fGraphFtmRate.Set(0);
1958
1959	const double tm = Time().RootTime();
1960
1961	h->SetBins(1, tm, tm+60);
1962	h->GetXaxis()->SetTimeFormat("%M'%S\"");
1963	h->GetXaxis()->SetTitle("Time");
1964
1965	c->Modified();
1966	c->Update();
1967	return;
1968	}
1969
1970	const double t1 = h->GetXaxis()->GetXmax();
1971	const double t0 = h->GetXaxis()->GetXmin();
1972
1973	const double now = t0+sdata.fTimeStamp/1000000.;
1974
1975	h->SetBins(h->GetNbinsX()+1, t0, now+1);
1976	fGraphFtmRate.SetPoint(fGraphFtmRate.GetN(), now, sdata.fTriggerRate);
1977
1978	if (t1-t0>300)
1979	{
1980	h->GetXaxis()->SetTimeFormat("%Hh%M'");
1981	h->GetXaxis()->SetTitle("Time");
1982	}
1983
1984	h->SetMinimum(0);
1985
1986	c->Modified();
1987	c->Update();
1988	#endif
1989	}
1990
1991	void UpdateRatesCam(const FTM::DimTriggerRates &sdata)
1992	{
1993	if (fThresholdIdx->value()>=0)
1994	{
1995	const int isw = fThresholdIdx->value();
1996	const int ihw = fPatchMapHW[isw];
1997	fPatchRate->setValue(sdata.fPatchRate[ihw]);
1998	fBoardRate->setValue(sdata.fBoardRate[ihw/4]);
1999	}
2000
2001	const bool b = fBoardRatesEnabled->isChecked();
2002
2003	valarray<double> dat(0., 1440);
2004
2005	// fPatch converts from software id to software patch id
2006	for (int i=0; i<1440; i++)
2007	{
2008	const int ihw = fPixelMap.index(i).hw()/9;
2009	dat[i] = b ? sdata.fBoardRate[ihw/4] : sdata.fPatchRate[ihw];
2010	}
2011
2012	fRatesCanv->SetData(dat);
2013	fRatesCanv->updateCamera();
2014	}
2015
2016	int64_t fTimeStamp0;
2017
2018	void on_fBoardRatesEnabled_toggled(bool)
2019	{
2020	UpdateRatesCam(fTriggerRates);
2021	}
2022
2023	void UpdateRatesGraphs(const FTM::DimTriggerRates &sdata)
2024	{
2025	#ifdef HAVE_ROOT
2026	if (fTimeStamp0<0)
2027	{
2028	fTimeStamp0 = sdata.fTimeStamp;
2029	return;
2030	}
2031
2032	TCanvas *c = fFtmRateCanv->GetCanvas();
2033
2034	TH1 h = (TH1)c->FindObject("TimeFrame");
2035
2036	const double tdiff = sdata.fTimeStamp-fTimeStamp0;
2037	fTimeStamp0 = sdata.fTimeStamp;
2038
2039	if (tdiff<0)
2040	{
2041	for (int i=0; i<160; i++)
2042	fGraphPatchRate[i].Set(0);
2043	for (int i=0; i<40; i++)
2044	fGraphBoardRate[i].Set(0);
2045
2046	return;
2047	}
2048
2049	//const double t1 = h->GetXaxis()->GetXmax();
2050	const double t0 = h->GetXaxis()->GetXmin();
2051
2052	for (int i=0; i<160; i++)
2053	if (fFtuStatus[i/4]>0)
2054	fGraphPatchRate[i].SetPoint(fGraphPatchRate[i].GetN(),
2055	t0+sdata.fTimeStamp/1000000., sdata.fPatchRate[i]);
2056	for (int i=0; i<40; i++)
2057	if (fFtuStatus[i]>0)
2058	fGraphBoardRate[i].SetPoint(fGraphBoardRate[i].GetN(),
2059	t0+sdata.fTimeStamp/1000000., sdata.fBoardRate[i]);
2060
2061	c->Modified();
2062	c->Update();
2063	#endif
2064	}
2065
2066	void handleFtmTriggerRates(const DimData &d)
2067	{
2068	if (!CheckSize(d, sizeof(FTM::DimTriggerRates)))
2069	return;
2070
2071	const FTM::DimTriggerRates &sdata = d.ref<FTM::DimTriggerRates>();
2072
2073	fFtmTime->setText(QString::number(sdata.fTimeStamp/1000000., 'f', 6)+ " s");
2074	fTriggerCounter->setText(QString::number(sdata.fTriggerCounter));
2075
2076	if (sdata.fTimeStamp>0)
2077	fTriggerCounterRate->setValue(1000000.*sdata.fTriggerCounter/sdata.fTimeStamp);
2078	else
2079	fTriggerCounterRate->setValue(0);
2080
2081	// ----------------------------------------------
2082
2083	fOnTime->setText(QString::number(sdata.fOnTimeCounter/1000000., 'f', 6)+" s");
2084
2085	if (sdata.fTimeStamp>0)
2086	fOnTimeRel->setValue(100.*sdata.fOnTimeCounter/sdata.fTimeStamp);
2087	else
2088	fOnTimeRel->setValue(0);
2089
2090	// ----------------------------------------------
2091
2092	UpdateTriggerRate(sdata);
2093	UpdateRatesGraphs(sdata);
2094	UpdateRatesCam(sdata);
2095
2096	fTriggerRates = sdata;
2097	}
2098
2099	void handleFtmCounter(const DimData &d)
2100	{
2101	if (!CheckSize(d, sizeof(uint32_t)*6))
2102	return;
2103
2104	const uint32_t *sdata = d.ptr<uint32_t>();
2105
2106	fFtmCounterH->setValue(sdata[0]);
2107	fFtmCounterS->setValue(sdata[1]);
2108	fFtmCounterD->setValue(sdata[2]);
2109	fFtmCounterF->setValue(sdata[3]);
2110	fFtmCounterE->setValue(sdata[4]);
2111	fFtmCounterR->setValue(sdata[5]);
2112	}
2113
2114	void handleFtmDynamicData(const DimData &d)
2115	{
2116	if (!CheckSize(d, sizeof(FTM::DimDynamicData)))
2117	return;
2118
2119	const FTM::DimDynamicData &sdata = d.ref<FTM::DimDynamicData>();
2120
2121	fFtmTemp0->setValue(sdata.fTempSensor[0]*0.1);
2122	fFtmTemp1->setValue(sdata.fTempSensor[1]*0.1);
2123	fFtmTemp2->setValue(sdata.fTempSensor[2]*0.1);
2124	fFtmTemp3->setValue(sdata.fTempSensor[3]*0.1);
2125
2126	SetLedColor(fClockCondLed, sdata.fState&FTM::kFtmLocked ? kLedGreen : kLedRed, d.time);
2127	}
2128
2129	void DisplayRates()
2130	{
2131	#ifdef HAVE_ROOT
2132	TCanvas *c = fFtmRateCanv->GetCanvas();
2133
2134	while (c->FindObject("PatchRate"))
2135	c->GetListOfPrimitives()->Remove(c->FindObject("PatchRate"));
2136
2137	while (c->FindObject("BoardRate"))
2138	c->GetListOfPrimitives()->Remove(c->FindObject("BoardRate"));
2139
2140	c->cd();
2141
2142	if (fRatePatch1->value()>=0)
2143	{
2144	fGraphPatchRate[fRatePatch1->value()].SetLineColor(kRed);
2145	fGraphPatchRate[fRatePatch1->value()].SetMarkerColor(kRed);
2146	fGraphPatchRate[fRatePatch1->value()].Draw("PL");
2147	}
2148	if (fRatePatch2->value()>=0)
2149	{
2150	fGraphPatchRate[fRatePatch2->value()].SetLineColor(kGreen);
2151	fGraphPatchRate[fRatePatch2->value()].SetMarkerColor(kGreen);
2152	fGraphPatchRate[fRatePatch2->value()].Draw("PL");
2153	}
2154	if (fRateBoard1->value()>=0)
2155	{
2156	fGraphBoardRate[fRateBoard1->value()].SetLineColor(kMagenta);
2157	fGraphBoardRate[fRateBoard1->value()].SetMarkerColor(kMagenta);
2158	fGraphBoardRate[fRateBoard1->value()].Draw("PL");
2159	}
2160	if (fRateBoard2->value()>=0)
2161	{
2162	fGraphBoardRate[fRateBoard2->value()].SetLineColor(kCyan);
2163	fGraphBoardRate[fRateBoard2->value()].SetMarkerColor(kCyan);
2164	fGraphBoardRate[fRateBoard2->value()].Draw("PL");
2165	}
2166
2167	c->Modified();
2168	c->Update();
2169	#endif
2170	}
2171
2172	FTM::DimStaticData fFtmStaticData;
2173
2174	void SetFtuLed(int idx, int counter, const Time &t)
2175	{
2176	if (counter==0 \|\| counter>3)
2177	counter = 3;
2178
2179	if (counter<0)
2180	counter = 0;
2181
2182	const LedColor_t col[4] = { kLedGray, kLedGreen, kLedOrange, kLedRed };
2183
2184	SetLedColor(fFtuLED[idx], col[counter], t);
2185
2186	fFtuStatus[idx] = counter;
2187	}
2188
2189	void SetFtuStatusLed(const Time &t)
2190	{
2191	const int max = fFtuStatus.max();
2192
2193	switch (max)
2194	{
2195	case 0:
2196	SetLedColor(fStatusFTULed, kLedGray, t);
2197	fStatusFTULabel->setText("All disabled");
2198	fStatusFTULabel->setToolTip("All FTUs are disabled");
2199	break;
2200
2201	case 1:
2202	SetLedColor(fStatusFTULed, kLedGreen, t);
2203	fStatusFTULabel->setToolTip("Communication with FTU is smooth.");
2204	fStatusFTULabel->setText("ok");
2205	break;
2206
2207	case 2:
2208	SetLedColor(fStatusFTULed, kLedOrange, t);
2209	fStatusFTULabel->setText("Warning");
2210	fStatusFTULabel->setToolTip("At least one FTU didn't answer immediately");
2211	break;
2212
2213	case 3:
2214	SetLedColor(fStatusFTULed, kLedRed, t);
2215	fStatusFTULabel->setToolTip("At least one FTU didn't answer!");
2216	fStatusFTULabel->setText("ERROR");
2217	break;
2218	}
2219
2220	const int cnt = count(&fFtuStatus[0], &fFtuStatus[40], 0);
2221	fFtuAllOn->setEnabled(cnt!=0);
2222	fFtuAllOff->setEnabled(cnt!=40);
2223	}
2224
2225	void handleFtmStaticData(const DimData &d)
2226	{
2227	if (!CheckSize(d, sizeof(FTM::DimStaticData)))
2228	return;
2229
2230	const FTM::DimStaticData &sdata = d.ref<FTM::DimStaticData>();
2231
2232	fTriggerInterval->setValue(sdata.fTriggerInterval);
2233	fPhysicsCoincidence->setValue(sdata.fMultiplicityPhysics);
2234	fCalibCoincidence->setValue(sdata.fMultiplicityCalib);
2235	fPhysicsWindow->setValue(sdata.fWindowPhysics);
2236	fCalibWindow->setValue(sdata.fWindowCalib);
2237
2238	fTriggerDelay->setValue(sdata.fDelayTrigger);
2239	fTimeMarkerDelay->setValue(sdata.fDelayTimeMarker);
2240	fDeadTime->setValue(sdata.fDeadTime);
2241
2242	fClockCondR0->setValue(sdata.fClockConditioner[0]);
2243	fClockCondR1->setValue(sdata.fClockConditioner[1]);
2244	fClockCondR8->setValue(sdata.fClockConditioner[2]);
2245	fClockCondR9->setValue(sdata.fClockConditioner[3]);
2246	fClockCondR11->setValue(sdata.fClockConditioner[4]);
2247	fClockCondR13->setValue(sdata.fClockConditioner[5]);
2248	fClockCondR14->setValue(sdata.fClockConditioner[6]);
2249	fClockCondR15->setValue(sdata.fClockConditioner[7]);
2250
2251	const uint32_t R0 = sdata.fClockConditioner[0];
2252	const uint32_t R14 = sdata.fClockConditioner[6];
2253	const uint32_t R15 = sdata.fClockConditioner[7];
2254
2255	const uint32_t Ndiv = (R15&0x1ffff00)<<2;
2256	const uint32_t Rdiv = (R14&0x007ff00)>>8;
2257	const uint32_t Cdiv = (R0 &0x000ff00)>>8;
2258
2259	double freq = 40.Ndiv/(RdivCdiv);
2260
2261	fClockCondFreqRes->setValue(freq);
2262
2263	//fClockCondFreq->setEditText("");
2264	fClockCondFreq->setCurrentIndex(0);
2265
2266	fTriggerSeqPed->setValue(sdata.fTriggerSeqPed);
2267	fTriggerSeqLPint->setValue(sdata.fTriggerSeqLPint);
2268	fTriggerSeqLPext->setValue(sdata.fTriggerSeqLPext);
2269
2270	fLpIntIntensity->setValue(sdata.fIntensityLPint);
2271	fLpExtIntensity->setValue(sdata.fIntensityLPext);
2272
2273	fLpIntGroup1->setChecked(sdata.HasLPintG1());
2274	fLpIntGroup2->setChecked(sdata.HasLPintG2());
2275	fLpExtGroup1->setChecked(sdata.HasLPextG1());
2276	fLpExtGroup2->setChecked(sdata.HasLPextG2());
2277
2278	fEnableTrigger->setChecked(sdata.HasTrigger());
2279	fEnableVeto->setChecked(sdata.HasVeto());
2280	fEnableExt1->setChecked(sdata.HasExt1());
2281	fEnableExt2->setChecked(sdata.HasExt2());
2282	fEnableClockCond->setChecked(sdata.HasClockConditioner());
2283
2284	uint16_t multiplicity = sdata.fMultiplicity[0];
2285
2286	for (int i=0; i<40; i++)
2287	{
2288	if (!sdata.IsActive(i))
2289	SetFtuLed(i, -1, d.time);
2290	else
2291	{
2292	if (fFtuStatus[i]==0)
2293	SetFtuLed(i, 1, d.time);
2294	}
2295	fFtuLED[i]->setChecked(false);
2296
2297	if (sdata.fMultiplicity[i]!=multiplicity)
2298	multiplicity = -1;
2299
2300	}
2301	SetFtuStatusLed(d.time);
2302
2303	fNoutof4Val->setValue(multiplicity);
2304
2305	for (vector<PixelMapEntry>::const_iterator it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
2306	fRatesCanv->SetEnable(it->index, sdata.IsEnabled(it->hw()));
2307
2308	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
2309	fPixelEnable->setChecked(sdata.IsEnabled(entry.hw()));
2310
2311	if (fThresholdIdx->value()>=0)
2312	{
2313	const int isw = fThresholdIdx->value();
2314	const int ihw = fPatchMapHW[isw];
2315	fThresholdVal->setValue(sdata.fThreshold[ihw]);
2316	}
2317
2318	fPrescalingVal->setValue(sdata.fPrescaling[0]);
2319
2320	fFtmStaticData = sdata;
2321	}
2322
2323	void handleFtmPassport(const DimData &d)
2324	{
2325	if (!CheckSize(d, sizeof(FTM::DimPassport)))
2326	return;
2327
2328	const FTM::DimPassport &sdata = d.ref<FTM::DimPassport>();
2329
2330	stringstream str1, str2;
2331	str1 << hex << "0x" << setfill('0') << setw(16) << sdata.fBoardId;
2332	str2 << sdata.fFirmwareId;
2333
2334	fFtmBoardId->setText(str1.str().c_str());
2335	fFtmFirmwareId->setText(str2.str().c_str());
2336	}
2337
2338	void handleFtmFtuList(const DimData &d)
2339	{
2340	if (!CheckSize(d, sizeof(FTM::DimFtuList)))
2341	return;
2342
2343	fFtuPing->setChecked(false);
2344
2345	const FTM::DimFtuList &sdata = d.ref<FTM::DimFtuList>();
2346
2347	stringstream str;
2348	str << "<table width='100%'>" << setfill('0');
2349	str << "<tr><th>Num</th><th></th><th>Addr</th><th></th><th>DNA</th></tr>";
2350	for (int i=0; i<40; i++)
2351	{
2352	str << "<tr>";
2353	str << "<td align='center'>" << dec << i << hex << "</td>";
2354	str << "<td align='center'>:</td>";
2355	str << "<td align='center'>0x" << setw(2) << (int)sdata.fAddr[i] << "</td>";
2356	str << "<td align='center'>:</td>";
2357	str << "<td align='center'>0x" << setw(16) << sdata.fDNA[i] << "</td>";
2358	str << "</tr>";
2359	}
2360	str << "</table>";
2361
2362	fFtuDNA->setText(str.str().c_str());
2363
2364	fFtuAnswersTotal->setValue(sdata.fNumBoards);
2365	fFtuAnswersCrate0->setValue(sdata.fNumBoardsCrate[0]);
2366	fFtuAnswersCrate1->setValue(sdata.fNumBoardsCrate[1]);
2367	fFtuAnswersCrate2->setValue(sdata.fNumBoardsCrate[2]);
2368	fFtuAnswersCrate3->setValue(sdata.fNumBoardsCrate[3]);
2369
2370	for (int i=0; i<40; i++)
2371	SetFtuLed(i, sdata.IsActive(i) ? sdata.fPing[i] : -1, d.time);
2372
2373	SetFtuStatusLed(d.time);
2374	}
2375
2376	void handleFtmError(const DimData &d)
2377	{
2378	if (!CheckSize(d, sizeof(FTM::DimError)))
2379	return;
2380
2381	const FTM::DimError &sdata = d.ref<FTM::DimError>();
2382
2383	SetFtuLed(sdata.fError.fDestAddress, sdata.fError.fNumCalls, d.time);
2384	SetFtuStatusLed(d.time);
2385
2386	// FIXME: Write to special window!
2387	//Out() << "Error:" << endl;
2388	//Out() << sdata.fError << endl;
2389	}
2390
2391	// ========================== FSC =======================================
2392
2393	void SetFscValue(QDoubleSpinBox *box, const DimData &d, int idx, bool enable)
2394	{
2395	//box->setEnabled(enable);
2396	if (!enable)
2397	{
2398	box->setToolTip(d.time.GetAsStr().c_str());
2399	return;
2400	}
2401
2402	ostringstream str;
2403	str << d.time << " -- " << d.get<float>() << "s";
2404
2405	box->setToolTip(str.str().c_str());
2406	box->setValue(d.get<float>(idx*4+4));
2407	}
2408
2409
2410	void handleFscTemp(const DimData &d)
2411	{
2412	const bool enable = d.size()>0 && CheckSize(d, 60*sizeof(float));
2413	if (!enable)
2414	return;
2415
2416	QDoubleSpinBox *boxes[] = {
2417	fTempCam00, fTempCam01,
2418	fTempCam10, fTempCam11, fTempCam12, fTempCam13, fTempCam14,
2419	fTempCam20, fTempCam21, fTempCam22, fTempCam23, fTempCam24, fTempCam25,
2420	fTempCam30, fTempCam31, fTempCam32, fTempCam33, fTempCam34,
2421	fTempCam40, fTempCam41, fTempCam42, fTempCam43, fTempCam44, fTempCam45,
2422	fTempCam50, fTempCam51, fTempCam52, fTempCam53, fTempCam54,
2423	fTempCam60, fTempCam61,
2424	// 0:b/f 1:b/f 2:b/f 3:b/f
2425	fTempCrate0back, fTempCrate0front,
2426	fTempCrate1back, fTempCrate1front,
2427	fTempCrate2back, fTempCrate2front,
2428	fTempCrate3back, fTempCrate3front,
2429	// 0:b/f 1:b/f 2:b/f 3:b/f
2430	fTempPS0back, fTempPS0front,
2431	fTempPS1back, fTempPS1front,
2432	fTempPS2back, fTempPS2front,
2433	fTempPS3back, fTempPS3front,
2434	// AUX PS: FTM t/b; FSC t/b
2435	fTempAuxFTMtop, fTempAuxFTMbottom,
2436	fTempAuxFSCtop, fTempAuxFSCbottom,
2437	// Backpanel: FTM t/b; FSC t/b
2438	fTempBackpanelFTMtop, fTempBackpanelFTMbottom,
2439	fTempBackpanelFSCtop, fTempBackpanelFSCbottom,
2440	// top front/back; bottom front/back
2441	fTempSwitchboxTopFront, fTempSwitchboxTopBack,
2442	fTempSwitchboxBottomFront, fTempSwitchboxBottomBack,
2443	};
2444
2445	for (int i=0; i<59; i++)
2446	SetFscValue(boxes[i], d, i, enable);
2447
2448	if (!enable)
2449	return;
2450
2451	const float *ptr = d.ptr<float>();
2452
2453	double avg = 0;
2454	int num = 0;
2455	for (int i=1; i<32; i++)
2456	if (ptr[i]!=0)
2457	{
2458	avg += ptr[i];
2459	num ++;
2460	}
2461
2462	fTempCamAvg->setValue(num?avg/num:0);
2463	}
2464
2465	void handleFscVolt(const DimData &d)
2466	{
2467	const bool enable = d.size()>0 && CheckSize(d, 31*sizeof(float));
2468	if (!enable)
2469	return;
2470
2471	QDoubleSpinBox *boxes[] = {
2472	fVoltFad00, fVoltFad10, fVoltFad20, fVoltFad30,
2473	fVoltFad01, fVoltFad11, fVoltFad21, fVoltFad31,
2474	fVoltFad02, fVoltFad12, fVoltFad22, fVoltFad32,
2475	fVoltFPA00, fVoltFPA10, fVoltFPA20, fVoltFPA30,
2476	fVoltFPA01, fVoltFPA11, fVoltFPA21, fVoltFPA31,
2477	fVoltFPA02, fVoltFPA12, fVoltFPA22, fVoltFPA32,
2478	fVoltETH0, fVoltETH1,
2479	fVoltFTM0, fVoltFTM1,
2480	fVoltFFC, fVoltFLP,
2481	};
2482
2483	for (int i=0; i<30; i++)
2484	SetFscValue(boxes[i], d, i, enable);
2485	}
2486
2487	void handleFscCurrent(const DimData &d)
2488	{
2489	const bool enable = d.size()>0 && CheckSize(d, 31*sizeof(float));
2490	if (!enable)
2491	return;
2492
2493	QDoubleSpinBox *boxes[] = {
2494	fAmpFad00, fAmpFad10, fAmpFad20, fAmpFad30,
2495	fAmpFad01, fAmpFad11, fAmpFad21, fAmpFad31,
2496	fAmpFad02, fAmpFad12, fAmpFad22, fAmpFad32,
2497	fAmpFPA00, fAmpFPA10, fAmpFPA20, fAmpFPA30,
2498	fAmpFPA01, fAmpFPA11, fAmpFPA21, fAmpFPA31,
2499	fAmpFPA02, fAmpFPA12, fAmpFPA22, fAmpFPA32,
2500	fAmpETH0, fAmpETH1,
2501	fAmpFTM0, fAmpFTM1,
2502	fAmpFFC, fAmpFLP,
2503	};
2504
2505	for (int i=0; i<30; i++)
2506	SetFscValue(boxes[i], d, i, enable);
2507	}
2508
2509	void handleFscHumidity(const DimData &d)
2510	{
2511	const bool enable = d.size()>0 && CheckSize(d, 5*sizeof(float));
2512
2513	SetFscValue(fHumidity1, d, 0, enable);
2514	SetFscValue(fHumidity2, d, 1, enable);
2515	SetFscValue(fHumidity3, d, 2, enable);
2516	SetFscValue(fHumidity4, d, 3, enable);
2517	}
2518
2519	// ========================== Feedback ==================================
2520
2521	#ifdef HAVE_ROOT
2522	TGraphErrors fGraphFeedbackDev;
2523	TGraphErrors fGraphFeedbackCmd;
2524
2525	void UpdateFeedback(TQtWidget &rwidget, const Time &time, TGraphErrors &graph, double avg, double rms)
2526	{
2527	TCanvas *c = rwidget.GetCanvas();
2528
2529	TH1 h = (TH1)c->FindObject("TimeFrame");
2530
2531	while (graph.GetN()>500)
2532	graph.RemovePoint(0);
2533
2534	const double now = time.RootTime();
2535
2536	while (graph.GetN()>0 && now-graph.GetX()[0]>3600)
2537	graph.RemovePoint(0);
2538
2539	const int n = graph.GetN();
2540
2541	const double xmin = n>0 ? graph.GetX()[0] : now;
2542
2543	h->SetBins(n+1, xmin-1, now+1);
2544	graph.SetPoint(n, now, avg);
2545	graph.SetPointError(n, 0, rms);
2546
2547	h->GetXaxis()->SetTimeFormat(now-xmin>300 ? "%Hh%M'" : "%M'%S\"");
2548
2549	c->Modified();
2550	c->Update();
2551	}
2552	#endif
2553
2554	void handleFeedbackDeviation(const DimData &d)
2555	{
2556	if (!CheckSize(d, 2416sizeof(float)))
2557	return;
2558
2559	const float *ptr = d.ptr<float>();
2560
2561	valarray<float> dev(1440);
2562	valarray<float> cmd(1440);
2563
2564	double avgdev = 0;
2565	double avgcmd = 0;
2566
2567	double rmsdev = 0;
2568	double rmscmd = 0;
2569
2570	for (int i=0; i<1440; i++)
2571	{
2572	const PixelMapEntry &entry = fPixelMap.index(i);
2573
2574	dev[i] = /1000/ptr[entry.hv()];
2575	cmd[i] = 1000*ptr[entry.hv()+416];
2576
2577	avgdev += dev[i];
2578	avgcmd += cmd[i];
2579
2580	rmsdev += dev[i]*dev[i];
2581	rmscmd += cmd[i]*cmd[i];
2582	}
2583
2584	avgdev /= 1440;
2585	avgcmd /= 1440;
2586
2587	rmsdev = sqrt(rmsdev/1440 - avgdev*avgdev);
2588	rmscmd = sqrt(rmscmd/1440 - avgcmd*avgcmd);
2589
2590	fFeedbackDevCam->SetData(dev);
2591	fFeedbackCmdCam->SetData(cmd);
2592
2593	fFeedbackDevCam->updateCamera();
2594	fFeedbackCmdCam->updateCamera();
2595
2596	#ifdef HAVE_ROOT
2597	UpdateFeedback(*fFeedbackDev, d.time, fGraphFeedbackDev, avgdev, rmsdev);
2598	UpdateFeedback(*fFeedbackCmd, d.time, fGraphFeedbackCmd, avgcmd, rmscmd);
2599	#endif
2600	}
2601
2602	void handleFeedbackReference(const DimData &d)
2603	{
2604	if (!CheckSize(d, 416*sizeof(float)))
2605	return;
2606
2607	const float *ptr = d.ptr<float>();
2608
2609	// fFeedbackRefCam->SetData(valarray<float>(ptr, 416));
2610	// fFeedbackRefCam->updateCamera();
2611	}
2612
2613	// ======================= Rate Scan ====================================
2614
2615	TGraph fGraphRateScan[201];
2616
2617	void UpdateRateScan(uint32_t th, const float *rates)
2618	{
2619	#ifdef HAVE_ROOT
2620	TCanvas *c = fRateScanCanv->GetCanvas();
2621
2622	TH1 h = (TH1)c->FindObject("Frame");
2623
2624	if (fGraphRateScan[0].GetN()==0 \|\| th<=fGraphRateScan[0].GetX()[0])
2625	{
2626	h->SetBins(1, th<10 ? 0 : th-10, th+10);
2627	h->SetMinimum(1);
2628	h->SetMaximum(rates[0]*2);
2629
2630	for (int i=0; i<201; i++)
2631	{
2632	fGraphRateScan[i].Set(0);
2633	fGraphRateScan[i].SetPoint(fGraphRateScan[i].GetN(), th, rates[i]);
2634	}
2635
2636	c->SetGrid();
2637	c->SetLogy();
2638
2639	c->Modified();
2640	c->Update();
2641	return;
2642	}
2643
2644	const double dac = h->GetXaxis()->GetXmin();
2645	h->SetBins(h->GetNbinsX()+1, dac, th+10);
2646
2647	for (int i=0; i<201; i++)
2648	fGraphRateScan[i].SetPoint(fGraphRateScan[i].GetN(), th, rates[i]);
2649
2650	c->Modified();
2651	c->Update();
2652	#endif
2653	}
2654
2655	void DisplayRateScan()
2656	{
2657	#ifdef HAVE_ROOT
2658	TCanvas *c = fRateScanCanv->GetCanvas();
2659
2660	while (c->FindObject("PatchRate"))
2661	c->GetListOfPrimitives()->Remove(c->FindObject("PatchRate"));
2662
2663	while (c->FindObject("BoardRate"))
2664	c->GetListOfPrimitives()->Remove(c->FindObject("BoardRate"));
2665
2666	c->cd();
2667
2668	if (fRateScanPatch1->value()>=0)
2669	{
2670	fGraphRateScan[fRateScanPatch1->value()+41].SetLineColor(kRed);
2671	fGraphRateScan[fRateScanPatch1->value()+41].SetMarkerColor(kRed);
2672	fGraphRateScan[fRateScanPatch1->value()+41].Draw("PL");
2673	}
2674	if (fRateScanPatch2->value()>=0)
2675	{
2676	fGraphRateScan[fRateScanPatch2->value()+41].SetLineColor(kGreen);
2677	fGraphRateScan[fRateScanPatch2->value()+41].SetMarkerColor(kGreen);
2678	fGraphRateScan[fRateScanPatch2->value()+41].Draw("PL");
2679	}
2680	if (fRateScanBoard1->value()>=0)
2681	{
2682	fGraphRateScan[fRateScanBoard1->value()+1].SetLineColor(kMagenta);
2683	fGraphRateScan[fRateScanBoard1->value()+1].SetMarkerColor(kMagenta);
2684	fGraphRateScan[fRateScanBoard1->value()+1].Draw("PL");
2685	}
2686	if (fRateScanBoard2->value()>=0)
2687	{
2688	fGraphRateScan[fRateScanBoard2->value()+1].SetLineColor(kCyan);
2689	fGraphRateScan[fRateScanBoard2->value()+1].SetMarkerColor(kCyan);
2690	fGraphRateScan[fRateScanBoard2->value()+1].Draw("PL");
2691	}
2692
2693	c->Modified();
2694	c->Update();
2695	#endif
2696	}
2697
2698	void handleRateScan(const DimData &d)
2699	{
2700	if (!CheckSize(d, 204*sizeof(float)))
2701	return;
2702
2703	UpdateRateScan(d.get<uint32_t>(), d.ptr<float>(12));
2704	}
2705
2706	// ========================== FSC =======================================
2707
2708	vector<int16_t> fVecBiasVolt;
2709	vector<int16_t> fVecBiasCurrent;
2710
2711	void handleBiasVolt(const DimData &d)
2712	{
2713	if (!CheckSize(d, 2416sizeof(int16_t)))
2714	return;
2715
2716	const int16_t *ptr = d.ptr<int16_t>();
2717
2718	fVecBiasVolt.assign(ptr, ptr+2*416);
2719
2720	on_fBiasDispRefVolt_stateChanged();
2721	UpdateBiasValues();
2722	}
2723
2724	void handleBiasCurrent(const DimData &d)
2725	{
2726	if (!CheckSize(d, 416*sizeof(int16_t)))
2727	return;
2728
2729	const int16_t *ptr = d.ptr<int16_t>();
2730
2731	fVecBiasCurrent.assign(ptr, ptr+416);
2732
2733	valarray<double> dat(0., 1440);
2734
2735	// fPatch converts from software id to software patch id
2736	for (int i=0; i<1440; i++)
2737	{
2738	const PixelMapEntry &entry = fPixelMap.index(i);
2739
2740	// FIXME: Display Overcurrent
2741	dat[i] = abs(ptr[entry.hv()])*5000./4096;
2742
2743	fBiasCamA->SetEnable(i, uint16_t(ptr[entry.hv()])!=0x8000);
2744	fBiasCamA->highlightPixel(i, ptr[entry.hv()]<0);
2745	}
2746
2747	fBiasCamA->SetData(dat);
2748	fBiasCamA->updateCamera();
2749
2750	UpdateBiasValues();
2751	}
2752
2753	// ====================== MessageImp ====================================
2754
2755	bool fChatOnline;
2756
2757	void handleStateChanged(const Time &time, const std::string &server,
2758	const State &s)
2759	{
2760	// FIXME: Prefix tooltip with time
2761	if (server=="MCP")
2762	{
2763	// FIXME: Enable FTU page!!!
2764	fStatusMCPLabel->setText(s.name.c_str());
2765	fStatusMCPLabel->setToolTip(s.comment.c_str());
2766
2767	if (s.index<2) // No Dim connection
2768	SetLedColor(fStatusMCPLed, kLedGray, time);
2769	if (s.index==2) // Disconnected
2770	SetLedColor(fStatusMCPLed, kLedRed, time);
2771	if (s.index==3) // Connecting
2772	SetLedColor(fStatusMCPLed, kLedOrange, time);
2773	if (s.index==4) // Connected
2774	SetLedColor(fStatusMCPLed, kLedYellow, time);
2775	if (s.index==5 \|\| s.index==10) // Idle
2776	SetLedColor(fStatusMCPLed, kLedGreen, time);
2777
2778	if (s.index>=7 && s.index<=9)
2779	SetLedColor(fStatusMCPLed, kLedGreenBar, time);
2780
2781	fMcpStartRun->setEnabled(s.index>=5);
2782	fMcpStopRun->setEnabled(s.index>=5);
2783	fMcpReset->setEnabled(s.index>=7 && s.index<=10);
2784	}
2785
2786	if (server=="FTM_CONTROL")
2787	{
2788	// FIXME: Enable FTU page!!!
2789	fStatusFTMLabel->setText(s.name.c_str());
2790	fStatusFTMLabel->setToolTip(s.comment.c_str());
2791
2792	bool enable = false;
2793	const bool configuring =
2794	s.index==FTM::StateMachine::kConfiguring1 \|\|
2795	s.index==FTM::StateMachine::kConfiguring2 \|\|
2796	s.index==FTM::StateMachine::kConfigured;
2797
2798	if (s.index<FTM::StateMachine::kDisconnected) // No Dim connection
2799	SetLedColor(fStatusFTMLed, kLedGray, time);
2800	if (s.index==FTM::StateMachine::kDisconnected) // Dim connection / FTM disconnected
2801	SetLedColor(fStatusFTMLed, kLedYellow, time);
2802	if (s.index==FTM::StateMachine::kConnected \|\|
2803	s.index==FTM::StateMachine::kIdle \|\|
2804	configuring) // Dim connection / FTM connected
2805	SetLedColor(fStatusFTMLed, kLedGreen, time);
2806	if (s.index==FTM::StateMachine::kTriggerOn) // Dim connection / FTM connected
2807	SetLedColor(fStatusFTMLed, kLedGreenCheck, time);
2808	if (s.index==FTM::StateMachine::kConnected \|\|
2809	s.index==FTM::StateMachine::kIdle) // Dim connection / FTM connected
2810	enable = true;
2811
2812	fFtmStartRun->setEnabled(!configuring && enable);
2813	fFtmStopRun->setEnabled(!configuring && (enable \|\| s.index==FTM::StateMachine::kTriggerOn));
2814
2815	fTriggerWidget->setEnabled(enable);
2816	fFtuGroupEnable->setEnabled(enable);
2817	fRatesControls->setEnabled(enable);
2818	fFtuWidget->setEnabled(s.index>FTM::StateMachine::kDisconnected);
2819
2820	if (s.index>=FTM::StateMachine::kConnected)
2821	SetFtuStatusLed(time);
2822	else
2823	{
2824	SetLedColor(fStatusFTULed, kLedGray, time);
2825	fStatusFTULabel->setText("Offline");
2826	fStatusFTULabel->setToolTip("FTM is not online.");
2827	}
2828	}
2829
2830	if (server=="FAD_CONTROL")
2831	{
2832	fStatusFADLabel->setText(s.name.c_str());
2833	fStatusFADLabel->setToolTip(s.comment.c_str());
2834
2835	bool enable = false;
2836
2837	if (s.index<FAD::kOffline) // No Dim connection
2838	{
2839	SetLedColor(fStatusFADLed, kLedGray, time);
2840
2841	// Timing problem - sometimes they stay gray :(
2842	//for (int i=0; i<40; i++)
2843	// SetLedColor(fFadLED[i], kLedGray, time);
2844
2845	/*
2846	fStatusEventBuilderLabel->setText("Offline");
2847	fStatusEventBuilderLabel->setToolTip("No connection to fadctrl.");
2848	fEvtBldWidget->setEnabled(false);
2849
2850	SetLedColor(fStatusEventBuilderLed, kLedGray, time);
2851	*/
2852	}
2853	if (s.index==FAD::kOffline) // Dim connection / FTM disconnected
2854	SetLedColor(fStatusFADLed, kLedRed, time);
2855	if (s.index==FAD::kDisconnected) // Dim connection / FTM disconnected
2856	SetLedColor(fStatusFADLed, kLedOrange, time);
2857	if (s.index==FAD::kConnecting) // Dim connection / FTM disconnected
2858	{
2859	SetLedColor(fStatusFADLed, kLedYellow, time);
2860	// FIXME FIXME FIXME: The LEDs are not displayed when disabled!
2861	enable = true;
2862	}
2863	if (s.index>=FAD::kConnected) // Dim connection / FTM connected
2864	{
2865	SetLedColor(fStatusFADLed, kLedGreen, time);
2866	enable = true;
2867	}
2868
2869	fFadWidget->setEnabled(enable);
2870
2871	fFadStart->setEnabled(s.index==FAD::kOffline);
2872	fFadStop->setEnabled(s.index>FAD::kOffline);
2873	fFadAbort->setEnabled(s.index>FAD::kOffline);
2874	fFadSoftReset->setEnabled(s.index>FAD::kOffline);
2875	fFadHardReset->setEnabled(s.index>FAD::kOffline);
2876	}
2877
2878	if (server=="FSC_CONTROL")
2879	{
2880	fStatusFSCLabel->setText(s.name.c_str());
2881	fStatusFSCLabel->setToolTip(s.comment.c_str());
2882
2883	bool enable = false;
2884
2885	if (s.index<1) // No Dim connection
2886	SetLedColor(fStatusFSCLed, kLedGray, time);
2887	if (s.index==1) // Dim connection / FTM disconnected
2888	SetLedColor(fStatusFSCLed, kLedRed, time);
2889	if (s.index>=2) // Dim connection / FTM disconnected
2890	{
2891	SetLedColor(fStatusFSCLed, kLedGreen, time);
2892	enable = true;
2893	}
2894
2895	fAuxWidget->setEnabled(enable);
2896	}
2897
2898	if (server=="BIAS_CONTROL")
2899	{
2900	fStatusBiasLabel->setText(s.name.c_str());
2901	fStatusBiasLabel->setToolTip(s.comment.c_str());
2902
2903	if (s.index<1) // No Dim connection
2904	SetLedColor(fStatusBiasLed, kLedGray, time);
2905	if (s.index==BIAS::kDisconnected) // Dim connection / FTM disconnected
2906	SetLedColor(fStatusBiasLed, kLedRed, time);
2907	if (s.index==BIAS::kConnecting \|\| s.index==BIAS::kInitializing) // Connecting / Initializing
2908	SetLedColor(fStatusBiasLed, kLedOrange, time);
2909	if (s.index==BIAS::kVoltageOff) // At reference
2910	SetLedColor(fStatusBiasLed, kLedGreenBar, time);
2911	if (s.index==BIAS::kNotReferenced) // At reference
2912	SetLedColor(fStatusBiasLed, kLedGreenWarn, time);
2913	if (s.index==BIAS::kRamping) // Ramping
2914	SetLedColor(fStatusBiasLed, kLedInProgress, time);
2915	if (s.index==BIAS::kVoltageOn) // At reference
2916	SetLedColor(fStatusBiasLed, kLedGreenCheck, time);
2917	if (s.index==BIAS::kOverCurrent) // Over current
2918	SetLedColor(fStatusBiasLed, kLedWarnBorder, time);
2919	if (s.index==BIAS::kExpertMode) // ExpertMode
2920	SetLedColor(fStatusBiasLed, kLedWarnTriangleBorder, time);
2921
2922	fBiasWidget->setEnabled(s.index>=3);
2923	}
2924
2925	if (server=="FEEDBACK")
2926	{
2927	fStatusFeedbackLabel->setText(s.name.c_str());
2928	fStatusFeedbackLabel->setToolTip(s.comment.c_str());
2929
2930	if (s.index>6) // Running
2931	SetLedColor(fStatusFeedbackLed, kLedGreenCheck, time);
2932	if (s.index==5 \|\| s.index==6) // Idle
2933	SetLedColor(fStatusFeedbackLed, kLedGreen, time);
2934	if (s.index==4) // Connected
2935	SetLedColor(fStatusFeedbackLed, kLedYellow, time);
2936	if (s.index==3) // Connecting
2937	SetLedColor(fStatusFeedbackLed, kLedOrange, time);
2938	if (s.index<3) // NoDim / Disconnected
2939	SetLedColor(fStatusFeedbackLed, kLedRed, time);
2940	if (s.index<1) // No Dim connection
2941	SetLedColor(fStatusFeedbackLed, kLedGray, time);
2942
2943	fFeedbackWidget->setEnabled(s.index>=3);
2944	fFeedbackStop->setEnabled(s.index>4);
2945	fFeedbackTempStart->setEnabled(s.index==4);
2946	fFeedbackTempOffset->setEnabled(s.index<=4);
2947	fFeedbackOutputEnable->setEnabled(s.index<=6);
2948	fFeedbackOutputDisable->setEnabled(s.index!=5 && s.index!=6);
2949
2950	fFeedbackFrameLeft->setEnabled(s.index!=5 && s.index!=7);
2951	fFeedbackCanvLeft->setEnabled(s.index!=5 && s.index!=7);
2952	}
2953
2954	if (server=="DATA_LOGGER")
2955	{
2956	fStatusLoggerLabel->setText(s.name.c_str());
2957	fStatusLoggerLabel->setToolTip(s.comment.c_str());
2958
2959	bool enable = true;
2960
2961	if (s.index<30) // Ready/Waiting
2962	SetLedColor(fStatusLoggerLed, kLedYellow, time);
2963	if (s.index==30) // Ready/Waiting
2964	SetLedColor(fStatusLoggerLed, kLedGreen, time);
2965	if (s.index<-1) // Offline
2966	{
2967	SetLedColor(fStatusLoggerLed, kLedGray, time);
2968	enable = false;
2969	}
2970	if (s.index>=0x100) // Error
2971	SetLedColor(fStatusLoggerLed, kLedRed, time);
2972	if (s.index==40) // Logging
2973	SetLedColor(fStatusLoggerLed, kLedGreen, time);
2974
2975	fLoggerWidget->setEnabled(enable);
2976	fLoggerStart->setEnabled(s.index>-1 && s.index<30);
2977	fLoggerStop->setEnabled(s.index>=30);
2978	}
2979
2980	if (server=="CHAT")
2981	{
2982	fStatusChatLabel->setText(s.name.c_str());
2983
2984	fChatOnline = s.index==0;
2985
2986	SetLedColor(fStatusChatLed, fChatOnline ? kLedGreen : kLedGray, time);
2987
2988	fChatSend->setEnabled(fChatOnline);
2989	fChatMessage->setEnabled(fChatOnline);
2990	}
2991
2992	if (server=="SCHEDULER")
2993	{
2994	fStatusSchedulerLabel->setText(s.name.c_str());
2995
2996	SetLedColor(fStatusSchedulerLed, s.index>=0 ? kLedGreen : kLedRed, time);
2997	}
2998	}
2999
3000	void on_fTabWidget_currentChanged(int which)
3001	{
3002	if (fTabWidget->tabText(which)=="Chat")
3003	fTabWidget->setTabIcon(which, QIcon());
3004	}
3005
3006	void handleWrite(const Time &time, const string &text, int qos)
3007	{
3008	stringstream out;
3009
3010	if (text.substr(0, 6)=="CHAT: ")
3011	{
3012	if (qos==MessageImp::kDebug)
3013	return;
3014
3015	out << "<font size='-1' color='navy'>[<B>";
3016	out << time.GetAsStr("%H:%M:%S");
3017	out << "</B>]</FONT> " << text.substr(6);
3018	fChatText->append(out.str().c_str());
3019
3020	if (fTabWidget->tabText(fTabWidget->currentIndex())=="Chat")
3021	return;
3022
3023	static int num = 0;
3024	if (num++<2)
3025	return;
3026
3027	for (int i=0; i<fTabWidget->count(); i++)
3028	if (fTabWidget->tabText(i)=="Chat")
3029	{
3030	fTabWidget->setTabIcon(i, QIcon(":/Resources/icons/warning 3.png"));
3031	break;
3032	}
3033
3034	return;
3035	}
3036
3037
3038	out << "<font style='font-family:monospace' color='";
3039
3040	switch (qos)
3041	{
3042	case kMessage: out << "black"; break;
3043	case kInfo: out << "green"; break;
3044	case kWarn: out << "#FF6600"; break;
3045	case kError: out << "maroon"; break;
3046	case kFatal: out << "maroon"; break;
3047	case kDebug: out << "navy"; break;
3048	default: out << "navy"; break;
3049	}
3050	out << "'>";
3051	out << time.GetAsStr("%H:%M:%S.%f").substr(0,12);
3052	out << " - " << text << "</font>";
3053
3054	fLogText->append(out.str().c_str());
3055
3056	if (qos>=kWarn && qos!=kDebug)
3057	fTextEdit->append(out.str().c_str());
3058	}
3059
3060	void IndicateStateChange(const Time &time, const std::string &server)
3061	{
3062	const State s = GetState(server, GetCurrentState(server));
3063
3064	QApplication::postEvent(this,
3065	new FunctionEvent(boost::bind(&FactGui::handleStateChanged, this, time, server, s)));
3066	}
3067
3068	int Write(const Time &time, const string &txt, int qos)
3069	{
3070	QApplication::postEvent(this,
3071	new FunctionEvent(boost::bind(&FactGui::handleWrite, this, time, txt, qos)));
3072
3073	return 0;
3074	}
3075
3076	// ====================== Dim infoHandler================================
3077
3078	void handleDimService(const string &txt)
3079	{
3080	fDimSvcText->append(txt.c_str());
3081	}
3082
3083	void infoHandlerService(DimInfo &info)
3084	{
3085	const string fmt = string(info.getFormat()).empty() ? "C" : info.getFormat();
3086
3087	stringstream dummy;
3088	const Converter conv(dummy, fmt, false);
3089
3090	const Time tm(info.getTimestamp(), info.getTimestampMillisecs()*1000);
3091
3092	stringstream out;
3093	out << "<font size'-1' color='navy'>[";
3094	out << tm.GetAsStr("%H:%M:%S.%f").substr(0,12);
3095	out << "]</font> <B>" << info.getName() << "</B> - ";
3096
3097	bool iserr = 2;
3098	if (!conv)
3099	{
3100	out << "Compilation of format string '" << fmt << "' failed!";
3101	}
3102	else
3103	{
3104	try
3105	{
3106	const string dat = info.getSize()==0 ? "<empty>" : conv.GetString(info.getData(), info.getSize());
3107	out << dat;
3108	iserr = info.getSize()==0;
3109	}
3110	catch (const runtime_error &e)
3111	{
3112	out << "Conversion to string failed!<pre>" << e.what() << "</pre>";
3113	}
3114	}
3115
3116	// srand(hash<string>()(string(info.getName())));
3117	// int bg = rand()&0xffffff;
3118
3119	int bg = hash<string>()(string(info.getName()));
3120
3121	// allow only light colors
3122	bg = ~(bg&0x1f1f1f)&0xffffff;
3123
3124	if (iserr==2)
3125	bg = 0xffffff;
3126
3127	stringstream bgcol;
3128	bgcol << hex << setfill('0') << setw(6) << bg;
3129
3130	const string col = iserr==0 ? "black" : (iserr==1 ? "#FF6600" : "black");
3131	const string str = "<table width='100%' bgcolor=#"+bgcol.str()+"><tr><td><font color='"+col+"'>"+out.str()+"</font></td></tr></table>";
3132
3133	QApplication::postEvent(this,
3134	new FunctionEvent(boost::bind(&FactGui::handleDimService, this, str)));
3135	}
3136
3137	void CallInfoHandler(void (FactGui::*handler)(const DimData&), const DimData &d)
3138	{
3139	fInHandler = true;
3140	(this->*handler)(d);
3141	fInHandler = false;
3142	}
3143
3144	/*
3145	void CallInfoHandler(const boost::function<void()> &func)
3146	{
3147	// This ensures that newly received values are not sent back to the emitter
3148	// because changing the value emits the valueChanged signal (or similar)
3149	fInHandler = true;
3150	func();
3151	fInHandler = false;
3152	}*/
3153
3154	void PostInfoHandler(void (FactGui::*handler)(const DimData&))
3155	{
3156	//const boost::function<void()> f = boost::bind(handler, this, DimData(getInfo()));
3157
3158	FunctionEvent *evt = new FunctionEvent(boost::bind(&FactGui::CallInfoHandler, this, handler, DimData(getInfo())));
3159	// FunctionEvent *evt = new FunctionEvent(boost::bind(&FactGui::CallInfoHandler, this, f));
3160	// FunctionEvent *evt = new FunctionEvent(boost::bind(handler, this, DimData(getInfo()))));
3161
3162	QApplication::postEvent(this, evt);
3163	}
3164
3165	void infoHandler()
3166	{
3167	// Initialize the time-stamp (what a weird workaround...)
3168	if (getInfo())
3169	getInfo()->getTimestamp();
3170
3171	if (getInfo()==&fDimDNS)
3172	return PostInfoHandler(&FactGui::handleDimDNS);
3173	#ifdef DEBUG_DIM
3174	cout << "HandleDimInfo " << getInfo()->getName() << endl;
3175	#endif
3176	if (getInfo()==&fDimLoggerStats)
3177	return PostInfoHandler(&FactGui::handleLoggerStats);
3178
3179	// if (getInfo()==&fDimFadFiles)
3180	// return PostInfoHandler(&FactGui::handleFadFiles);
3181
3182	if (getInfo()==&fDimFadWriteStats)
3183	return PostInfoHandler(&FactGui::handleFadWriteStats);
3184
3185	if (getInfo()==&fDimFadConnections)
3186	return PostInfoHandler(&FactGui::handleFadConnections);
3187
3188	if (getInfo()==&fDimFadFwVersion)
3189	return PostInfoHandler(&FactGui::handleFadFwVersion);
3190
3191	if (getInfo()==&fDimFadRunNumber)
3192	return PostInfoHandler(&FactGui::handleFadRunNumber);
3193
3194	if (getInfo()==&fDimFadDNA)
3195	return PostInfoHandler(&FactGui::handleFadDNA);
3196
3197	if (getInfo()==&fDimFadTemperature)
3198	return PostInfoHandler(&FactGui::handleFadTemperature);
3199
3200	if (getInfo()==&fDimFadRefClock)
3201	return PostInfoHandler(&FactGui::handleFadRefClock);
3202
3203	if (getInfo()==&fDimFadRoi)
3204	return PostInfoHandler(&FactGui::handleFadRoi);
3205
3206	if (getInfo()==&fDimFadDac)
3207	return PostInfoHandler(&FactGui::handleFadDac);
3208
3209	if (getInfo()==&fDimFadDrsCalibration)
3210	return PostInfoHandler(&FactGui::handleFadDrsCalibration);
3211
3212	if (getInfo()==&fDimFadPrescaler)
3213	return PostInfoHandler(&FactGui::handleFadPrescaler);
3214
3215	if (getInfo()==&fDimFadStatus)
3216	return PostInfoHandler(&FactGui::handleFadStatus);
3217
3218	if (getInfo()==&fDimFadStatistics1)
3219	return PostInfoHandler(&FactGui::handleFadStatistics1);
3220
3221	if (getInfo()==&fDimFadStatistics2)
3222	return PostInfoHandler(&FactGui::handleFadStatistics2);
3223
3224	if (getInfo()==&fDimFadEvents)
3225	return PostInfoHandler(&FactGui::handleFadEvents);
3226
3227	if (getInfo()==&fDimFadRuns)
3228	return PostInfoHandler(&FactGui::handleFadRuns);
3229
3230	if (getInfo()==&fDimFadStartRun)
3231	return PostInfoHandler(&FactGui::handleFadStartRun);
3232
3233	if (getInfo()==&fDimFadRawData)
3234	return PostInfoHandler(&FactGui::handleFadRawData);
3235
3236	if (getInfo()==&fDimFadEventData)
3237	return PostInfoHandler(&FactGui::handleFadEventData);
3238
3239	/*
3240	if (getInfo()==&fDimFadSetup)
3241	return PostInfoHandler(&FactGui::handleFadSetup);
3242	*/
3243	if (getInfo()==&fDimLoggerFilenameNight)
3244	return PostInfoHandler(&FactGui::handleLoggerFilenameNight);
3245
3246	if (getInfo()==&fDimLoggerNumSubs)
3247	return PostInfoHandler(&FactGui::handleLoggerNumSubs);
3248
3249	if (getInfo()==&fDimLoggerFilenameRun)
3250	return PostInfoHandler(&FactGui::handleLoggerFilenameRun);
3251
3252	if (getInfo()==&fDimFtmTriggerRates)
3253	return PostInfoHandler(&FactGui::handleFtmTriggerRates);
3254
3255	if (getInfo()==&fDimFtmCounter)
3256	return PostInfoHandler(&FactGui::handleFtmCounter);
3257
3258	if (getInfo()==&fDimFtmDynamicData)
3259	return PostInfoHandler(&FactGui::handleFtmDynamicData);
3260
3261	if (getInfo()==&fDimFtmPassport)
3262	return PostInfoHandler(&FactGui::handleFtmPassport);
3263
3264	if (getInfo()==&fDimFtmFtuList)
3265	return PostInfoHandler(&FactGui::handleFtmFtuList);
3266
3267	if (getInfo()==&fDimFtmStaticData)
3268	return PostInfoHandler(&FactGui::handleFtmStaticData);
3269
3270	if (getInfo()==&fDimFtmError)
3271	return PostInfoHandler(&FactGui::handleFtmError);
3272
3273	if (getInfo()==&fDimFscTemp)
3274	return PostInfoHandler(&FactGui::handleFscTemp);
3275
3276	if (getInfo()==&fDimFscVolt)
3277	return PostInfoHandler(&FactGui::handleFscVolt);
3278
3279	if (getInfo()==&fDimFscCurrent)
3280	return PostInfoHandler(&FactGui::handleFscCurrent);
3281
3282	if (getInfo()==&fDimFscHumidity)
3283	return PostInfoHandler(&FactGui::handleFscHumidity);
3284
3285	if (getInfo()==&fDimBiasVolt)
3286	return PostInfoHandler(&FactGui::handleBiasVolt);
3287
3288	if (getInfo()==&fDimBiasCurrent)
3289	return PostInfoHandler(&FactGui::handleBiasCurrent);
3290
3291	if (getInfo()==&fDimFeedbackReference)
3292	return PostInfoHandler(&FactGui::handleFeedbackReference);
3293
3294	if (getInfo()==&fDimFeedbackDeviation)
3295	return PostInfoHandler(&FactGui::handleFeedbackDeviation);
3296
3297	if (getInfo()==&fDimRateScan)
3298	return PostInfoHandler(&FactGui::handleRateScan);
3299
3300	// if (getInfo()==&fDimFadFiles)
3301	// return PostInfoHandler(&FactGui::handleFadFiles);
3302
3303	for (map<string,DimInfo*>::iterator i=fServices.begin(); i!=fServices.end(); i++)
3304	if (i->second==getInfo())
3305	{
3306	infoHandlerService(*i->second);
3307	return;
3308	}
3309
3310	DimNetwork::infoHandler();
3311	}
3312
3313
3314	// ======================================================================
3315
3316	bool event(QEvent *evt)
3317	{
3318	if (dynamic_cast<FunctionEvent*>(evt))
3319	return static_cast<FunctionEvent*>(evt)->Exec();
3320
3321	if (dynamic_cast<CheckBoxEvent*>(evt))
3322	{
3323	const QStandardItem &item = static_cast<CheckBoxEvent*>(evt)->item;
3324	const QStandardItem *par = item.parent();
3325	if (par)
3326	{
3327	const QString server = par->text();
3328	const QString service = item.text();
3329
3330	const string s = (server+'/'+service).toStdString();
3331
3332	if (item.checkState()==Qt::Checked)
3333	SubscribeService(s);
3334	else
3335	UnsubscribeService(s);
3336	}
3337	}
3338
3339	return MainWindow::event(evt); // unrecognized
3340	}
3341
3342	void on_fDimCmdSend_clicked()
3343	{
3344	const QString server = fDimCmdServers->currentIndex().data().toString();
3345	const QString command = fDimCmdCommands->currentIndex().data().toString();
3346	const QString arguments = fDimCmdLineEdit->displayText();
3347
3348	// FIXME: Sending a command exactly when the info Handler changes
3349	// the list it might lead to confusion.
3350	try
3351	{
3352	SendDimCommand(server.toStdString(), command.toStdString()+" "+arguments.toStdString());
3353	fTextEdit->append("<font color='green'>Command '"+server+'/'+command+"' successfully emitted.</font>");
3354	fDimCmdLineEdit->clear();
3355	}
3356	catch (const runtime_error &e)
3357	{
3358	stringstream txt;
3359	txt << e.what();
3360
3361	string buffer;
3362	while (getline(txt, buffer, '\n'))
3363	fTextEdit->append(("<font color='red'><pre>"+buffer+"</pre></font>").c_str());
3364	}
3365	}
3366
3367	#ifdef HAVE_ROOT
3368	void slot_RootEventProcessed(TObject obj, unsigned int evt, TCanvas canv)
3369	{
3370	// kMousePressEvent // TCanvas processed QEvent mousePressEvent
3371	// kMouseMoveEvent // TCanvas processed QEvent mouseMoveEvent
3372	// kMouseReleaseEvent // TCanvas processed QEvent mouseReleaseEvent
3373	// kMouseDoubleClickEvent // TCanvas processed QEvent mouseDoubleClickEvent
3374	// kKeyPressEvent // TCanvas processed QEvent keyPressEvent
3375	// kEnterEvent // TCanvas processed QEvent enterEvent
3376	// kLeaveEvent // TCanvas processed QEvent leaveEvent
3377
3378	if (dynamic_cast<TCanvas*>(obj))
3379	return;
3380
3381	TQtWidget tipped = static_cast<TQtWidget>(sender());
3382
3383	if (evt==11/kMouseReleaseEvent/)
3384	return;
3385
3386	if (evt==61/kMouseDoubleClickEvent/)
3387	return;
3388
3389	if (obj)
3390	{
3391	// Find the object which will get picked by the GetObjectInfo
3392	// due to buffer overflows in many root-versions
3393	// in TH1 and TProfile we have to work around and implement
3394	// our own GetObjectInfo which make everything a bit more
3395	// complicated.
3396	canv->cd();
3397	#if ROOT_VERSION_CODE > ROOT_VERSION(5,22,00)
3398	const char *objectInfo =
3399	obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
3400	#else
3401	const char objectInfo = dynamic_cast<TH1>(obj) ?
3402	"" : obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
3403	#endif
3404
3405	QString tipText;
3406	tipText += obj->GetName();
3407	tipText += " [";
3408	tipText += obj->ClassName();
3409	tipText += "]: ";
3410	tipText += objectInfo;
3411
3412	fStatusBar->showMessage(tipText, 3000);
3413	}
3414
3415	gSystem->DispatchOneEvent(kFALSE);
3416	//gSystem->ProcessEvents();
3417	//QWhatsThis::display(tipText)
3418	}
3419
3420	void slot_RootUpdate()
3421	{
3422	gSystem->DispatchOneEvent(kFALSE);
3423	//gSystem->ProcessEvents();
3424	QTimer::singleShot(10, this, SLOT(slot_RootUpdate()));
3425	}
3426	#endif
3427
3428	void ChoosePatchThreshold(Camera &cam, int isw)
3429	{
3430	cam.Reset();
3431
3432	fThresholdIdx->setValue(isw);
3433
3434	const int ihw = isw<0 ? 0 : fPatchMapHW[isw];
3435
3436	fPatchRate->setEnabled(isw>=0);
3437	fThresholdCrate->setEnabled(isw>=0);
3438	fThresholdBoard->setEnabled(isw>=0);
3439	fThresholdPatch->setEnabled(isw>=0);
3440
3441	if (isw<0)
3442	return;
3443
3444	const int patch = ihw%4;
3445	const int board = (ihw/4)%10;
3446	const int crate = (ihw/4)/10;
3447
3448	fInChoosePatchTH = true;
3449
3450	fThresholdCrate->setValue(crate);
3451	fThresholdBoard->setValue(board);
3452	fThresholdPatch->setValue(patch);
3453
3454	fInChoosePatchTH = false;
3455
3456	fThresholdVal->setValue(fFtmStaticData.fThreshold[ihw]);
3457	fPatchRate->setValue(fTriggerRates.fPatchRate[ihw]);
3458	fBoardRate->setValue(fTriggerRates.fBoardRate[ihw/4]);
3459
3460	// Loop over the software idx of all pixels
3461	// for (unsigned int i=0; i<1440; i++)
3462	// if (fPatchHW[i]==ihw)
3463	// cam.SetBold(i);
3464	}
3465
3466	/*
3467	void ChoosePatchBias(Camera &cam, int isw)
3468	{
3469	cam.Reset();
3470
3471	fBiasChannel->setValue(isw);
3472
3473	const int ihw = isw<0 ? 0 : fPatchMapHW[isw];
3474
3475	fBiasCurrent->setEnabled(isw>=0);
3476	fBiasCrate->setEnabled(isw>=0);
3477	fBiasBoard->setEnabled(isw>=0);
3478	fBiasPatch->setEnabled(isw>=0);
3479
3480	if (isw<0)
3481	return;
3482
3483	const int patch = ihw%4;
3484	const int board = (ihw/4)%10;
3485	const int crate = (ihw/4)/10;
3486
3487	fInChoosePatchBias = true;
3488
3489	fBiasCrate->setValue(crate);
3490	fBiasBoard->setValue(board);
3491	fBiasPatch->setValue(patch);
3492
3493	fInChoosePatchBias = false;
3494
3495	if (fVecBias.size()>0)
3496	{
3497	// FIXME: Mapping
3498	fBiasVoltDac->setValue(fVecBias[ihw]);
3499	fBiasVolt->setValue(fVecBias[ihw]*90./4096);
3500	}
3501
3502	fBiasCurrent->setValue(cam.GetData(isw));
3503
3504	// Loop over the software idx of all pixels
3505	for (unsigned int i=0; i<1440; i++)
3506	if (fPatchHW[i]==ihw)
3507	cam.SetBold(i);
3508	}*/
3509
3510	void slot_ChoosePixelThreshold(int isw)
3511	{
3512	fPixelIdx->setValue(isw);
3513
3514	const PixelMapEntry &entry = fPixelMap.index(isw);
3515	fPixelEnable->setChecked(fFtmStaticData.IsEnabled(entry.hw()));
3516	}
3517
3518	void slot_CameraDoubleClick(int isw)
3519	{
3520	fPixelIdx->setValue(isw);
3521
3522	const PixelMapEntry &entry = fPixelMap.index(isw);
3523	Dim::SendCommand("FTM_CONTROL/TOGGLE_PIXEL", uint16_t(entry.hw()));
3524	}
3525
3526	void slot_CameraMouseMove(int isw)
3527	{
3528	const PixelMapEntry &entry = fPixelMap.index(isw);
3529
3530	QString tipText;
3531	tipText += fRatesCanv->GetName();
3532	ostringstream str;
3533	str << setfill('0') <<
3534	" \|\| HW: " << entry.crate() << "\|" << entry.board() << "\|" << entry.patch() << "\|" << entry.pixel() << " (crate\|board\|patch\|pixel)" <<
3535	" \|\| HV: " << entry.hv_board << "\|" << setw(2) << entry.hv_channel << " (board\|channel)" <<
3536	" \|\| ID: " << isw;
3537
3538
3539	tipText += str.str().c_str();
3540	fStatusBar->showMessage(tipText, 3000);
3541	}
3542
3543	void on_fThresholdIdx_valueChanged(int isw)
3544	{
3545	// fRatesCanv->SetBold(isw);
3546	// fRatesCanv->updateGL();
3547	}
3548
3549	void UpdateThresholdIdx()
3550	{
3551	if (fInChoosePatchTH)
3552	return;
3553
3554	const int crate = fThresholdCrate->value();
3555	const int board = fThresholdBoard->value();
3556	const int patch = fThresholdPatch->value();
3557
3558	const int ihw = patch + board4 + crate40;
3559
3560	int isw = 0;
3561	for (; isw<160; isw++)
3562	if (ihw==fPatchMapHW[isw])
3563	break;
3564
3565	on_fThresholdIdx_valueChanged(isw);
3566	}
3567
3568	void on_fPixelIdx_valueChanged(int isw)
3569	{
3570	int ii = 0;
3571	for (; ii<160; ii++)
3572	if (fPixelMap.index(isw).hw()/9==fPatchMapHW[ii])
3573	break;
3574
3575	fRatesCanv->SetWhite(isw);
3576	ChoosePatchThreshold(*fRatesCanv, ii);
3577
3578	const PixelMapEntry &entry = fPixelMap.index(isw);
3579	fPixelEnable->setChecked(fFtmStaticData.IsEnabled(entry.hw()));
3580	}
3581
3582	// ------------------- Bias display ---------------------
3583
3584	void UpdateBiasValues()
3585	{
3586	const int b = fBiasHvBoard->value();
3587	const int c = fBiasHvChannel->value();
3588
3589	const int ihw = b*32+c;
3590
3591	if (fVecBiasVolt.size()>0)
3592	{
3593	fBiasVoltCur->setValue(fVecBiasVolt[ihw]*90./4096);
3594	fBiasVoltRef->setValue(fVecBiasVolt[ihw+416]*90./4096);
3595
3596	SetLedColor(fBiasNominalLed,
3597	fVecBiasVolt[ihw]==fVecBiasVolt[ihw+416]?kLedGreen:kLedRed, Time());
3598	}
3599
3600	if (fVecBiasCurrent.size()>0)
3601	{
3602	fBiasCurrent->setValue(abs(fVecBiasCurrent[ihw])*5000./4096);
3603	SetLedColor(fBiasOverCurrentLed,
3604	fVecBiasCurrent[ihw]<0?kLedRed:kLedGreen, Time());
3605	}
3606	}
3607
3608	void UpdateBiasCam(const PixelMapEntry &entry)
3609	{
3610	fInChooseBiasCam = true;
3611
3612	fBiasCamCrate->setValue(entry.crate());
3613	fBiasCamBoard->setValue(entry.board());
3614	fBiasCamPatch->setValue(entry.patch());
3615	fBiasCamPixel->setValue(entry.pixel());
3616
3617	fInChooseBiasCam = false;
3618	}
3619
3620	void BiasHvChannelChanged()
3621	{
3622	if (fInChooseBiasHv)
3623	return;
3624
3625	const int b = fBiasHvBoard->value();
3626	const int ch = fBiasHvChannel->value();
3627
3628	// FIXME: Mark corresponding patch in camera
3629	const PixelMapEntry &entry = fPixelMap.hv(b, ch);
3630	fBiasCamV->SetWhite(entry.index);
3631	fBiasCamA->SetWhite(entry.index);
3632	fBiasCamV->updateCamera();
3633	fBiasCamA->updateCamera();
3634
3635	UpdateBiasCam(entry);
3636	UpdateBiasValues();
3637	}
3638
3639	void UpdateBiasHv(const PixelMapEntry &entry)
3640	{
3641	fInChooseBiasHv = true;
3642
3643	fBiasHvBoard->setValue(entry.hv_board);
3644	fBiasHvChannel->setValue(entry.hv_channel);
3645
3646	fInChooseBiasHv = false;
3647	}
3648
3649	void BiasCamChannelChanged()
3650	{
3651	if (fInChooseBiasCam)
3652	return;
3653
3654	const int crate = fBiasCamCrate->value();
3655	const int board = fBiasCamBoard->value();
3656	const int patch = fBiasCamPatch->value();
3657	const int pixel = fBiasCamPixel->value();
3658
3659	// FIXME: Display corresponding patches
3660	const PixelMapEntry &entry = fPixelMap.cbpx(crate, board, patch, pixel);
3661	fBiasCamV->SetWhite(entry.index);
3662	fBiasCamA->SetWhite(entry.index);
3663	fBiasCamV->updateCamera();
3664	fBiasCamA->updateCamera();
3665
3666	UpdateBiasHv(entry);
3667	UpdateBiasValues();
3668	}
3669
3670	void slot_ChooseBiasChannel(int isw)
3671	{
3672	const PixelMapEntry &entry = fPixelMap.index(isw);
3673
3674	UpdateBiasHv(entry);
3675	UpdateBiasCam(entry);
3676	UpdateBiasValues();
3677	}
3678
3679	void on_fBiasDispRefVolt_stateChanged(int = 0)
3680	{
3681	// FIXME: Display patches for which ref==cur
3682
3683	valarray<double> dat(0., 1440);
3684
3685	int offset = 0;
3686	if (!fBiasDispRefVolt->isChecked())
3687	fBiasCamV->setTitle("Applied BIAS voltage");
3688	else
3689	{
3690	fBiasCamV->setTitle("Reference BIAS voltage");
3691	offset = 416;
3692	}
3693
3694	if (fVecBiasVolt.size()>0)
3695	{
3696	for (int i=0; i<1440; i++)
3697	{
3698	const PixelMapEntry &entry = fPixelMap.index(i);
3699	dat[i] = fVecBiasVolt[entry.hv()+offset]*90./4096;
3700
3701	fBiasCamV->highlightPixel(i, fVecBiasVolt[entry.hv()]!=fVecBiasVolt[entry.hv()+416]);
3702	}
3703
3704	fBiasCamV->SetData(dat);
3705	}
3706
3707	fBiasCamV->updateCamera();
3708	}
3709
3710	// ------------------------------------------------------
3711
3712	void on_fPixelEnable_stateChanged(int b)
3713	{
3714	if (fInHandler)
3715	return;
3716
3717	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
3718
3719	Dim::SendCommand(b==Qt::Unchecked ?
3720	"FTM_CONTROL/DISABLE_PIXEL" : "FTM_CONTROL/ENABLE_PIXEL",
3721	uint16_t(entry.hw()));
3722	}
3723
3724	void on_fPixelDisableOthers_clicked()
3725	{
3726	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
3727	Dim::SendCommand("FTM_CONTROL/DISABLE_ALL_PIXELS_EXCEPT", uint16_t(entry.hw()));
3728	}
3729
3730	void on_fThresholdDisableOthers_clicked()
3731	{
3732	const int16_t isw = fThresholdIdx->value();
3733	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3734	if (ihw<0)
3735	return;
3736
3737	Dim::SendCommand("FTM_CONTROL/DISABLE_ALL_PATCHES_EXCEPT", ihw);
3738	}
3739
3740	void on_fThresholdEnablePatch_clicked()
3741	{
3742	const int16_t isw = fThresholdIdx->value();
3743	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3744	if (ihw<0)
3745	return;
3746
3747	Dim::SendCommand("FTM_CONTROL/ENABLE_PATCH", ihw);
3748	}
3749
3750	void on_fThresholdDisablePatch_clicked()
3751	{
3752	const int16_t isw = fThresholdIdx->value();
3753	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3754	if (ihw<0)
3755	return;
3756
3757	Dim::SendCommand("FTM_CONTROL/DISABLE_PATCH", ihw);
3758	}
3759
3760	void on_fThresholdVal_valueChanged(int v)
3761	{
3762	fThresholdVolt->setValue(2500./4095*v);
3763
3764	const int32_t isw = fThresholdIdx->value();
3765	const int32_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3766
3767	const int32_t d[2] = { ihw, v };
3768
3769	if (!fInHandler)
3770	Dim::SendCommand("FTM_CONTROL/SET_THRESHOLD", d);
3771	}
3772
3773	TGraph fGraphFtmTemp[4];
3774	TGraph fGraphFtmRate;
3775	TGraph fGraphPatchRate[160];
3776	TGraph fGraphBoardRate[40];
3777
3778	#ifdef HAVE_ROOT
3779	TH1 DrawTimeFrame(const char ytitle)
3780	{
3781	const double tm = Time().RootTime();
3782
3783	TH1F *h=new TH1F("TimeFrame", "", 1, tm, tm+60);//Time().RootTime()-1./24/60/60, Time().RootTime());
3784	h->SetDirectory(0);
3785	h->SetBit(kCanDelete);
3786	h->SetStats(kFALSE);
3787	// h.SetMinimum(0);
3788	// h.SetMaximum(1);
3789	h->SetXTitle("Time");
3790	h->SetYTitle(ytitle);
3791	h->GetXaxis()->CenterTitle();
3792	h->GetYaxis()->CenterTitle();
3793	h->GetXaxis()->SetTimeDisplay(true);
3794	h->GetXaxis()->SetTimeFormat("%Mh%S'");
3795	h->GetXaxis()->SetLabelSize(0.025);
3796	h->GetYaxis()->SetLabelSize(0.025);
3797	h->GetYaxis()->SetTitleOffset(1.2);
3798	// h.GetYaxis()->SetTitleSize(1.2);
3799	h->Draw();
3800
3801	return h;
3802	}
3803	#endif
3804
3805	pair<string,string> Split(const string &str) const
3806	{
3807	const size_t p = str.find_first_of('\|');
3808	if (p==string::npos)
3809	return make_pair(str, "");
3810
3811	return make_pair(str.substr(0, p), str.substr(p+1));
3812	}
3813
3814	public:
3815	FactGui(Configuration &conf) :
3816	fFtuStatus(40),
3817	/fPixelMapHW(1440),/ fPatchMapHW(160),
3818	fInChoosePatchTH(false),
3819	fInChooseBiasHv(false), fInChooseBiasCam(false),
3820	fDimDNS("DIS_DNS/VERSION_NUMBER", 1, int(0), this),
3821	//-
3822	fDimLoggerStats ("DATA_LOGGER/STATS", (void*)NULL, 0, this),
3823	fDimLoggerFilenameNight("DATA_LOGGER/FILENAME_NIGHTLY", (void*)NULL, 0, this),
3824	fDimLoggerFilenameRun ("DATA_LOGGER/FILENAME_RUN", (void*)NULL, 0, this),
3825	fDimLoggerNumSubs ("DATA_LOGGER/NUM_SUBS", (void*)NULL, 0, this),
3826	//-
3827	fDimFtmPassport ("FTM_CONTROL/PASSPORT", (void*)NULL, 0, this),
3828	fDimFtmTriggerRates ("FTM_CONTROL/TRIGGER_RATES", (void*)NULL, 0, this),
3829	fDimFtmError ("FTM_CONTROL/ERROR", (void*)NULL, 0, this),
3830	fDimFtmFtuList ("FTM_CONTROL/FTU_LIST", (void*)NULL, 0, this),
3831	fDimFtmStaticData ("FTM_CONTROL/STATIC_DATA", (void*)NULL, 0, this),
3832	fDimFtmDynamicData ("FTM_CONTROL/DYNAMIC_DATA", (void*)NULL, 0, this),
3833	fDimFtmCounter ("FTM_CONTROL/COUNTER", (void*)NULL, 0, this),
3834	//-
3835	fDimFadWriteStats ("FAD_CONTROL/STATS", (void*)NULL, 0, this),
3836	fDimFadStartRun ("FAD_CONTROL/START_RUN", (void*)NULL, 0, this),
3837	fDimFadRuns ("FAD_CONTROL/RUNS", (void*)NULL, 0, this),
3838	fDimFadEvents ("FAD_CONTROL/EVENTS", (void*)NULL, 0, this),
3839	fDimFadRawData ("FAD_CONTROL/RAW_DATA", (void*)NULL, 0, this),
3840	fDimFadEventData ("FAD_CONTROL/EVENT_DATA", (void*)NULL, 0, this),
3841	fDimFadConnections ("FAD_CONTROL/CONNECTIONS", (void*)NULL, 0, this),
3842	fDimFadFwVersion ("FAD_CONTROL/FIRMWARE_VERSION", (void*)NULL, 0, this),
3843	fDimFadRunNumber ("FAD_CONTROL/RUN_NUMBER", (void*)NULL, 0, this),
3844	fDimFadDNA ("FAD_CONTROL/DNA", (void*)NULL, 0, this),
3845	fDimFadTemperature ("FAD_CONTROL/TEMPERATURE", (void*)NULL, 0, this),
3846	fDimFadPrescaler ("FAD_CONTROL/PRESCALER", (void*)NULL, 0, this),
3847	fDimFadRefClock ("FAD_CONTROL/REFERENCE_CLOCK", (void*)NULL, 0, this),
3848	fDimFadRoi ("FAD_CONTROL/REGION_OF_INTEREST", (void*)NULL, 0, this),
3849	fDimFadDac ("FAD_CONTROL/DAC", (void*)NULL, 0, this),
3850	fDimFadDrsCalibration ("FAD_CONTROL/DRS_CALIBRATION", (void*)NULL, 0, this),
3851	fDimFadStatus ("FAD_CONTROL/STATUS", (void*)NULL, 0, this),
3852	fDimFadStatistics1 ("FAD_CONTROL/STATISTICS1", (void*)NULL, 0, this),
3853	fDimFadStatistics2 ("FAD_CONTROL/STATISTICS2", (void*)NULL, 0, this),
3854	//-
3855	fDimFscTemp ("FSC_CONTROL/TEMPERATURE", (void*)NULL, 0, this),
3856	fDimFscVolt ("FSC_CONTROL/VOLTAGE", (void*)NULL, 0, this),
3857	fDimFscCurrent ("FSC_CONTROL/CURRENT", (void*)NULL, 0, this),
3858	fDimFscHumidity ("FSC_CONTROL/HUMIDITY", (void*)NULL, 0, this),
3859	//-
3860	fDimBiasVolt ("BIAS_CONTROL/VOLTAGE", (void*)NULL, 0, this),
3861	fDimBiasCurrent ("BIAS_CONTROL/CURRENT", (void*)NULL, 0, this),
3862	//-
3863	fDimFeedbackDeviation ("FEEDBACK/DEVIATION", (void*)NULL, 0, this),
3864	fDimFeedbackReference ("FEEDBACK/REFERENCE", (void*)NULL, 0, this),
3865	//-
3866	fDimRateScan ("RATE_SCAN/DATA", (void*)NULL, 0, this),
3867	//-
3868	fEventData(0), fDrsCalibration(144010246),
3869	fTimeStamp0(0)
3870	{
3871	fClockCondFreq->addItem("--- Hz", QVariant(-1));
3872	fClockCondFreq->addItem("800 MHz", QVariant(800));
3873	fClockCondFreq->addItem("1 GHz", QVariant(1000));
3874	fClockCondFreq->addItem("2 GHz", QVariant(2000));
3875	fClockCondFreq->addItem("3 GHz", QVariant(3000));
3876	fClockCondFreq->addItem("4 GHz", QVariant(4000));
3877	fClockCondFreq->addItem("5 GHz", QVariant(5000));
3878
3879	cout << "-- run counter ---" << endl;
3880	fMcpNumEvents->addItem("unlimited", QVariant(0));
3881	const vector<uint32_t> runcount = conf.Vec<uint32_t>("run-count");
3882	for (vector<uint32_t>::const_iterator it=runcount.begin(); it!=runcount.end(); it++)
3883	{
3884	cout << *it << endl;
3885	ostringstream str;
3886	str << *it;
3887	fMcpNumEvents->addItem(str.str().c_str(), QVariant(*it));
3888	}
3889
3890	cout << "-- run times ---" << endl;
3891	fMcpTime->addItem("unlimited", QVariant(0));
3892	const vector<string> runtime = conf.Vec<string>("run-time");
3893	for (vector<string>::const_iterator it=runtime.begin(); it!=runtime.end(); it++)
3894	{
3895	const pair<string,string> p = Split(*it);
3896	cout << *it << "\|" << p.second << "\|" << p.first << "\|" << endl;
3897	fMcpTime->addItem(p.second.c_str(), QVariant(stoi(p.first)));
3898	}
3899
3900	cout << "-- run types ---" << endl;
3901	const vector<string> runtype = conf.Vec<string>("run-type");
3902	for (vector<string>::const_iterator it=runtype.begin(); it!=runtype.end(); it++)
3903	{
3904	const pair<string,string> p = Split(*it);
3905	cout << *it << "\|" << p.second << "\|" << p.first << "\|" << endl;
3906	fMcpRunType->addItem(p.second.c_str(), QVariant(p.first.c_str()));
3907	}
3908
3909	fTriggerWidget->setEnabled(false);
3910	fFtuWidget->setEnabled(false);
3911	fFtuGroupEnable->setEnabled(false);
3912	fRatesControls->setEnabled(false);
3913	fFadWidget->setEnabled(false);
3914	fEvtBldWidget->setEnabled(false);
3915	fLoggerWidget->setEnabled(false);
3916	fBiasWidget->setEnabled(false);
3917	fAuxWidget->setEnabled(false);
3918
3919	fChatSend->setEnabled(false);
3920	fChatMessage->setEnabled(false);
3921
3922	DimClient::sendCommand("CHAT/MSG", "GUI online.");
3923	// + MessageDimRX
3924
3925	// --------------------------------------------------------------------------
3926
3927	if (!fPixelMap.Read(conf.Get<string>("pixel-map-file")))
3928	{
3929	cerr << "ERROR - Problems reading " << conf.Get<string>("pixel-map-file") << endl;
3930	exit(-1);
3931	}
3932
3933	// --------------------------------------------------------------------------
3934
3935	/*
3936	ifstream fin1("Trigger-Patches.txt");
3937
3938	string buf;
3939
3940	int l = 0;
3941	while (getline(fin1, buf, '\n'))
3942	{
3943	buf = Tools::Trim(buf);
3944	if (buf[0]=='#')
3945	continue;
3946
3947	stringstream str(buf);
3948	for (int i=0; i<9; i++)
3949	{
3950	unsigned int n;
3951	str >> n;
3952
3953	if (n>=fPatchHW.size())
3954	continue;
3955
3956	fPatchHW[n] = l;
3957	}
3958	l++;
3959	}
3960
3961	if (l!=160)
3962	cerr << "WARNING - Problems reading Trigger-Patches.txt" << endl;
3963	*/
3964	// --------------------------------------------------------------------------
3965
3966	/*
3967	ifstream fin2("MasterList-v3.txt");
3968
3969	l = 0;
3970
3971	while (getline(fin2, buf, '\n'))
3972	{
3973	buf = Tools::Trim(buf);
3974	if (buf[0]=='#')
3975	continue;
3976
3977	unsigned int softid, hardid, dummy;
3978
3979	stringstream str(buf);
3980
3981	str >> softid;
3982	str >> dummy;
3983	str >> hardid;
3984
3985	if (softid>=fPixelMapHW.size())
3986	continue;
3987
3988	fPixelMapHW[softid] = hardid;
3989
3990	l++;
3991	}
3992
3993	if (l!=1440)
3994	cerr << "WARNING - Problems reading MasterList-v3.txt" << endl;
3995	*/
3996	// --------------------------------------------------------------------------
3997
3998	ifstream fin3("PatchList.txt");
3999
4000	string buf;
4001
4002	int l = 0;
4003	while (getline(fin3, buf, '\n'))
4004	{
4005	buf = Tools::Trim(buf);
4006	if (buf[0]=='#')
4007	continue;
4008
4009	unsigned int softid, hardid;
4010
4011	stringstream str(buf);
4012
4013	str >> softid;
4014	str >> hardid;
4015
4016	if (softid>=fPatchMapHW.size())
4017	continue;
4018
4019	fPatchMapHW[softid] = hardid-1;
4020
4021	l++;
4022	}
4023
4024	if (l!=160)
4025	cerr << "WARNING - Problems reading PatchList.txt" << endl;
4026
4027	// --------------------------------------------------------------------------
4028	#ifdef HAVE_ROOT
4029
4030	fGraphFeedbackDev.SetLineColor(kBlue);
4031	fGraphFeedbackDev.SetMarkerColor(kBlue);
4032	fGraphFeedbackDev.SetMarkerStyle(kFullDotMedium);
4033
4034	fGraphFeedbackCmd.SetLineColor(kBlue);
4035	fGraphFeedbackCmd.SetMarkerColor(kBlue);
4036	fGraphFeedbackCmd.SetMarkerStyle(kFullDotMedium);
4037
4038	// Evolution of control deviation
4039	// Evolution of command values (bias voltage change)
4040	fGraphFeedbackDev.SetName("ControlDev");
4041	fGraphFeedbackCmd.SetName("CommandVal");
4042
4043	TCanvas *c = fFeedbackDev->GetCanvas();
4044	c->SetBorderMode(0);
4045	c->SetFrameBorderMode(0);
4046	c->SetFillColor(kWhite);
4047	c->SetRightMargin(0.03);
4048	c->SetTopMargin(0.03);
4049	c->SetGrid();
4050	c->cd();
4051
4052	TH1 *hf = DrawTimeFrame("Control deviation [mV] ");
4053	hf->GetXaxis()->SetLabelSize(0.07);
4054	hf->GetYaxis()->SetLabelSize(0.07);
4055	hf->GetYaxis()->SetTitleSize(0.08);
4056	hf->GetYaxis()->SetTitleOffset(0.55);
4057	hf->GetXaxis()->SetTitle("");
4058	hf->GetYaxis()->SetRangeUser(-99, 99);
4059
4060	fGraphFeedbackDev.Draw("LP");
4061
4062	c = fFeedbackCmd->GetCanvas();
4063	c->SetBorderMode(0);
4064	c->SetFrameBorderMode(0);
4065	c->SetFillColor(kWhite);
4066	c->SetRightMargin(0.03);
4067	c->SetTopMargin(0.03);
4068	c->SetGrid();
4069	c->cd();
4070
4071	hf = DrawTimeFrame("Command delta value [mV] ");
4072	hf->GetXaxis()->SetLabelSize(0.07);
4073	hf->GetYaxis()->SetLabelSize(0.07);
4074	hf->GetYaxis()->SetTitleSize(0.08);
4075	hf->GetYaxis()->SetTitleOffset(0.55);
4076	hf->GetXaxis()->SetTitle("");
4077	hf->GetYaxis()->SetRangeUser(-9910, 9910);
4078
4079	fGraphFeedbackCmd.Draw("LP");
4080
4081	// --------------------------------------------------------------------------
4082
4083	c = fRateScanCanv->GetCanvas();
4084	//c->SetBit(TCanvas::kNoContextMenu);
4085	c->SetBorderMode(0);
4086	c->SetFrameBorderMode(0);
4087	c->SetFillColor(kWhite);
4088	c->SetRightMargin(0.03);
4089	c->SetTopMargin(0.03);
4090	c->SetGrid();
4091	c->cd();
4092
4093	TH1F *h=new TH1F("Frame", "", 1, 0, 1);
4094	h->SetDirectory(0);
4095	h->SetBit(kCanDelete);
4096	h->SetStats(kFALSE);
4097	h->SetXTitle("Threshold [DAC]");
4098	h->SetYTitle("Rate [Hz]");
4099	h->GetXaxis()->CenterTitle();
4100	h->GetYaxis()->CenterTitle();
4101	h->GetXaxis()->SetLabelSize(0.025);
4102	h->GetYaxis()->SetLabelSize(0.025);
4103	h->GetYaxis()->SetTitleOffset(1.2);
4104	h->Draw();
4105
4106	fGraphRateScan[0].SetName("CameraRate");
4107	for (int i=0; i<40; i++)
4108	{
4109	fGraphRateScan[i+1].SetName("BoardRate");
4110	fGraphRateScan[i+1].SetMarkerStyle(kFullDotMedium);
4111	}
4112	for (int i=0; i<160; i++)
4113	{
4114	fGraphRateScan[i+41].SetName("PatchRate");
4115	fGraphRateScan[i+41].SetMarkerStyle(kFullDotMedium);
4116	}
4117
4118	fGraphRateScan[0].SetLineColor(kBlue);
4119	fGraphRateScan[0].SetMarkerColor(kBlue);
4120	fGraphRateScan[0].SetMarkerStyle(kFullDotSmall);
4121	fGraphRateScan[0].Draw("LP");
4122
4123	// --------------------------------------------------------------------------
4124
4125	c = fFtmRateCanv->GetCanvas();
4126	//c->SetBit(TCanvas::kNoContextMenu);
4127	c->SetBorderMode(0);
4128	c->SetFrameBorderMode(0);
4129	c->SetFillColor(kWhite);
4130	c->SetRightMargin(0.03);
4131	c->SetTopMargin(0.03);
4132	c->SetGrid();
4133	c->cd();
4134
4135	hf = DrawTimeFrame("Trigger rate [Hz]");
4136	hf->GetYaxis()->SetRangeUser(0, 1010);
4137
4138	for (int i=0; i<160; i++)
4139	{
4140	fGraphPatchRate[i].SetName("PatchRate");
4141	//fGraphPatchRate[i].SetLineColor(kBlue);
4142	//fGraphPatchRate[i].SetMarkerColor(kBlue);
4143	fGraphPatchRate[i].SetMarkerStyle(kFullDotMedium);
4144	}
4145	for (int i=0; i<40; i++)
4146	{
4147	fGraphBoardRate[i].SetName("BoardRate");
4148	//fGraphBoardRate[i].SetLineColor(kBlue);
4149	//fGraphBoardRate[i].SetMarkerColor(kBlue);
4150	fGraphBoardRate[i].SetMarkerStyle(kFullDotMedium);
4151	}
4152
4153	fGraphFtmRate.SetLineColor(kBlue);
4154	fGraphFtmRate.SetMarkerColor(kBlue);
4155	fGraphFtmRate.SetMarkerStyle(kFullDotSmall);
4156	fGraphFtmRate.Draw("LP");
4157
4158	/*
4159	TCanvas *c = fFtmTempCanv->GetCanvas();
4160	c->SetBit(TCanvas::kNoContextMenu);
4161	c->SetBorderMode(0);
4162	c->SetFrameBorderMode(0);
4163	c->SetFillColor(kWhite);
4164	c->SetRightMargin(0.03);
4165	c->SetTopMargin(0.03);
4166	c->cd();
4167	*/
4168	//CreateTimeFrame("Temperature / �C");
4169
4170	fGraphFtmTemp[0].SetMarkerStyle(kFullDotSmall);
4171	fGraphFtmTemp[1].SetMarkerStyle(kFullDotSmall);
4172	fGraphFtmTemp[2].SetMarkerStyle(kFullDotSmall);
4173	fGraphFtmTemp[3].SetMarkerStyle(kFullDotSmall);
4174
4175	fGraphFtmTemp[1].SetLineColor(kBlue);
4176	fGraphFtmTemp[2].SetLineColor(kRed);
4177	fGraphFtmTemp[3].SetLineColor(kGreen);
4178
4179	fGraphFtmTemp[1].SetMarkerColor(kBlue);
4180	fGraphFtmTemp[2].SetMarkerColor(kRed);
4181	fGraphFtmTemp[3].SetMarkerColor(kGreen);
4182
4183	//fGraphFtmTemp[0].Draw("LP");
4184	//fGraphFtmTemp[1].Draw("LP");
4185	//fGraphFtmTemp[2].Draw("LP");
4186	//fGraphFtmTemp[3].Draw("LP");
4187
4188	// --------------------------------------------------------------------------
4189
4190	c = fAdcDataCanv->GetCanvas();
4191	//c->SetBit(TCanvas::kNoContextMenu);
4192	c->SetBorderMode(0);
4193	c->SetFrameBorderMode(0);
4194	c->SetFillColor(kWhite);
4195	c->SetRightMargin(0.10);
4196	c->SetGrid();
4197	//c->cd();
4198	#endif
4199
4200	// --------------------------------------------------------------------------
4201	fFeedbackDevCam->assignPixelMap(fPixelMap);
4202	fFeedbackDevCam->setAutoscaleLowerLimit((fFeedbackDevMin->minimum()+0.5*fFeedbackDevMin->singleStep()));
4203	fFeedbackDevCam->SetMin(fFeedbackDevMin->value());
4204	fFeedbackDevCam->SetMax(fFeedbackDevMax->value());
4205	fFeedbackDevCam->updateCamera();
4206
4207	fFeedbackCmdCam->assignPixelMap(fPixelMap);
4208	fFeedbackCmdCam->setAutoscaleLowerLimit((fFeedbackCmdMin->minimum()+0.5*fFeedbackCmdMin->singleStep()));
4209	fFeedbackCmdCam->SetMin(fFeedbackCmdMin->value());
4210	fFeedbackCmdCam->SetMax(fFeedbackCmdMax->value());
4211	fFeedbackCmdCam->updateCamera();
4212
4213	// --------------------------------------------------------------------------
4214
4215	fBiasCamV->assignPixelMap(fPixelMap);
4216	fBiasCamV->setAutoscaleLowerLimit((fBiasVoltMin->minimum()+0.5*fBiasVoltMin->singleStep()));
4217	fBiasCamV->SetMin(fBiasVoltMin->value());
4218	fBiasCamV->SetMax(fBiasVoltMax->value());
4219	fBiasCamV->updateCamera();
4220
4221	fBiasCamA->assignPixelMap(fPixelMap);
4222	fBiasCamA->setAutoscaleLowerLimit((fBiasCurrentMin->minimum()+0.5*fBiasCurrentMin->singleStep()));
4223	fBiasCamA->SetMin(fBiasCurrentMin->value());
4224	fBiasCamA->SetMax(fBiasCurrentMax->value());
4225	fBiasCamA->updateCamera();
4226
4227	// --------------------------------------------------------------------------
4228
4229	fRatesCanv->assignPixelMap(fPixelMap);
4230	fRatesCanv->setAutoscaleLowerLimit((fRatesMin->minimum()+0.5fRatesMin->singleStep())0.001);
4231	fRatesCanv->SetMin(fRatesMin->value());
4232	fRatesCanv->SetMax(fRatesMax->value());
4233	fRatesCanv->updateCamera();
4234	on_fPixelIdx_valueChanged(0);
4235
4236	// --------------------------------------------------------------------------
4237
4238	fRatesCanv->setTitle("Patch rates");
4239	fRatesCanv->setUnits("Hz");
4240
4241	fBiasCamA->setTitle("BIAS current");
4242	fBiasCamA->setUnits("uA");
4243
4244	fBiasCamV->setTitle("Applied BIAS voltage");
4245	fBiasCamV->setUnits("V");
4246
4247	fEventCanv1->setTitle("Average (all slices)");
4248	fEventCanv2->setTitle("RMS (all slices)");
4249	fEventCanv3->setTitle("Maximum (all slices)");
4250	fEventCanv4->setTitle("Position of maximum (all slices)");
4251
4252	fEventCanv1->setUnits("mV");
4253	fEventCanv2->setUnits("mV");
4254	fEventCanv3->setUnits("mV");
4255	fEventCanv4->setUnits("slice");
4256
4257	// --------------------------------------------------------------------------
4258
4259	fFeedbackDevCam->setTitle("Control deviation (Pulser amplitude voltage)");
4260	fFeedbackCmdCam->setTitle("Applied voltage change (BIAS voltage)");
4261
4262	fFeedbackDevCam->setUnits("mV");
4263	fFeedbackCmdCam->setUnits("mV");
4264
4265	// --------------------------------------------------------------------------
4266
4267	QTimer::singleShot(1000, this, SLOT(slot_RootUpdate()));
4268
4269	//widget->setMouseTracking(true);
4270	//widget->EnableSignalEvents(kMouseMoveEvent);
4271
4272	fFtmRateCanv->setMouseTracking(true);
4273	fFtmRateCanv->EnableSignalEvents(kMouseMoveEvent);
4274
4275	fAdcDataCanv->setMouseTracking(true);
4276	fAdcDataCanv->EnableSignalEvents(kMouseMoveEvent);
4277
4278	fRatesCanv->setMouseTracking(true);
4279	fEventCanv1->setMouseTracking(true);
4280	fEventCanv2->setMouseTracking(true);
4281	fEventCanv3->setMouseTracking(true);
4282	fEventCanv4->setMouseTracking(true);
4283
4284	fBiasCamV->setMouseTracking(true);
4285	fBiasCamA->setMouseTracking(true);
4286
4287	fFeedbackDevCam->setMouseTracking(true);
4288	fFeedbackCmdCam->setMouseTracking(true);
4289
4290	fEventCanv1->ShowPixelCursor(true);
4291	fEventCanv2->ShowPixelCursor(true);
4292	fEventCanv3->ShowPixelCursor(true);
4293	fEventCanv4->ShowPixelCursor(true);
4294
4295	fEventCanv1->ShowPatchCursor(true);
4296	fEventCanv2->ShowPatchCursor(true);
4297	fEventCanv3->ShowPatchCursor(true);
4298	fEventCanv4->ShowPatchCursor(true);
4299
4300	fFeedbackDevCam->ShowPixelCursor(true);
4301	fFeedbackCmdCam->ShowPixelCursor(true);
4302
4303	fFeedbackDevCam->ShowPatchCursor(true);
4304	fFeedbackCmdCam->ShowPatchCursor(true);
4305
4306	connect(fRatesCanv, SIGNAL(signalPixelMoveOver(int)),
4307	this, SLOT(slot_CameraMouseMove(int)));
4308	connect(fEventCanv1, SIGNAL(signalPixelMoveOver(int)),
4309	this, SLOT(slot_CameraMouseMove(int)));
4310	connect(fEventCanv2, SIGNAL(signalPixelMoveOver(int)),
4311	this, SLOT(slot_CameraMouseMove(int)));
4312	connect(fEventCanv3, SIGNAL(signalPixelMoveOver(int)),
4313	this, SLOT(slot_CameraMouseMove(int)));
4314	connect(fEventCanv4, SIGNAL(signalPixelMoveOver(int)),
4315	this, SLOT(slot_CameraMouseMove(int)));
4316
4317	connect(fBiasCamV, SIGNAL(signalPixelMoveOver(int)),
4318	this, SLOT(slot_CameraMouseMove(int)));
4319	connect(fBiasCamA, SIGNAL(signalPixelMoveOver(int)),
4320	this, SLOT(slot_CameraMouseMove(int)));
4321
4322	connect(fFeedbackDevCam, SIGNAL(signalPixelMoveOver(int)),
4323	this, SLOT(slot_CameraMouseMove(int)));
4324	connect(fFeedbackCmdCam, SIGNAL(signalPixelMoveOver(int)),
4325	this, SLOT(slot_CameraMouseMove(int)));
4326
4327	connect(fRatesCanv, SIGNAL(signalPixelDoubleClick(int)),
4328	this, SLOT(slot_CameraDoubleClick(int)));
4329	connect(fRatesCanv, SIGNAL(signalCurrentPixel(int)),
4330	this, SLOT(slot_ChoosePixelThreshold(int)));
4331	connect(fBiasCamV, SIGNAL(signalCurrentPixel(int)),
4332	this, SLOT(slot_ChooseBiasChannel(int)));
4333	connect(fBiasCamA, SIGNAL(signalCurrentPixel(int)),
4334	this, SLOT(slot_ChooseBiasChannel(int)));
4335
4336	connect(fFtmRateCanv, SIGNAL( RootEventProcessed(TObject, unsigned int, TCanvas)),
4337	this, SLOT (slot_RootEventProcessed(TObject, unsigned int, TCanvas)));
4338	connect(fAdcDataCanv, SIGNAL( RootEventProcessed(TObject, unsigned int, TCanvas)),
4339	this, SLOT (slot_RootEventProcessed(TObject, unsigned int, TCanvas)));
4340	}
4341
4342	~FactGui()
4343	{
4344	// Unsubscribe all services
4345	for (map<string,DimInfo*>::iterator i=fServices.begin();
4346	i!=fServices.end(); i++)
4347	delete i->second;
4348
4349	delete fEventData;
4350	}
4351	};
4352
4353	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: