Context Navigation

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

Visit:

Last change on this file since 12302 was 12295, checked in by tbretz, 14 years ago
Addec code for the rate scan tab display
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	for (int i=0; i<201; i++)
2627	fGraphRateScan[i].Set(0);
2628
2629	h->SetBins(1, th-10, th+10);
2630	h->SetMinimum(1);
2631	h->SetMaximum(rates[0]*2);
2632
2633	c->SetGrid();
2634	c->SetLogy();
2635
2636	for (int i=0; i<201; i++)
2637	fGraphRateScan[i].SetPoint(fGraphRateScan[i].GetN(), th, rates[i]);
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
2799	if (s.index<FTM::StateMachine::kDisconnected) // No Dim connection
2800	SetLedColor(fStatusFTMLed, kLedGray, time);
2801	if (s.index==FTM::StateMachine::kDisconnected) // Dim connection / FTM disconnected
2802	SetLedColor(fStatusFTMLed, kLedYellow, time);
2803	if (s.index==FTM::StateMachine::kConnected \|\|
2804	s.index==FTM::StateMachine::kIdle \|\|
2805	configuring \|\|
2806	s.index==FTM::StateMachine::kTakingData) // Dim connection / FTM connected
2807	SetLedColor(fStatusFTMLed, kLedGreen, time);
2808
2809	if (s.index==FTM::StateMachine::kConnected \|\|
2810	s.index==FTM::StateMachine::kIdle) // Dim connection / FTM connected
2811	enable = true;
2812
2813	fFtmStartRun->setEnabled(!configuring && enable);
2814	fFtmStopRun->setEnabled(!configuring && (enable \|\| s.index==FTM::StateMachine::kTakingData));
2815
2816	fTriggerWidget->setEnabled(enable);
2817	fFtuGroupEnable->setEnabled(enable);
2818	fRatesControls->setEnabled(enable);
2819	fFtuWidget->setEnabled(s.index>FTM::StateMachine::kDisconnected);
2820
2821	if (s.index>=FTM::StateMachine::kConnected)
2822	SetFtuStatusLed(time);
2823	else
2824	{
2825	SetLedColor(fStatusFTULed, kLedGray, time);
2826	fStatusFTULabel->setText("Offline");
2827	fStatusFTULabel->setToolTip("FTM is not online.");
2828	}
2829	}
2830
2831	if (server=="FAD_CONTROL")
2832	{
2833	fStatusFADLabel->setText(s.name.c_str());
2834	fStatusFADLabel->setToolTip(s.comment.c_str());
2835
2836	bool enable = false;
2837
2838	if (s.index<FAD::kOffline) // No Dim connection
2839	{
2840	SetLedColor(fStatusFADLed, kLedGray, time);
2841
2842	// Timing problem - sometimes they stay gray :(
2843	//for (int i=0; i<40; i++)
2844	// SetLedColor(fFadLED[i], kLedGray, time);
2845
2846	/*
2847	fStatusEventBuilderLabel->setText("Offline");
2848	fStatusEventBuilderLabel->setToolTip("No connection to fadctrl.");
2849	fEvtBldWidget->setEnabled(false);
2850
2851	SetLedColor(fStatusEventBuilderLed, kLedGray, time);
2852	*/
2853	}
2854	if (s.index==FAD::kOffline) // Dim connection / FTM disconnected
2855	SetLedColor(fStatusFADLed, kLedRed, time);
2856	if (s.index==FAD::kDisconnected) // Dim connection / FTM disconnected
2857	SetLedColor(fStatusFADLed, kLedOrange, time);
2858	if (s.index==FAD::kConnecting) // Dim connection / FTM disconnected
2859	{
2860	SetLedColor(fStatusFADLed, kLedYellow, time);
2861	// FIXME FIXME FIXME: The LEDs are not displayed when disabled!
2862	enable = true;
2863	}
2864	if (s.index>=FAD::kConnected) // Dim connection / FTM connected
2865	{
2866	SetLedColor(fStatusFADLed, kLedGreen, time);
2867	enable = true;
2868	}
2869
2870	fFadWidget->setEnabled(enable);
2871
2872	fFadStart->setEnabled(s.index==FAD::kOffline);
2873	fFadStop->setEnabled(s.index>FAD::kOffline);
2874	fFadAbort->setEnabled(s.index>FAD::kOffline);
2875	fFadSoftReset->setEnabled(s.index>FAD::kOffline);
2876	fFadHardReset->setEnabled(s.index>FAD::kOffline);
2877	}
2878
2879	if (server=="FSC_CONTROL")
2880	{
2881	fStatusFSCLabel->setText(s.name.c_str());
2882	fStatusFSCLabel->setToolTip(s.comment.c_str());
2883
2884	bool enable = false;
2885
2886	if (s.index<1) // No Dim connection
2887	SetLedColor(fStatusFSCLed, kLedGray, time);
2888	if (s.index==1) // Dim connection / FTM disconnected
2889	SetLedColor(fStatusFSCLed, kLedRed, time);
2890	if (s.index>=2) // Dim connection / FTM disconnected
2891	{
2892	SetLedColor(fStatusFSCLed, kLedGreen, time);
2893	enable = true;
2894	}
2895
2896	fAuxWidget->setEnabled(enable);
2897	}
2898
2899	if (server=="BIAS_CONTROL")
2900	{
2901	fStatusBiasLabel->setText(s.name.c_str());
2902	fStatusBiasLabel->setToolTip(s.comment.c_str());
2903
2904	if (s.index<1) // No Dim connection
2905	SetLedColor(fStatusBiasLed, kLedGray, time);
2906	if (s.index==BIAS::kDisconnected) // Dim connection / FTM disconnected
2907	SetLedColor(fStatusBiasLed, kLedRed, time);
2908	if (s.index==BIAS::kConnecting \|\| s.index==BIAS::kInitializing) // Connecting / Initializing
2909	SetLedColor(fStatusBiasLed, kLedOrange, time);
2910	if (s.index==BIAS::kVoltageOff) // At reference
2911	SetLedColor(fStatusBiasLed, kLedGreen, time);
2912	if (s.index==BIAS::kNotReferenced) // At reference
2913	SetLedColor(fStatusBiasLed, kLedGreenWarn, time);
2914	if (s.index==BIAS::kRamping) // Ramping
2915	SetLedColor(fStatusBiasLed, kLedInProgress, time);
2916	if (s.index==BIAS::kVoltageOn) // At reference
2917	SetLedColor(fStatusBiasLed, kLedGreenCheck, time);
2918	if (s.index==BIAS::kOverCurrent) // Over current
2919	SetLedColor(fStatusBiasLed, kLedWarnBorder, time);
2920	if (s.index==BIAS::kExpertMode) // ExpertMode
2921	SetLedColor(fStatusBiasLed, kLedWarnTriangleBorder, time);
2922
2923	fBiasWidget->setEnabled(s.index>=3);
2924	}
2925
2926	if (server=="FEEDBACK")
2927	{
2928	fStatusFeedbackLabel->setText(s.name.c_str());
2929	fStatusFeedbackLabel->setToolTip(s.comment.c_str());
2930
2931	if (s.index>6) // Running
2932	SetLedColor(fStatusFeedbackLed, kLedGreenCheck, time);
2933	if (s.index==5 \|\| s.index==6) // Idle
2934	SetLedColor(fStatusFeedbackLed, kLedGreen, time);
2935	if (s.index==4) // Connected
2936	SetLedColor(fStatusFeedbackLed, kLedYellow, time);
2937	if (s.index==3) // Connecting
2938	SetLedColor(fStatusFeedbackLed, kLedOrange, time);
2939	if (s.index<3) // NoDim / Disconnected
2940	SetLedColor(fStatusFeedbackLed, kLedRed, time);
2941	if (s.index<1) // No Dim connection
2942	SetLedColor(fStatusFeedbackLed, kLedGray, time);
2943
2944	fFeedbackWidget->setEnabled(s.index>=3);
2945	fFeedbackStop->setEnabled(s.index>4);
2946	fFeedbackTempStart->setEnabled(s.index==4);
2947	fFeedbackTempOffset->setEnabled(s.index<=4);
2948	fFeedbackOutputEnable->setEnabled(s.index<=6);
2949	fFeedbackOutputDisable->setEnabled(s.index!=5 && s.index!=6);
2950
2951	fFeedbackFrameLeft->setEnabled(s.index!=5 && s.index!=7);
2952	fFeedbackCanvLeft->setEnabled(s.index!=5 && s.index!=7);
2953	}
2954
2955	if (server=="DATA_LOGGER")
2956	{
2957	fStatusLoggerLabel->setText(s.name.c_str());
2958	fStatusLoggerLabel->setToolTip(s.comment.c_str());
2959
2960	bool enable = true;
2961
2962	if (s.index<30) // Ready/Waiting
2963	SetLedColor(fStatusLoggerLed, kLedYellow, time);
2964	if (s.index==30) // Ready/Waiting
2965	SetLedColor(fStatusLoggerLed, kLedGreen, time);
2966	if (s.index<-1) // Offline
2967	{
2968	SetLedColor(fStatusLoggerLed, kLedGray, time);
2969	enable = false;
2970	}
2971	if (s.index>=0x100) // Error
2972	SetLedColor(fStatusLoggerLed, kLedRed, time);
2973	if (s.index==40) // Logging
2974	SetLedColor(fStatusLoggerLed, kLedGreen, time);
2975
2976	fLoggerWidget->setEnabled(enable);
2977	fLoggerStart->setEnabled(s.index>-1 && s.index<30);
2978	fLoggerStop->setEnabled(s.index>=30);
2979	}
2980
2981	if (server=="CHAT")
2982	{
2983	fStatusChatLabel->setText(s.name.c_str());
2984
2985	fChatOnline = s.index==0;
2986
2987	SetLedColor(fStatusChatLed, fChatOnline ? kLedGreen : kLedGray, time);
2988
2989	fChatSend->setEnabled(fChatOnline);
2990	fChatMessage->setEnabled(fChatOnline);
2991	}
2992
2993	if (server=="SCHEDULER")
2994	{
2995	fStatusSchedulerLabel->setText(s.name.c_str());
2996
2997	SetLedColor(fStatusSchedulerLed, s.index>=0 ? kLedGreen : kLedRed, time);
2998	}
2999	}
3000
3001	void on_fTabWidget_currentChanged(int which)
3002	{
3003	if (fTabWidget->tabText(which)=="Chat")
3004	fTabWidget->setTabIcon(which, QIcon());
3005	}
3006
3007	void handleWrite(const Time &time, const string &text, int qos)
3008	{
3009	stringstream out;
3010
3011	if (text.substr(0, 6)=="CHAT: ")
3012	{
3013	if (qos==MessageImp::kDebug)
3014	return;
3015
3016	out << "<font size='-1' color='navy'>[<B>";
3017	out << time.GetAsStr("%H:%M:%S");
3018	out << "</B>]</FONT> " << text.substr(6);
3019	fChatText->append(out.str().c_str());
3020
3021	if (fTabWidget->tabText(fTabWidget->currentIndex())=="Chat")
3022	return;
3023
3024	static int num = 0;
3025	if (num++<2)
3026	return;
3027
3028	for (int i=0; i<fTabWidget->count(); i++)
3029	if (fTabWidget->tabText(i)=="Chat")
3030	{
3031	fTabWidget->setTabIcon(i, QIcon(":/Resources/icons/warning 3.png"));
3032	break;
3033	}
3034
3035	return;
3036	}
3037
3038
3039	out << "<font style='font-family:monospace' color='";
3040
3041	switch (qos)
3042	{
3043	case kMessage: out << "black"; break;
3044	case kInfo: out << "green"; break;
3045	case kWarn: out << "#FF6600"; break;
3046	case kError: out << "maroon"; break;
3047	case kFatal: out << "maroon"; break;
3048	case kDebug: out << "navy"; break;
3049	default: out << "navy"; break;
3050	}
3051	out << "'>";
3052	out << time.GetAsStr("%H:%M:%S.%f").substr(0,12);
3053	out << " - " << text << "</font>";
3054
3055	fLogText->append(out.str().c_str());
3056
3057	if (qos>=kWarn && qos!=kDebug)
3058	fTextEdit->append(out.str().c_str());
3059	}
3060
3061	void IndicateStateChange(const Time &time, const std::string &server)
3062	{
3063	const State s = GetState(server, GetCurrentState(server));
3064
3065	QApplication::postEvent(this,
3066	new FunctionEvent(boost::bind(&FactGui::handleStateChanged, this, time, server, s)));
3067	}
3068
3069	int Write(const Time &time, const string &txt, int qos)
3070	{
3071	QApplication::postEvent(this,
3072	new FunctionEvent(boost::bind(&FactGui::handleWrite, this, time, txt, qos)));
3073
3074	return 0;
3075	}
3076
3077	// ====================== Dim infoHandler================================
3078
3079	void handleDimService(const string &txt)
3080	{
3081	fDimSvcText->append(txt.c_str());
3082	}
3083
3084	void infoHandlerService(DimInfo &info)
3085	{
3086	const string fmt = string(info.getFormat()).empty() ? "C" : info.getFormat();
3087
3088	stringstream dummy;
3089	const Converter conv(dummy, fmt, false);
3090
3091	const Time tm(info.getTimestamp(), info.getTimestampMillisecs()*1000);
3092
3093	stringstream out;
3094	out << "<font size'-1' color='navy'>[";
3095	out << tm.GetAsStr("%H:%M:%S.%f").substr(0,12);
3096	out << "]</font> <B>" << info.getName() << "</B> - ";
3097
3098	bool iserr = 2;
3099	if (!conv)
3100	{
3101	out << "Compilation of format string '" << fmt << "' failed!";
3102	}
3103	else
3104	{
3105	try
3106	{
3107	const string dat = info.getSize()==0 ? "<empty>" : conv.GetString(info.getData(), info.getSize());
3108	out << dat;
3109	iserr = info.getSize()==0;
3110	}
3111	catch (const runtime_error &e)
3112	{
3113	out << "Conversion to string failed!<pre>" << e.what() << "</pre>";
3114	}
3115	}
3116
3117	// srand(hash<string>()(string(info.getName())));
3118	// int bg = rand()&0xffffff;
3119
3120	int bg = hash<string>()(string(info.getName()));
3121
3122	// allow only light colors
3123	bg = ~(bg&0x1f1f1f)&0xffffff;
3124
3125	if (iserr==2)
3126	bg = 0xffffff;
3127
3128	stringstream bgcol;
3129	bgcol << hex << setfill('0') << setw(6) << bg;
3130
3131	const string col = iserr==0 ? "black" : (iserr==1 ? "#FF6600" : "black");
3132	const string str = "<table width='100%' bgcolor=#"+bgcol.str()+"><tr><td><font color='"+col+"'>"+out.str()+"</font></td></tr></table>";
3133
3134	QApplication::postEvent(this,
3135	new FunctionEvent(boost::bind(&FactGui::handleDimService, this, str)));
3136	}
3137
3138	void CallInfoHandler(void (FactGui::*handler)(const DimData&), const DimData &d)
3139	{
3140	fInHandler = true;
3141	(this->*handler)(d);
3142	fInHandler = false;
3143	}
3144
3145	/*
3146	void CallInfoHandler(const boost::function<void()> &func)
3147	{
3148	// This ensures that newly received values are not sent back to the emitter
3149	// because changing the value emits the valueChanged signal (or similar)
3150	fInHandler = true;
3151	func();
3152	fInHandler = false;
3153	}*/
3154
3155	void PostInfoHandler(void (FactGui::*handler)(const DimData&))
3156	{
3157	//const boost::function<void()> f = boost::bind(handler, this, DimData(getInfo()));
3158
3159	FunctionEvent *evt = new FunctionEvent(boost::bind(&FactGui::CallInfoHandler, this, handler, DimData(getInfo())));
3160	// FunctionEvent *evt = new FunctionEvent(boost::bind(&FactGui::CallInfoHandler, this, f));
3161	// FunctionEvent *evt = new FunctionEvent(boost::bind(handler, this, DimData(getInfo()))));
3162
3163	QApplication::postEvent(this, evt);
3164	}
3165
3166	void infoHandler()
3167	{
3168	// Initialize the time-stamp (what a weird workaround...)
3169	if (getInfo())
3170	getInfo()->getTimestamp();
3171
3172	if (getInfo()==&fDimDNS)
3173	return PostInfoHandler(&FactGui::handleDimDNS);
3174	#ifdef DEBUG_DIM
3175	cout << "HandleDimInfo " << getInfo()->getName() << endl;
3176	#endif
3177	if (getInfo()==&fDimLoggerStats)
3178	return PostInfoHandler(&FactGui::handleLoggerStats);
3179
3180	// if (getInfo()==&fDimFadFiles)
3181	// return PostInfoHandler(&FactGui::handleFadFiles);
3182
3183	if (getInfo()==&fDimFadWriteStats)
3184	return PostInfoHandler(&FactGui::handleFadWriteStats);
3185
3186	if (getInfo()==&fDimFadConnections)
3187	return PostInfoHandler(&FactGui::handleFadConnections);
3188
3189	if (getInfo()==&fDimFadFwVersion)
3190	return PostInfoHandler(&FactGui::handleFadFwVersion);
3191
3192	if (getInfo()==&fDimFadRunNumber)
3193	return PostInfoHandler(&FactGui::handleFadRunNumber);
3194
3195	if (getInfo()==&fDimFadDNA)
3196	return PostInfoHandler(&FactGui::handleFadDNA);
3197
3198	if (getInfo()==&fDimFadTemperature)
3199	return PostInfoHandler(&FactGui::handleFadTemperature);
3200
3201	if (getInfo()==&fDimFadRefClock)
3202	return PostInfoHandler(&FactGui::handleFadRefClock);
3203
3204	if (getInfo()==&fDimFadRoi)
3205	return PostInfoHandler(&FactGui::handleFadRoi);
3206
3207	if (getInfo()==&fDimFadDac)
3208	return PostInfoHandler(&FactGui::handleFadDac);
3209
3210	if (getInfo()==&fDimFadDrsCalibration)
3211	return PostInfoHandler(&FactGui::handleFadDrsCalibration);
3212
3213	if (getInfo()==&fDimFadPrescaler)
3214	return PostInfoHandler(&FactGui::handleFadPrescaler);
3215
3216	if (getInfo()==&fDimFadStatus)
3217	return PostInfoHandler(&FactGui::handleFadStatus);
3218
3219	if (getInfo()==&fDimFadStatistics1)
3220	return PostInfoHandler(&FactGui::handleFadStatistics1);
3221
3222	if (getInfo()==&fDimFadStatistics2)
3223	return PostInfoHandler(&FactGui::handleFadStatistics2);
3224
3225	if (getInfo()==&fDimFadEvents)
3226	return PostInfoHandler(&FactGui::handleFadEvents);
3227
3228	if (getInfo()==&fDimFadRuns)
3229	return PostInfoHandler(&FactGui::handleFadRuns);
3230
3231	if (getInfo()==&fDimFadStartRun)
3232	return PostInfoHandler(&FactGui::handleFadStartRun);
3233
3234	if (getInfo()==&fDimFadRawData)
3235	return PostInfoHandler(&FactGui::handleFadRawData);
3236
3237	if (getInfo()==&fDimFadEventData)
3238	return PostInfoHandler(&FactGui::handleFadEventData);
3239
3240	/*
3241	if (getInfo()==&fDimFadSetup)
3242	return PostInfoHandler(&FactGui::handleFadSetup);
3243	*/
3244	if (getInfo()==&fDimLoggerFilenameNight)
3245	return PostInfoHandler(&FactGui::handleLoggerFilenameNight);
3246
3247	if (getInfo()==&fDimLoggerNumSubs)
3248	return PostInfoHandler(&FactGui::handleLoggerNumSubs);
3249
3250	if (getInfo()==&fDimLoggerFilenameRun)
3251	return PostInfoHandler(&FactGui::handleLoggerFilenameRun);
3252
3253	if (getInfo()==&fDimFtmTriggerRates)
3254	return PostInfoHandler(&FactGui::handleFtmTriggerRates);
3255
3256	if (getInfo()==&fDimFtmCounter)
3257	return PostInfoHandler(&FactGui::handleFtmCounter);
3258
3259	if (getInfo()==&fDimFtmDynamicData)
3260	return PostInfoHandler(&FactGui::handleFtmDynamicData);
3261
3262	if (getInfo()==&fDimFtmPassport)
3263	return PostInfoHandler(&FactGui::handleFtmPassport);
3264
3265	if (getInfo()==&fDimFtmFtuList)
3266	return PostInfoHandler(&FactGui::handleFtmFtuList);
3267
3268	if (getInfo()==&fDimFtmStaticData)
3269	return PostInfoHandler(&FactGui::handleFtmStaticData);
3270
3271	if (getInfo()==&fDimFtmError)
3272	return PostInfoHandler(&FactGui::handleFtmError);
3273
3274	if (getInfo()==&fDimFscTemp)
3275	return PostInfoHandler(&FactGui::handleFscTemp);
3276
3277	if (getInfo()==&fDimFscVolt)
3278	return PostInfoHandler(&FactGui::handleFscVolt);
3279
3280	if (getInfo()==&fDimFscCurrent)
3281	return PostInfoHandler(&FactGui::handleFscCurrent);
3282
3283	if (getInfo()==&fDimFscHumidity)
3284	return PostInfoHandler(&FactGui::handleFscHumidity);
3285
3286	if (getInfo()==&fDimBiasVolt)
3287	return PostInfoHandler(&FactGui::handleBiasVolt);
3288
3289	if (getInfo()==&fDimBiasCurrent)
3290	return PostInfoHandler(&FactGui::handleBiasCurrent);
3291
3292	if (getInfo()==&fDimFeedbackReference)
3293	return PostInfoHandler(&FactGui::handleFeedbackReference);
3294
3295	if (getInfo()==&fDimFeedbackDeviation)
3296	return PostInfoHandler(&FactGui::handleFeedbackDeviation);
3297
3298	if (getInfo()==&fDimRateScan)
3299	return PostInfoHandler(&FactGui::handleRateScan);
3300
3301	// if (getInfo()==&fDimFadFiles)
3302	// return PostInfoHandler(&FactGui::handleFadFiles);
3303
3304	for (map<string,DimInfo*>::iterator i=fServices.begin(); i!=fServices.end(); i++)
3305	if (i->second==getInfo())
3306	{
3307	infoHandlerService(*i->second);
3308	return;
3309	}
3310
3311	DimNetwork::infoHandler();
3312	}
3313
3314
3315	// ======================================================================
3316
3317	bool event(QEvent *evt)
3318	{
3319	if (dynamic_cast<FunctionEvent*>(evt))
3320	return static_cast<FunctionEvent*>(evt)->Exec();
3321
3322	if (dynamic_cast<CheckBoxEvent*>(evt))
3323	{
3324	const QStandardItem &item = static_cast<CheckBoxEvent*>(evt)->item;
3325	const QStandardItem *par = item.parent();
3326	if (par)
3327	{
3328	const QString server = par->text();
3329	const QString service = item.text();
3330
3331	const string s = (server+'/'+service).toStdString();
3332
3333	if (item.checkState()==Qt::Checked)
3334	SubscribeService(s);
3335	else
3336	UnsubscribeService(s);
3337	}
3338	}
3339
3340	return MainWindow::event(evt); // unrecognized
3341	}
3342
3343	void on_fDimCmdSend_clicked()
3344	{
3345	const QString server = fDimCmdServers->currentIndex().data().toString();
3346	const QString command = fDimCmdCommands->currentIndex().data().toString();
3347	const QString arguments = fDimCmdLineEdit->displayText();
3348
3349	// FIXME: Sending a command exactly when the info Handler changes
3350	// the list it might lead to confusion.
3351	try
3352	{
3353	SendDimCommand(server.toStdString(), command.toStdString()+" "+arguments.toStdString());
3354	fTextEdit->append("<font color='green'>Command '"+server+'/'+command+"' successfully emitted.</font>");
3355	fDimCmdLineEdit->clear();
3356	}
3357	catch (const runtime_error &e)
3358	{
3359	stringstream txt;
3360	txt << e.what();
3361
3362	string buffer;
3363	while (getline(txt, buffer, '\n'))
3364	fTextEdit->append(("<font color='red'><pre>"+buffer+"</pre></font>").c_str());
3365	}
3366	}
3367
3368	#ifdef HAVE_ROOT
3369	void slot_RootEventProcessed(TObject obj, unsigned int evt, TCanvas canv)
3370	{
3371	// kMousePressEvent // TCanvas processed QEvent mousePressEvent
3372	// kMouseMoveEvent // TCanvas processed QEvent mouseMoveEvent
3373	// kMouseReleaseEvent // TCanvas processed QEvent mouseReleaseEvent
3374	// kMouseDoubleClickEvent // TCanvas processed QEvent mouseDoubleClickEvent
3375	// kKeyPressEvent // TCanvas processed QEvent keyPressEvent
3376	// kEnterEvent // TCanvas processed QEvent enterEvent
3377	// kLeaveEvent // TCanvas processed QEvent leaveEvent
3378
3379	if (dynamic_cast<TCanvas*>(obj))
3380	return;
3381
3382	TQtWidget tipped = static_cast<TQtWidget>(sender());
3383
3384	if (evt==11/kMouseReleaseEvent/)
3385	return;
3386
3387	if (evt==61/kMouseDoubleClickEvent/)
3388	return;
3389
3390	if (obj)
3391	{
3392	// Find the object which will get picked by the GetObjectInfo
3393	// due to buffer overflows in many root-versions
3394	// in TH1 and TProfile we have to work around and implement
3395	// our own GetObjectInfo which make everything a bit more
3396	// complicated.
3397	canv->cd();
3398	#if ROOT_VERSION_CODE > ROOT_VERSION(5,22,00)
3399	const char *objectInfo =
3400	obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
3401	#else
3402	const char objectInfo = dynamic_cast<TH1>(obj) ?
3403	"" : obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
3404	#endif
3405
3406	QString tipText;
3407	tipText += obj->GetName();
3408	tipText += " [";
3409	tipText += obj->ClassName();
3410	tipText += "]: ";
3411	tipText += objectInfo;
3412
3413	fStatusBar->showMessage(tipText, 3000);
3414	}
3415
3416	gSystem->DispatchOneEvent(kFALSE);
3417	//gSystem->ProcessEvents();
3418	//QWhatsThis::display(tipText)
3419	}
3420
3421	void slot_RootUpdate()
3422	{
3423	gSystem->DispatchOneEvent(kFALSE);
3424	//gSystem->ProcessEvents();
3425	QTimer::singleShot(10, this, SLOT(slot_RootUpdate()));
3426	}
3427	#endif
3428
3429	void ChoosePatchThreshold(Camera &cam, int isw)
3430	{
3431	cam.Reset();
3432
3433	fThresholdIdx->setValue(isw);
3434
3435	const int ihw = isw<0 ? 0 : fPatchMapHW[isw];
3436
3437	fPatchRate->setEnabled(isw>=0);
3438	fThresholdCrate->setEnabled(isw>=0);
3439	fThresholdBoard->setEnabled(isw>=0);
3440	fThresholdPatch->setEnabled(isw>=0);
3441
3442	if (isw<0)
3443	return;
3444
3445	const int patch = ihw%4;
3446	const int board = (ihw/4)%10;
3447	const int crate = (ihw/4)/10;
3448
3449	fInChoosePatchTH = true;
3450
3451	fThresholdCrate->setValue(crate);
3452	fThresholdBoard->setValue(board);
3453	fThresholdPatch->setValue(patch);
3454
3455	fInChoosePatchTH = false;
3456
3457	fThresholdVal->setValue(fFtmStaticData.fThreshold[ihw]);
3458	fPatchRate->setValue(fTriggerRates.fPatchRate[ihw]);
3459	fBoardRate->setValue(fTriggerRates.fBoardRate[ihw/4]);
3460
3461	// Loop over the software idx of all pixels
3462	// for (unsigned int i=0; i<1440; i++)
3463	// if (fPatchHW[i]==ihw)
3464	// cam.SetBold(i);
3465	}
3466
3467	/*
3468	void ChoosePatchBias(Camera &cam, int isw)
3469	{
3470	cam.Reset();
3471
3472	fBiasChannel->setValue(isw);
3473
3474	const int ihw = isw<0 ? 0 : fPatchMapHW[isw];
3475
3476	fBiasCurrent->setEnabled(isw>=0);
3477	fBiasCrate->setEnabled(isw>=0);
3478	fBiasBoard->setEnabled(isw>=0);
3479	fBiasPatch->setEnabled(isw>=0);
3480
3481	if (isw<0)
3482	return;
3483
3484	const int patch = ihw%4;
3485	const int board = (ihw/4)%10;
3486	const int crate = (ihw/4)/10;
3487
3488	fInChoosePatchBias = true;
3489
3490	fBiasCrate->setValue(crate);
3491	fBiasBoard->setValue(board);
3492	fBiasPatch->setValue(patch);
3493
3494	fInChoosePatchBias = false;
3495
3496	if (fVecBias.size()>0)
3497	{
3498	// FIXME: Mapping
3499	fBiasVoltDac->setValue(fVecBias[ihw]);
3500	fBiasVolt->setValue(fVecBias[ihw]*90./4096);
3501	}
3502
3503	fBiasCurrent->setValue(cam.GetData(isw));
3504
3505	// Loop over the software idx of all pixels
3506	for (unsigned int i=0; i<1440; i++)
3507	if (fPatchHW[i]==ihw)
3508	cam.SetBold(i);
3509	}*/
3510
3511	void slot_ChoosePixelThreshold(int isw)
3512	{
3513	fPixelIdx->setValue(isw);
3514
3515	const PixelMapEntry &entry = fPixelMap.index(isw);
3516	fPixelEnable->setChecked(fFtmStaticData.IsEnabled(entry.hw()));
3517	}
3518
3519	void slot_CameraDoubleClick(int isw)
3520	{
3521	fPixelIdx->setValue(isw);
3522
3523	const PixelMapEntry &entry = fPixelMap.index(isw);
3524	Dim::SendCommand("FTM_CONTROL/TOGGLE_PIXEL", uint16_t(entry.hw()));
3525	}
3526
3527	void slot_CameraMouseMove(int isw)
3528	{
3529	const PixelMapEntry &entry = fPixelMap.index(isw);
3530
3531	QString tipText;
3532	tipText += fRatesCanv->GetName();
3533	ostringstream str;
3534	str << setfill('0') <<
3535	" \|\| HW: " << entry.crate() << "\|" << entry.board() << "\|" << entry.patch() << "\|" << entry.pixel() << " (crate\|board\|patch\|pixel)" <<
3536	" \|\| HV: " << entry.hv_board << "\|" << setw(2) << entry.hv_channel << " (board\|channel)" <<
3537	" \|\| ID: " << isw;
3538
3539
3540	tipText += str.str().c_str();
3541	fStatusBar->showMessage(tipText, 3000);
3542	}
3543
3544	void on_fThresholdIdx_valueChanged(int isw)
3545	{
3546	// fRatesCanv->SetBold(isw);
3547	// fRatesCanv->updateGL();
3548	}
3549
3550	void UpdateThresholdIdx()
3551	{
3552	if (fInChoosePatchTH)
3553	return;
3554
3555	const int crate = fThresholdCrate->value();
3556	const int board = fThresholdBoard->value();
3557	const int patch = fThresholdPatch->value();
3558
3559	const int ihw = patch + board4 + crate40;
3560
3561	int isw = 0;
3562	for (; isw<160; isw++)
3563	if (ihw==fPatchMapHW[isw])
3564	break;
3565
3566	on_fThresholdIdx_valueChanged(isw);
3567	}
3568
3569	void on_fPixelIdx_valueChanged(int isw)
3570	{
3571	int ii = 0;
3572	for (; ii<160; ii++)
3573	if (fPixelMap.index(isw).hw()/9==fPatchMapHW[ii])
3574	break;
3575
3576	fRatesCanv->SetWhite(isw);
3577	ChoosePatchThreshold(*fRatesCanv, ii);
3578
3579	const PixelMapEntry &entry = fPixelMap.index(isw);
3580	fPixelEnable->setChecked(fFtmStaticData.IsEnabled(entry.hw()));
3581	}
3582
3583	// ------------------- Bias display ---------------------
3584
3585	void UpdateBiasValues()
3586	{
3587	const int b = fBiasHvBoard->value();
3588	const int c = fBiasHvChannel->value();
3589
3590	const int ihw = b*32+c;
3591
3592	if (fVecBiasVolt.size()>0)
3593	{
3594	fBiasVoltCur->setValue(fVecBiasVolt[ihw]*90./4096);
3595	fBiasVoltRef->setValue(fVecBiasVolt[ihw+416]*90./4096);
3596
3597	SetLedColor(fBiasNominalLed,
3598	fVecBiasVolt[ihw]==fVecBiasVolt[ihw+416]?kLedGreen:kLedRed, Time());
3599	}
3600
3601	if (fVecBiasCurrent.size()>0)
3602	{
3603	fBiasCurrent->setValue(abs(fVecBiasCurrent[ihw])*5000./4096);
3604	SetLedColor(fBiasOverCurrentLed,
3605	fVecBiasCurrent[ihw]<0?kLedRed:kLedGreen, Time());
3606	}
3607	}
3608
3609	void UpdateBiasCam(const PixelMapEntry &entry)
3610	{
3611	fInChooseBiasCam = true;
3612
3613	fBiasCamCrate->setValue(entry.crate());
3614	fBiasCamBoard->setValue(entry.board());
3615	fBiasCamPatch->setValue(entry.patch());
3616	fBiasCamPixel->setValue(entry.pixel());
3617
3618	fInChooseBiasCam = false;
3619	}
3620
3621	void BiasHvChannelChanged()
3622	{
3623	if (fInChooseBiasHv)
3624	return;
3625
3626	const int b = fBiasHvBoard->value();
3627	const int ch = fBiasHvChannel->value();
3628
3629	// FIXME: Mark corresponding patch in camera
3630	const PixelMapEntry &entry = fPixelMap.hv(b, ch);
3631	fBiasCamV->SetWhite(entry.index);
3632	fBiasCamA->SetWhite(entry.index);
3633	fBiasCamV->updateCamera();
3634	fBiasCamA->updateCamera();
3635
3636	UpdateBiasCam(entry);
3637	UpdateBiasValues();
3638	}
3639
3640	void UpdateBiasHv(const PixelMapEntry &entry)
3641	{
3642	fInChooseBiasHv = true;
3643
3644	fBiasHvBoard->setValue(entry.hv_board);
3645	fBiasHvChannel->setValue(entry.hv_channel);
3646
3647	fInChooseBiasHv = false;
3648	}
3649
3650	void BiasCamChannelChanged()
3651	{
3652	if (fInChooseBiasCam)
3653	return;
3654
3655	const int crate = fBiasCamCrate->value();
3656	const int board = fBiasCamBoard->value();
3657	const int patch = fBiasCamPatch->value();
3658	const int pixel = fBiasCamPixel->value();
3659
3660	// FIXME: Display corresponding patches
3661	const PixelMapEntry &entry = fPixelMap.cbpx(crate, board, patch, pixel);
3662	fBiasCamV->SetWhite(entry.index);
3663	fBiasCamA->SetWhite(entry.index);
3664	fBiasCamV->updateCamera();
3665	fBiasCamA->updateCamera();
3666
3667	UpdateBiasHv(entry);
3668	UpdateBiasValues();
3669	}
3670
3671	void slot_ChooseBiasChannel(int isw)
3672	{
3673	const PixelMapEntry &entry = fPixelMap.index(isw);
3674
3675	UpdateBiasHv(entry);
3676	UpdateBiasCam(entry);
3677	UpdateBiasValues();
3678	}
3679
3680	void on_fBiasDispRefVolt_stateChanged(int = 0)
3681	{
3682	// FIXME: Display patches for which ref==cur
3683
3684	valarray<double> dat(0., 1440);
3685
3686	int offset = 0;
3687	if (!fBiasDispRefVolt->isChecked())
3688	fBiasCamV->setTitle("Applied BIAS voltage");
3689	else
3690	{
3691	fBiasCamV->setTitle("Reference BIAS voltage");
3692	offset = 416;
3693	}
3694
3695	if (fVecBiasVolt.size()>0)
3696	{
3697	for (int i=0; i<1440; i++)
3698	{
3699	const PixelMapEntry &entry = fPixelMap.index(i);
3700	dat[i] = fVecBiasVolt[entry.hv()+offset]*90./4096;
3701
3702	fBiasCamV->highlightPixel(i, fVecBiasVolt[entry.hv()]!=fVecBiasVolt[entry.hv()+416]);
3703	}
3704
3705	fBiasCamV->SetData(dat);
3706	}
3707
3708	fBiasCamV->updateCamera();
3709	}
3710
3711	// ------------------------------------------------------
3712
3713	void on_fPixelEnable_stateChanged(int b)
3714	{
3715	if (fInHandler)
3716	return;
3717
3718	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
3719
3720	Dim::SendCommand(b==Qt::Unchecked ?
3721	"FTM_CONTROL/DISABLE_PIXEL" : "FTM_CONTROL/ENABLE_PIXEL",
3722	uint16_t(entry.hw()));
3723	}
3724
3725	void on_fPixelDisableOthers_clicked()
3726	{
3727	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
3728	Dim::SendCommand("FTM_CONTROL/DISABLE_ALL_PIXELS_EXCEPT", uint16_t(entry.hw()));
3729	}
3730
3731	void on_fThresholdDisableOthers_clicked()
3732	{
3733	const int16_t isw = fThresholdIdx->value();
3734	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3735	if (ihw<0)
3736	return;
3737
3738	Dim::SendCommand("FTM_CONTROL/DISABLE_ALL_PATCHES_EXCEPT", ihw);
3739	}
3740
3741	void on_fThresholdEnablePatch_clicked()
3742	{
3743	const int16_t isw = fThresholdIdx->value();
3744	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3745	if (ihw<0)
3746	return;
3747
3748	Dim::SendCommand("FTM_CONTROL/ENABLE_PATCH", ihw);
3749	}
3750
3751	void on_fThresholdDisablePatch_clicked()
3752	{
3753	const int16_t isw = fThresholdIdx->value();
3754	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3755	if (ihw<0)
3756	return;
3757
3758	Dim::SendCommand("FTM_CONTROL/DISABLE_PATCH", ihw);
3759	}
3760
3761	void on_fThresholdVal_valueChanged(int v)
3762	{
3763	fThresholdVolt->setValue(2500./4095*v);
3764
3765	const int32_t isw = fThresholdIdx->value();
3766	const int32_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3767
3768	const int32_t d[2] = { ihw, v };
3769
3770	if (!fInHandler)
3771	Dim::SendCommand("FTM_CONTROL/SET_THRESHOLD", d);
3772	}
3773
3774	TGraph fGraphFtmTemp[4];
3775	TGraph fGraphFtmRate;
3776	TGraph fGraphPatchRate[160];
3777	TGraph fGraphBoardRate[40];
3778
3779	#ifdef HAVE_ROOT
3780	TH1 DrawTimeFrame(const char ytitle)
3781	{
3782	const double tm = Time().RootTime();
3783
3784	TH1F *h=new TH1F("TimeFrame", "", 1, tm, tm+60);//Time().RootTime()-1./24/60/60, Time().RootTime());
3785	h->SetDirectory(0);
3786	h->SetBit(kCanDelete);
3787	h->SetStats(kFALSE);
3788	// h.SetMinimum(0);
3789	// h.SetMaximum(1);
3790	h->SetXTitle("Time");
3791	h->SetYTitle(ytitle);
3792	h->GetXaxis()->CenterTitle();
3793	h->GetYaxis()->CenterTitle();
3794	h->GetXaxis()->SetTimeDisplay(true);
3795	h->GetXaxis()->SetTimeFormat("%Mh%S'");
3796	h->GetXaxis()->SetLabelSize(0.025);
3797	h->GetYaxis()->SetLabelSize(0.025);
3798	h->GetYaxis()->SetTitleOffset(1.2);
3799	// h.GetYaxis()->SetTitleSize(1.2);
3800	h->Draw();
3801
3802	return h;
3803	}
3804	#endif
3805
3806	pair<string,string> Split(const string &str) const
3807	{
3808	const size_t p = str.find_first_of('\|');
3809	if (p==string::npos)
3810	return make_pair(str, "");
3811
3812	return make_pair(str.substr(0, p), str.substr(p+1));
3813	}
3814
3815	public:
3816	FactGui(Configuration &conf) :
3817	fFtuStatus(40),
3818	/fPixelMapHW(1440),/ fPatchMapHW(160),
3819	fInChoosePatchTH(false),
3820	fInChooseBiasHv(false), fInChooseBiasCam(false),
3821	fDimDNS("DIS_DNS/VERSION_NUMBER", 1, int(0), this),
3822	//-
3823	fDimLoggerStats ("DATA_LOGGER/STATS", (void*)NULL, 0, this),
3824	fDimLoggerFilenameNight("DATA_LOGGER/FILENAME_NIGHTLY", (void*)NULL, 0, this),
3825	fDimLoggerFilenameRun ("DATA_LOGGER/FILENAME_RUN", (void*)NULL, 0, this),
3826	fDimLoggerNumSubs ("DATA_LOGGER/NUM_SUBS", (void*)NULL, 0, this),
3827	//-
3828	fDimFtmPassport ("FTM_CONTROL/PASSPORT", (void*)NULL, 0, this),
3829	fDimFtmTriggerRates ("FTM_CONTROL/TRIGGER_RATES", (void*)NULL, 0, this),
3830	fDimFtmError ("FTM_CONTROL/ERROR", (void*)NULL, 0, this),
3831	fDimFtmFtuList ("FTM_CONTROL/FTU_LIST", (void*)NULL, 0, this),
3832	fDimFtmStaticData ("FTM_CONTROL/STATIC_DATA", (void*)NULL, 0, this),
3833	fDimFtmDynamicData ("FTM_CONTROL/DYNAMIC_DATA", (void*)NULL, 0, this),
3834	fDimFtmCounter ("FTM_CONTROL/COUNTER", (void*)NULL, 0, this),
3835	//-
3836	fDimFadWriteStats ("FAD_CONTROL/STATS", (void*)NULL, 0, this),
3837	fDimFadStartRun ("FAD_CONTROL/START_RUN", (void*)NULL, 0, this),
3838	fDimFadRuns ("FAD_CONTROL/RUNS", (void*)NULL, 0, this),
3839	fDimFadEvents ("FAD_CONTROL/EVENTS", (void*)NULL, 0, this),
3840	fDimFadRawData ("FAD_CONTROL/RAW_DATA", (void*)NULL, 0, this),
3841	fDimFadEventData ("FAD_CONTROL/EVENT_DATA", (void*)NULL, 0, this),
3842	fDimFadConnections ("FAD_CONTROL/CONNECTIONS", (void*)NULL, 0, this),
3843	fDimFadFwVersion ("FAD_CONTROL/FIRMWARE_VERSION", (void*)NULL, 0, this),
3844	fDimFadRunNumber ("FAD_CONTROL/RUN_NUMBER", (void*)NULL, 0, this),
3845	fDimFadDNA ("FAD_CONTROL/DNA", (void*)NULL, 0, this),
3846	fDimFadTemperature ("FAD_CONTROL/TEMPERATURE", (void*)NULL, 0, this),
3847	fDimFadPrescaler ("FAD_CONTROL/PRESCALER", (void*)NULL, 0, this),
3848	fDimFadRefClock ("FAD_CONTROL/REFERENCE_CLOCK", (void*)NULL, 0, this),
3849	fDimFadRoi ("FAD_CONTROL/REGION_OF_INTEREST", (void*)NULL, 0, this),
3850	fDimFadDac ("FAD_CONTROL/DAC", (void*)NULL, 0, this),
3851	fDimFadDrsCalibration ("FAD_CONTROL/DRS_CALIBRATION", (void*)NULL, 0, this),
3852	fDimFadStatus ("FAD_CONTROL/STATUS", (void*)NULL, 0, this),
3853	fDimFadStatistics1 ("FAD_CONTROL/STATISTICS1", (void*)NULL, 0, this),
3854	fDimFadStatistics2 ("FAD_CONTROL/STATISTICS2", (void*)NULL, 0, this),
3855	//-
3856	fDimFscTemp ("FSC_CONTROL/TEMPERATURE", (void*)NULL, 0, this),
3857	fDimFscVolt ("FSC_CONTROL/VOLTAGE", (void*)NULL, 0, this),
3858	fDimFscCurrent ("FSC_CONTROL/CURRENT", (void*)NULL, 0, this),
3859	fDimFscHumidity ("FSC_CONTROL/HUMIDITY", (void*)NULL, 0, this),
3860	//-
3861	fDimBiasVolt ("BIAS_CONTROL/VOLTAGE", (void*)NULL, 0, this),
3862	fDimBiasCurrent ("BIAS_CONTROL/CURRENT", (void*)NULL, 0, this),
3863	//-
3864	fDimFeedbackDeviation ("FEEDBACK/DEVIATION", (void*)NULL, 0, this),
3865	fDimFeedbackReference ("FEEDBACK/REFERENCE", (void*)NULL, 0, this),
3866	//-
3867	fDimRateScan ("RATE_SCAN/DATA", (void*)NULL, 0, this),
3868	//-
3869	fEventData(0), fDrsCalibration(144010246),
3870	fTimeStamp0(0)
3871	{
3872	fClockCondFreq->addItem("--- Hz", QVariant(-1));
3873	fClockCondFreq->addItem("800 MHz", QVariant(800));
3874	fClockCondFreq->addItem("1 GHz", QVariant(1000));
3875	fClockCondFreq->addItem("2 GHz", QVariant(2000));
3876	fClockCondFreq->addItem("3 GHz", QVariant(3000));
3877	fClockCondFreq->addItem("4 GHz", QVariant(4000));
3878	fClockCondFreq->addItem("5 GHz", QVariant(5000));
3879
3880	cout << "-- run counter ---" << endl;
3881	fMcpNumEvents->addItem("unlimited", QVariant(0));
3882	const vector<uint32_t> runcount = conf.Vec<uint32_t>("run-count");
3883	for (vector<uint32_t>::const_iterator it=runcount.begin(); it!=runcount.end(); it++)
3884	{
3885	cout << *it << endl;
3886	ostringstream str;
3887	str << *it;
3888	fMcpNumEvents->addItem(str.str().c_str(), QVariant(*it));
3889	}
3890
3891	cout << "-- run times ---" << endl;
3892	fMcpTime->addItem("unlimited", QVariant(0));
3893	const vector<string> runtime = conf.Vec<string>("run-time");
3894	for (vector<string>::const_iterator it=runtime.begin(); it!=runtime.end(); it++)
3895	{
3896	const pair<string,string> p = Split(*it);
3897	cout << *it << "\|" << p.second << "\|" << p.first << "\|" << endl;
3898	fMcpTime->addItem(p.second.c_str(), QVariant(stoi(p.first)));
3899	}
3900
3901	cout << "-- run types ---" << endl;
3902	const vector<string> runtype = conf.Vec<string>("run-type");
3903	for (vector<string>::const_iterator it=runtype.begin(); it!=runtype.end(); it++)
3904	{
3905	const pair<string,string> p = Split(*it);
3906	cout << *it << "\|" << p.second << "\|" << p.first << "\|" << endl;
3907	fMcpRunType->addItem(p.second.c_str(), QVariant(p.first.c_str()));
3908	}
3909
3910	fTriggerWidget->setEnabled(false);
3911	fFtuWidget->setEnabled(false);
3912	fFtuGroupEnable->setEnabled(false);
3913	fRatesControls->setEnabled(false);
3914	fFadWidget->setEnabled(false);
3915	fEvtBldWidget->setEnabled(false);
3916	fLoggerWidget->setEnabled(false);
3917	fBiasWidget->setEnabled(false);
3918	fAuxWidget->setEnabled(false);
3919
3920	fChatSend->setEnabled(false);
3921	fChatMessage->setEnabled(false);
3922
3923	DimClient::sendCommand("CHAT/MSG", "GUI online.");
3924	// + MessageDimRX
3925
3926	// --------------------------------------------------------------------------
3927
3928	if (!fPixelMap.Read(conf.Get<string>("pixel-map-file")))
3929	{
3930	cerr << "ERROR - Problems reading " << conf.Get<string>("pixel-map-file") << endl;
3931	exit(-1);
3932	}
3933
3934	// --------------------------------------------------------------------------
3935
3936	/*
3937	ifstream fin1("Trigger-Patches.txt");
3938
3939	string buf;
3940
3941	int l = 0;
3942	while (getline(fin1, buf, '\n'))
3943	{
3944	buf = Tools::Trim(buf);
3945	if (buf[0]=='#')
3946	continue;
3947
3948	stringstream str(buf);
3949	for (int i=0; i<9; i++)
3950	{
3951	unsigned int n;
3952	str >> n;
3953
3954	if (n>=fPatchHW.size())
3955	continue;
3956
3957	fPatchHW[n] = l;
3958	}
3959	l++;
3960	}
3961
3962	if (l!=160)
3963	cerr << "WARNING - Problems reading Trigger-Patches.txt" << endl;
3964	*/
3965	// --------------------------------------------------------------------------
3966
3967	/*
3968	ifstream fin2("MasterList-v3.txt");
3969
3970	l = 0;
3971
3972	while (getline(fin2, buf, '\n'))
3973	{
3974	buf = Tools::Trim(buf);
3975	if (buf[0]=='#')
3976	continue;
3977
3978	unsigned int softid, hardid, dummy;
3979
3980	stringstream str(buf);
3981
3982	str >> softid;
3983	str >> dummy;
3984	str >> hardid;
3985
3986	if (softid>=fPixelMapHW.size())
3987	continue;
3988
3989	fPixelMapHW[softid] = hardid;
3990
3991	l++;
3992	}
3993
3994	if (l!=1440)
3995	cerr << "WARNING - Problems reading MasterList-v3.txt" << endl;
3996	*/
3997	// --------------------------------------------------------------------------
3998
3999	ifstream fin3("PatchList.txt");
4000
4001	string buf;
4002
4003	int l = 0;
4004	while (getline(fin3, buf, '\n'))
4005	{
4006	buf = Tools::Trim(buf);
4007	if (buf[0]=='#')
4008	continue;
4009
4010	unsigned int softid, hardid;
4011
4012	stringstream str(buf);
4013
4014	str >> softid;
4015	str >> hardid;
4016
4017	if (softid>=fPatchMapHW.size())
4018	continue;
4019
4020	fPatchMapHW[softid] = hardid-1;
4021
4022	l++;
4023	}
4024
4025	if (l!=160)
4026	cerr << "WARNING - Problems reading PatchList.txt" << endl;
4027
4028	// --------------------------------------------------------------------------
4029	#ifdef HAVE_ROOT
4030
4031	fGraphFeedbackDev.SetLineColor(kBlue);
4032	fGraphFeedbackDev.SetMarkerColor(kBlue);
4033	fGraphFeedbackDev.SetMarkerStyle(kFullDotMedium);
4034
4035	fGraphFeedbackCmd.SetLineColor(kBlue);
4036	fGraphFeedbackCmd.SetMarkerColor(kBlue);
4037	fGraphFeedbackCmd.SetMarkerStyle(kFullDotMedium);
4038
4039	// Evolution of control deviation
4040	// Evolution of command values (bias voltage change)
4041	fGraphFeedbackDev.SetName("ControlDev");
4042	fGraphFeedbackCmd.SetName("CommandVal");
4043
4044	TCanvas *c = fFeedbackDev->GetCanvas();
4045	c->SetBorderMode(0);
4046	c->SetFrameBorderMode(0);
4047	c->SetFillColor(kWhite);
4048	c->SetRightMargin(0.03);
4049	c->SetTopMargin(0.03);
4050	c->SetGrid();
4051	c->cd();
4052
4053	TH1 *hf = DrawTimeFrame("Control deviation [mV] ");
4054	hf->GetXaxis()->SetLabelSize(0.07);
4055	hf->GetYaxis()->SetLabelSize(0.07);
4056	hf->GetYaxis()->SetTitleSize(0.08);
4057	hf->GetYaxis()->SetTitleOffset(0.55);
4058	hf->GetXaxis()->SetTitle("");
4059	hf->GetYaxis()->SetRangeUser(-99, 99);
4060
4061	fGraphFeedbackDev.Draw("LP");
4062
4063	c = fFeedbackCmd->GetCanvas();
4064	c->SetBorderMode(0);
4065	c->SetFrameBorderMode(0);
4066	c->SetFillColor(kWhite);
4067	c->SetRightMargin(0.03);
4068	c->SetTopMargin(0.03);
4069	c->SetGrid();
4070	c->cd();
4071
4072	hf = DrawTimeFrame("Command delta value [mV] ");
4073	hf->GetXaxis()->SetLabelSize(0.07);
4074	hf->GetYaxis()->SetLabelSize(0.07);
4075	hf->GetYaxis()->SetTitleSize(0.08);
4076	hf->GetYaxis()->SetTitleOffset(0.55);
4077	hf->GetXaxis()->SetTitle("");
4078	hf->GetYaxis()->SetRangeUser(-9910, 9910);
4079
4080	fGraphFeedbackCmd.Draw("LP");
4081
4082	// --------------------------------------------------------------------------
4083
4084	c = fRateScanCanv->GetCanvas();
4085	//c->SetBit(TCanvas::kNoContextMenu);
4086	c->SetBorderMode(0);
4087	c->SetFrameBorderMode(0);
4088	c->SetFillColor(kWhite);
4089	c->SetRightMargin(0.03);
4090	c->SetTopMargin(0.03);
4091	c->SetGrid();
4092	c->cd();
4093
4094	TH1F *h=new TH1F("Frame", "", 1, 0, 1);
4095	h->SetDirectory(0);
4096	h->SetBit(kCanDelete);
4097	h->SetStats(kFALSE);
4098	h->SetXTitle("Threshold [DAC]");
4099	h->SetYTitle("Rate [Hz]");
4100	h->GetXaxis()->CenterTitle();
4101	h->GetYaxis()->CenterTitle();
4102	h->GetXaxis()->SetLabelSize(0.025);
4103	h->GetYaxis()->SetLabelSize(0.025);
4104	h->GetYaxis()->SetTitleOffset(1.2);
4105	h->Draw();
4106
4107	fGraphRateScan[0].SetName("CameraRate");
4108	for (int i=0; i<40; i++)
4109	{
4110	fGraphRateScan[i+1].SetName("BoardRate");
4111	fGraphRateScan[i+1].SetMarkerStyle(kFullDotMedium);
4112	}
4113	for (int i=0; i<160; i++)
4114	{
4115	fGraphRateScan[i+41].SetName("PatchRate");
4116	fGraphRateScan[i+41].SetMarkerStyle(kFullDotMedium);
4117	}
4118
4119	fGraphRateScan[0].SetLineColor(kBlue);
4120	fGraphRateScan[0].SetMarkerColor(kBlue);
4121	fGraphRateScan[0].SetMarkerStyle(kFullDotSmall);
4122	fGraphRateScan[0].Draw("LP");
4123
4124	// --------------------------------------------------------------------------
4125
4126	c = fFtmRateCanv->GetCanvas();
4127	//c->SetBit(TCanvas::kNoContextMenu);
4128	c->SetBorderMode(0);
4129	c->SetFrameBorderMode(0);
4130	c->SetFillColor(kWhite);
4131	c->SetRightMargin(0.03);
4132	c->SetTopMargin(0.03);
4133	c->SetGrid();
4134	c->cd();
4135
4136	hf = DrawTimeFrame("Trigger rate [Hz]");
4137	hf->GetYaxis()->SetRangeUser(0, 1010);
4138
4139	for (int i=0; i<160; i++)
4140	{
4141	fGraphPatchRate[i].SetName("PatchRate");
4142	//fGraphPatchRate[i].SetLineColor(kBlue);
4143	//fGraphPatchRate[i].SetMarkerColor(kBlue);
4144	fGraphPatchRate[i].SetMarkerStyle(kFullDotMedium);
4145	}
4146	for (int i=0; i<40; i++)
4147	{
4148	fGraphBoardRate[i].SetName("BoardRate");
4149	//fGraphBoardRate[i].SetLineColor(kBlue);
4150	//fGraphBoardRate[i].SetMarkerColor(kBlue);
4151	fGraphBoardRate[i].SetMarkerStyle(kFullDotMedium);
4152	}
4153
4154	fGraphFtmRate.SetLineColor(kBlue);
4155	fGraphFtmRate.SetMarkerColor(kBlue);
4156	fGraphFtmRate.SetMarkerStyle(kFullDotSmall);
4157	fGraphFtmRate.Draw("LP");
4158
4159	/*
4160	TCanvas *c = fFtmTempCanv->GetCanvas();
4161	c->SetBit(TCanvas::kNoContextMenu);
4162	c->SetBorderMode(0);
4163	c->SetFrameBorderMode(0);
4164	c->SetFillColor(kWhite);
4165	c->SetRightMargin(0.03);
4166	c->SetTopMargin(0.03);
4167	c->cd();
4168	*/
4169	//CreateTimeFrame("Temperature / �C");
4170
4171	fGraphFtmTemp[0].SetMarkerStyle(kFullDotSmall);
4172	fGraphFtmTemp[1].SetMarkerStyle(kFullDotSmall);
4173	fGraphFtmTemp[2].SetMarkerStyle(kFullDotSmall);
4174	fGraphFtmTemp[3].SetMarkerStyle(kFullDotSmall);
4175
4176	fGraphFtmTemp[1].SetLineColor(kBlue);
4177	fGraphFtmTemp[2].SetLineColor(kRed);
4178	fGraphFtmTemp[3].SetLineColor(kGreen);
4179
4180	fGraphFtmTemp[1].SetMarkerColor(kBlue);
4181	fGraphFtmTemp[2].SetMarkerColor(kRed);
4182	fGraphFtmTemp[3].SetMarkerColor(kGreen);
4183
4184	//fGraphFtmTemp[0].Draw("LP");
4185	//fGraphFtmTemp[1].Draw("LP");
4186	//fGraphFtmTemp[2].Draw("LP");
4187	//fGraphFtmTemp[3].Draw("LP");
4188
4189	// --------------------------------------------------------------------------
4190
4191	c = fAdcDataCanv->GetCanvas();
4192	//c->SetBit(TCanvas::kNoContextMenu);
4193	c->SetBorderMode(0);
4194	c->SetFrameBorderMode(0);
4195	c->SetFillColor(kWhite);
4196	c->SetRightMargin(0.10);
4197	c->SetGrid();
4198	//c->cd();
4199	#endif
4200
4201	// --------------------------------------------------------------------------
4202	fFeedbackDevCam->assignPixelMap(fPixelMap);
4203	fFeedbackDevCam->setAutoscaleLowerLimit((fFeedbackDevMin->minimum()+0.5*fFeedbackDevMin->singleStep()));
4204	fFeedbackDevCam->SetMin(fFeedbackDevMin->value());
4205	fFeedbackDevCam->SetMax(fFeedbackDevMax->value());
4206	fFeedbackDevCam->updateCamera();
4207
4208	fFeedbackCmdCam->assignPixelMap(fPixelMap);
4209	fFeedbackCmdCam->setAutoscaleLowerLimit((fFeedbackCmdMin->minimum()+0.5*fFeedbackCmdMin->singleStep()));
4210	fFeedbackCmdCam->SetMin(fFeedbackCmdMin->value());
4211	fFeedbackCmdCam->SetMax(fFeedbackCmdMax->value());
4212	fFeedbackCmdCam->updateCamera();
4213
4214	// --------------------------------------------------------------------------
4215
4216	fBiasCamV->assignPixelMap(fPixelMap);
4217	fBiasCamV->setAutoscaleLowerLimit((fBiasVoltMin->minimum()+0.5*fBiasVoltMin->singleStep()));
4218	fBiasCamV->SetMin(fBiasVoltMin->value());
4219	fBiasCamV->SetMax(fBiasVoltMax->value());
4220	fBiasCamV->updateCamera();
4221
4222	fBiasCamA->assignPixelMap(fPixelMap);
4223	fBiasCamA->setAutoscaleLowerLimit((fBiasCurrentMin->minimum()+0.5*fBiasCurrentMin->singleStep()));
4224	fBiasCamA->SetMin(fBiasCurrentMin->value());
4225	fBiasCamA->SetMax(fBiasCurrentMax->value());
4226	fBiasCamA->updateCamera();
4227
4228	// --------------------------------------------------------------------------
4229
4230	fRatesCanv->assignPixelMap(fPixelMap);
4231	fRatesCanv->setAutoscaleLowerLimit((fRatesMin->minimum()+0.5fRatesMin->singleStep())0.001);
4232	fRatesCanv->SetMin(fRatesMin->value());
4233	fRatesCanv->SetMax(fRatesMax->value());
4234	fRatesCanv->updateCamera();
4235	on_fPixelIdx_valueChanged(0);
4236
4237	// --------------------------------------------------------------------------
4238
4239	fRatesCanv->setTitle("Patch rates");
4240	fRatesCanv->setUnits("Hz");
4241
4242	fBiasCamA->setTitle("BIAS current");
4243	fBiasCamA->setUnits("uA");
4244
4245	fBiasCamV->setTitle("Applied BIAS voltage");
4246	fBiasCamV->setUnits("V");
4247
4248	fEventCanv1->setTitle("Average (all slices)");
4249	fEventCanv2->setTitle("RMS (all slices)");
4250	fEventCanv3->setTitle("Maximum (all slices)");
4251	fEventCanv4->setTitle("Position of maximum (all slices)");
4252
4253	fEventCanv1->setUnits("mV");
4254	fEventCanv2->setUnits("mV");
4255	fEventCanv3->setUnits("mV");
4256	fEventCanv4->setUnits("slice");
4257
4258	// --------------------------------------------------------------------------
4259
4260	fFeedbackDevCam->setTitle("Control deviation (Pulser amplitude voltage)");
4261	fFeedbackCmdCam->setTitle("Applied voltage change (BIAS voltage)");
4262
4263	fFeedbackDevCam->setUnits("mV");
4264	fFeedbackCmdCam->setUnits("mV");
4265
4266	// --------------------------------------------------------------------------
4267
4268	QTimer::singleShot(1000, this, SLOT(slot_RootUpdate()));
4269
4270	//widget->setMouseTracking(true);
4271	//widget->EnableSignalEvents(kMouseMoveEvent);
4272
4273	fFtmRateCanv->setMouseTracking(true);
4274	fFtmRateCanv->EnableSignalEvents(kMouseMoveEvent);
4275
4276	fAdcDataCanv->setMouseTracking(true);
4277	fAdcDataCanv->EnableSignalEvents(kMouseMoveEvent);
4278
4279	fRatesCanv->setMouseTracking(true);
4280	fEventCanv1->setMouseTracking(true);
4281	fEventCanv2->setMouseTracking(true);
4282	fEventCanv3->setMouseTracking(true);
4283	fEventCanv4->setMouseTracking(true);
4284
4285	fBiasCamV->setMouseTracking(true);
4286	fBiasCamA->setMouseTracking(true);
4287
4288	fFeedbackDevCam->setMouseTracking(true);
4289	fFeedbackCmdCam->setMouseTracking(true);
4290
4291	fEventCanv1->ShowPixelCursor(true);
4292	fEventCanv2->ShowPixelCursor(true);
4293	fEventCanv3->ShowPixelCursor(true);
4294	fEventCanv4->ShowPixelCursor(true);
4295
4296	fEventCanv1->ShowPatchCursor(true);
4297	fEventCanv2->ShowPatchCursor(true);
4298	fEventCanv3->ShowPatchCursor(true);
4299	fEventCanv4->ShowPatchCursor(true);
4300
4301	fFeedbackDevCam->ShowPixelCursor(true);
4302	fFeedbackCmdCam->ShowPixelCursor(true);
4303
4304	fFeedbackDevCam->ShowPatchCursor(true);
4305	fFeedbackCmdCam->ShowPatchCursor(true);
4306
4307	connect(fRatesCanv, SIGNAL(signalPixelMoveOver(int)),
4308	this, SLOT(slot_CameraMouseMove(int)));
4309	connect(fEventCanv1, SIGNAL(signalPixelMoveOver(int)),
4310	this, SLOT(slot_CameraMouseMove(int)));
4311	connect(fEventCanv2, SIGNAL(signalPixelMoveOver(int)),
4312	this, SLOT(slot_CameraMouseMove(int)));
4313	connect(fEventCanv3, SIGNAL(signalPixelMoveOver(int)),
4314	this, SLOT(slot_CameraMouseMove(int)));
4315	connect(fEventCanv4, SIGNAL(signalPixelMoveOver(int)),
4316	this, SLOT(slot_CameraMouseMove(int)));
4317
4318	connect(fBiasCamV, SIGNAL(signalPixelMoveOver(int)),
4319	this, SLOT(slot_CameraMouseMove(int)));
4320	connect(fBiasCamA, SIGNAL(signalPixelMoveOver(int)),
4321	this, SLOT(slot_CameraMouseMove(int)));
4322
4323	connect(fFeedbackDevCam, SIGNAL(signalPixelMoveOver(int)),
4324	this, SLOT(slot_CameraMouseMove(int)));
4325	connect(fFeedbackCmdCam, SIGNAL(signalPixelMoveOver(int)),
4326	this, SLOT(slot_CameraMouseMove(int)));
4327
4328	connect(fRatesCanv, SIGNAL(signalPixelDoubleClick(int)),
4329	this, SLOT(slot_CameraDoubleClick(int)));
4330	connect(fRatesCanv, SIGNAL(signalCurrentPixel(int)),
4331	this, SLOT(slot_ChoosePixelThreshold(int)));
4332	connect(fBiasCamV, SIGNAL(signalCurrentPixel(int)),
4333	this, SLOT(slot_ChooseBiasChannel(int)));
4334	connect(fBiasCamA, SIGNAL(signalCurrentPixel(int)),
4335	this, SLOT(slot_ChooseBiasChannel(int)));
4336
4337	connect(fFtmRateCanv, SIGNAL( RootEventProcessed(TObject, unsigned int, TCanvas)),
4338	this, SLOT (slot_RootEventProcessed(TObject, unsigned int, TCanvas)));
4339	connect(fAdcDataCanv, SIGNAL( RootEventProcessed(TObject, unsigned int, TCanvas)),
4340	this, SLOT (slot_RootEventProcessed(TObject, unsigned int, TCanvas)));
4341	}
4342
4343	~FactGui()
4344	{
4345	// Unsubscribe all services
4346	for (map<string,DimInfo*>::iterator i=fServices.begin();
4347	i!=fServices.end(); i++)
4348	delete i->second;
4349
4350	delete fEventData;
4351	}
4352	};
4353
4354	#endif

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

Download in other formats: