Context Navigation

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

Visit:

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

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

Download in other formats: