Context Navigation

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

Visit:

Last change on this file since 12292 was 12289, checked in by tbretz, 13 years ago
Store trigger rates for later display
File size: 131.9 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	FTM::DimTriggerRates fTriggerRates;
1945
1946	void UpdateTriggerRate(const FTM::DimTriggerRates &sdata)
1947	{
1948	#ifdef HAVE_ROOT
1949	TCanvas *c = fFtmRateCanv->GetCanvas();
1950
1951	TH1 h = (TH1)c->FindObject("TimeFrame");
1952
1953	if (sdata.fTriggerRate<0)
1954	{
1955	fGraphFtmRate.Set(0);
1956
1957	const double tm = Time().RootTime();
1958
1959	h->SetBins(1, tm, tm+60);
1960	h->GetXaxis()->SetTimeFormat("%M'%S\"");
1961	h->GetXaxis()->SetTitle("Time");
1962
1963	c->Modified();
1964	c->Update();
1965	return;
1966	}
1967
1968	const double t1 = h->GetXaxis()->GetXmax();
1969	const double t0 = h->GetXaxis()->GetXmin();
1970
1971	const double now = t0+sdata.fTimeStamp/1000000.;
1972
1973	h->SetBins(h->GetNbinsX()+1, t0, now+1);
1974	fGraphFtmRate.SetPoint(fGraphFtmRate.GetN(), now, sdata.fTriggerRate);
1975
1976	if (t1-t0>300)
1977	{
1978	h->GetXaxis()->SetTimeFormat("%Hh%M'");
1979	h->GetXaxis()->SetTitle("Time");
1980	}
1981
1982	h->SetMinimum(0);
1983
1984	c->Modified();
1985	c->Update();
1986	#endif
1987	}
1988
1989	void UpdateRatesCam(const FTM::DimTriggerRates &sdata)
1990	{
1991	if (fThresholdIdx->value()>=0)
1992	{
1993	const int isw = fThresholdIdx->value();
1994	const int ihw = fPatchMapHW[isw];
1995	fPatchRate->setValue(sdata.fPatchRate[ihw]);
1996	fBoardRate->setValue(sdata.fBoardRate[ihw/4]);
1997	}
1998
1999	valarray<double> dat(0., 1440);
2000
2001	// fPatch converts from software id to software patch id
2002	for (int i=0; i<1440; i++)
2003	{
2004	const int ihw = fPixelMap.index(i).hw()/9;
2005	dat[i] = sdata.fPatchRate[ihw];
2006
2007	// Was this meant for something?
2008	//fRatesCanv->SetEnable(ihw, fFtuStatus[ihw/4]);
2009	}
2010
2011	fRatesCanv->SetData(dat);
2012	fRatesCanv->updateCamera();
2013	}
2014
2015	int64_t fTimeStamp0;
2016
2017	void UpdateRatesGraphs(const FTM::DimTriggerRates &sdata)
2018	{
2019	#ifdef HAVE_ROOT
2020	if (fTimeStamp0<0)
2021	{
2022	fTimeStamp0 = sdata.fTimeStamp;
2023	return;
2024	}
2025
2026	TCanvas *c = fFtmRateCanv->GetCanvas();
2027
2028	TH1 h = (TH1)c->FindObject("TimeFrame");
2029
2030	const double tdiff = sdata.fTimeStamp-fTimeStamp0;
2031	fTimeStamp0 = sdata.fTimeStamp;
2032
2033	if (tdiff<0)
2034	{
2035	for (int i=0; i<160; i++)
2036	fGraphPatchRate[i].Set(0);
2037	for (int i=0; i<40; i++)
2038	fGraphBoardRate[i].Set(0);
2039
2040	return;
2041	}
2042
2043	//const double t1 = h->GetXaxis()->GetXmax();
2044	const double t0 = h->GetXaxis()->GetXmin();
2045
2046	for (int i=0; i<160; i++)
2047	if (fFtuStatus[i/4]>0)
2048	fGraphPatchRate[i].SetPoint(fGraphPatchRate[i].GetN(),
2049	t0+sdata.fTimeStamp/1000000., sdata.fPatchRate[i]);
2050	for (int i=0; i<40; i++)
2051	if (fFtuStatus[i]>0)
2052	fGraphBoardRate[i].SetPoint(fGraphBoardRate[i].GetN(),
2053	t0+sdata.fTimeStamp/1000000., sdata.fBoardRate[i]);
2054
2055	c->Modified();
2056	c->Update();
2057	#endif
2058	}
2059
2060	void handleFtmTriggerRates(const DimData &d)
2061	{
2062	if (!CheckSize(d, sizeof(FTM::DimTriggerRates)))
2063	return;
2064
2065	const FTM::DimTriggerRates &sdata = d.ref<FTM::DimTriggerRates>();
2066
2067	fFtmTime->setText(QString::number(sdata.fTimeStamp/1000000., 'f', 6)+ " s");
2068	fTriggerCounter->setText(QString::number(sdata.fTriggerCounter));
2069
2070	if (sdata.fTimeStamp>0)
2071	fTriggerCounterRate->setValue(1000000.*sdata.fTriggerCounter/sdata.fTimeStamp);
2072	else
2073	fTriggerCounterRate->setValue(0);
2074
2075	// ----------------------------------------------
2076
2077	fOnTime->setText(QString::number(sdata.fOnTimeCounter/1000000., 'f', 6)+" s");
2078
2079	if (sdata.fTimeStamp>0)
2080	fOnTimeRel->setValue(100.*sdata.fOnTimeCounter/sdata.fTimeStamp);
2081	else
2082	fOnTimeRel->setValue(0);
2083
2084	// ----------------------------------------------
2085
2086	UpdateTriggerRate(sdata);
2087	UpdateRatesGraphs(sdata);
2088	UpdateRatesCam(sdata);
2089
2090	fTriggerRates = sdata;
2091	}
2092
2093	void handleFtmCounter(const DimData &d)
2094	{
2095	if (!CheckSize(d, sizeof(uint32_t)*6))
2096	return;
2097
2098	const uint32_t *sdata = d.ptr<uint32_t>();
2099
2100	fFtmCounterH->setValue(sdata[0]);
2101	fFtmCounterS->setValue(sdata[1]);
2102	fFtmCounterD->setValue(sdata[2]);
2103	fFtmCounterF->setValue(sdata[3]);
2104	fFtmCounterE->setValue(sdata[4]);
2105	fFtmCounterR->setValue(sdata[5]);
2106	}
2107
2108	void handleFtmDynamicData(const DimData &d)
2109	{
2110	if (!CheckSize(d, sizeof(FTM::DimDynamicData)))
2111	return;
2112
2113	const FTM::DimDynamicData &sdata = d.ref<FTM::DimDynamicData>();
2114
2115	fFtmTemp0->setValue(sdata.fTempSensor[0]*0.1);
2116	fFtmTemp1->setValue(sdata.fTempSensor[1]*0.1);
2117	fFtmTemp2->setValue(sdata.fTempSensor[2]*0.1);
2118	fFtmTemp3->setValue(sdata.fTempSensor[3]*0.1);
2119
2120	SetLedColor(fClockCondLed, sdata.fState&FTM::kFtmLocked ? kLedGreen : kLedRed, d.time);
2121	}
2122
2123	void DisplayRates()
2124	{
2125	#ifdef HAVE_ROOT
2126	TCanvas *c = fFtmRateCanv->GetCanvas();
2127
2128	while (c->FindObject("PatchRate"))
2129	c->GetListOfPrimitives()->Remove(c->FindObject("PatchRate"));
2130
2131	while (c->FindObject("BoardRate"))
2132	c->GetListOfPrimitives()->Remove(c->FindObject("BoardRate"));
2133
2134	c->cd();
2135
2136	if (fRatePatch1->value()>=0)
2137	{
2138	fGraphPatchRate[fRatePatch1->value()].SetLineColor(kRed);
2139	fGraphPatchRate[fRatePatch1->value()].SetMarkerColor(kRed);
2140	fGraphPatchRate[fRatePatch1->value()].Draw("PL");
2141	}
2142	if (fRatePatch2->value()>=0)
2143	{
2144	fGraphPatchRate[fRatePatch2->value()].SetLineColor(kGreen);
2145	fGraphPatchRate[fRatePatch2->value()].SetMarkerColor(kGreen);
2146	fGraphPatchRate[fRatePatch2->value()].Draw("PL");
2147	}
2148	if (fRateBoard1->value()>=0)
2149	{
2150	fGraphBoardRate[fRateBoard1->value()].SetLineColor(kMagenta);
2151	fGraphBoardRate[fRateBoard1->value()].SetMarkerColor(kMagenta);
2152	fGraphBoardRate[fRateBoard1->value()].Draw("PL");
2153	}
2154	if (fRateBoard2->value()>=0)
2155	{
2156	fGraphBoardRate[fRateBoard2->value()].SetLineColor(kCyan);
2157	fGraphBoardRate[fRateBoard2->value()].SetMarkerColor(kCyan);
2158	fGraphBoardRate[fRateBoard2->value()].Draw("PL");
2159	}
2160	#endif
2161	}
2162
2163	FTM::DimStaticData fFtmStaticData;
2164
2165	void SetFtuLed(int idx, int counter, const Time &t)
2166	{
2167	if (counter==0 \|\| counter>3)
2168	counter = 3;
2169
2170	if (counter<0)
2171	counter = 0;
2172
2173	const LedColor_t col[4] = { kLedGray, kLedGreen, kLedOrange, kLedRed };
2174
2175	SetLedColor(fFtuLED[idx], col[counter], t);
2176
2177	fFtuStatus[idx] = counter;
2178	}
2179
2180	void SetFtuStatusLed(const Time &t)
2181	{
2182	const int max = fFtuStatus.max();
2183
2184	switch (max)
2185	{
2186	case 0:
2187	SetLedColor(fStatusFTULed, kLedGray, t);
2188	fStatusFTULabel->setText("All disabled");
2189	fStatusFTULabel->setToolTip("All FTUs are disabled");
2190	break;
2191
2192	case 1:
2193	SetLedColor(fStatusFTULed, kLedGreen, t);
2194	fStatusFTULabel->setToolTip("Communication with FTU is smooth.");
2195	fStatusFTULabel->setText("ok");
2196	break;
2197
2198	case 2:
2199	SetLedColor(fStatusFTULed, kLedOrange, t);
2200	fStatusFTULabel->setText("Warning");
2201	fStatusFTULabel->setToolTip("At least one FTU didn't answer immediately");
2202	break;
2203
2204	case 3:
2205	SetLedColor(fStatusFTULed, kLedRed, t);
2206	fStatusFTULabel->setToolTip("At least one FTU didn't answer!");
2207	fStatusFTULabel->setText("ERROR");
2208	break;
2209	}
2210
2211	const int cnt = count(&fFtuStatus[0], &fFtuStatus[40], 0);
2212	fFtuAllOn->setEnabled(cnt!=0);
2213	fFtuAllOff->setEnabled(cnt!=40);
2214	}
2215
2216	void handleFtmStaticData(const DimData &d)
2217	{
2218	if (!CheckSize(d, sizeof(FTM::DimStaticData)))
2219	return;
2220
2221	const FTM::DimStaticData &sdata = d.ref<FTM::DimStaticData>();
2222
2223	fTriggerInterval->setValue(sdata.fTriggerInterval);
2224	fPhysicsCoincidence->setValue(sdata.fMultiplicityPhysics);
2225	fCalibCoincidence->setValue(sdata.fMultiplicityCalib);
2226	fPhysicsWindow->setValue(sdata.fWindowPhysics);
2227	fCalibWindow->setValue(sdata.fWindowCalib);
2228
2229	fTriggerDelay->setValue(sdata.fDelayTrigger);
2230	fTimeMarkerDelay->setValue(sdata.fDelayTimeMarker);
2231	fDeadTime->setValue(sdata.fDeadTime);
2232
2233	fClockCondR0->setValue(sdata.fClockConditioner[0]);
2234	fClockCondR1->setValue(sdata.fClockConditioner[1]);
2235	fClockCondR8->setValue(sdata.fClockConditioner[2]);
2236	fClockCondR9->setValue(sdata.fClockConditioner[3]);
2237	fClockCondR11->setValue(sdata.fClockConditioner[4]);
2238	fClockCondR13->setValue(sdata.fClockConditioner[5]);
2239	fClockCondR14->setValue(sdata.fClockConditioner[6]);
2240	fClockCondR15->setValue(sdata.fClockConditioner[7]);
2241
2242	const uint32_t R0 = sdata.fClockConditioner[0];
2243	const uint32_t R14 = sdata.fClockConditioner[6];
2244	const uint32_t R15 = sdata.fClockConditioner[7];
2245
2246	const uint32_t Ndiv = (R15&0x1ffff00)<<2;
2247	const uint32_t Rdiv = (R14&0x007ff00)>>8;
2248	const uint32_t Cdiv = (R0 &0x000ff00)>>8;
2249
2250	double freq = 40.Ndiv/(RdivCdiv);
2251
2252	fClockCondFreqRes->setValue(freq);
2253
2254	//fClockCondFreq->setEditText("");
2255	fClockCondFreq->setCurrentIndex(0);
2256
2257	fTriggerSeqPed->setValue(sdata.fTriggerSeqPed);
2258	fTriggerSeqLPint->setValue(sdata.fTriggerSeqLPint);
2259	fTriggerSeqLPext->setValue(sdata.fTriggerSeqLPext);
2260
2261	fLpIntIntensity->setValue(sdata.fIntensityLPint);
2262	fLpExtIntensity->setValue(sdata.fIntensityLPext);
2263
2264	fLpIntGroup1->setChecked(sdata.HasLPintG1());
2265	fLpIntGroup2->setChecked(sdata.HasLPintG2());
2266	fLpExtGroup1->setChecked(sdata.HasLPextG1());
2267	fLpExtGroup2->setChecked(sdata.HasLPextG2());
2268
2269	fEnableTrigger->setChecked(sdata.HasTrigger());
2270	fEnableVeto->setChecked(sdata.HasVeto());
2271	fEnableExt1->setChecked(sdata.HasExt1());
2272	fEnableExt2->setChecked(sdata.HasExt2());
2273	fEnableClockCond->setChecked(sdata.HasClockConditioner());
2274
2275	uint16_t multiplicity = sdata.fMultiplicity[0];
2276
2277	for (int i=0; i<40; i++)
2278	{
2279	if (!sdata.IsActive(i))
2280	SetFtuLed(i, -1, d.time);
2281	else
2282	{
2283	if (fFtuStatus[i]==0)
2284	SetFtuLed(i, 1, d.time);
2285	}
2286	fFtuLED[i]->setChecked(false);
2287
2288	if (sdata.fMultiplicity[i]!=multiplicity)
2289	multiplicity = -1;
2290
2291	}
2292	SetFtuStatusLed(d.time);
2293
2294	fNoutof4Val->setValue(multiplicity);
2295
2296	for (vector<PixelMapEntry>::const_iterator it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
2297	fRatesCanv->SetEnable(it->index, sdata.IsEnabled(it->hw()));
2298
2299	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
2300	fPixelEnable->setChecked(sdata.IsEnabled(entry.hw()));
2301
2302	if (fThresholdIdx->value()>=0)
2303	{
2304	const int isw = fThresholdIdx->value();
2305	const int ihw = fPatchMapHW[isw];
2306	fThresholdVal->setValue(sdata.fThreshold[ihw]);
2307	}
2308
2309	fPrescalingVal->setValue(sdata.fPrescaling[0]);
2310
2311	fFtmStaticData = sdata;
2312	}
2313
2314	void handleFtmPassport(const DimData &d)
2315	{
2316	if (!CheckSize(d, sizeof(FTM::DimPassport)))
2317	return;
2318
2319	const FTM::DimPassport &sdata = d.ref<FTM::DimPassport>();
2320
2321	stringstream str1, str2;
2322	str1 << hex << "0x" << setfill('0') << setw(16) << sdata.fBoardId;
2323	str2 << sdata.fFirmwareId;
2324
2325	fFtmBoardId->setText(str1.str().c_str());
2326	fFtmFirmwareId->setText(str2.str().c_str());
2327	}
2328
2329	void handleFtmFtuList(const DimData &d)
2330	{
2331	if (!CheckSize(d, sizeof(FTM::DimFtuList)))
2332	return;
2333
2334	fFtuPing->setChecked(false);
2335
2336	const FTM::DimFtuList &sdata = d.ref<FTM::DimFtuList>();
2337
2338	stringstream str;
2339	str << "<table width='100%'>" << setfill('0');
2340	str << "<tr><th>Num</th><th></th><th>Addr</th><th></th><th>DNA</th></tr>";
2341	for (int i=0; i<40; i++)
2342	{
2343	str << "<tr>";
2344	str << "<td align='center'>" << dec << i << hex << "</td>";
2345	str << "<td align='center'>:</td>";
2346	str << "<td align='center'>0x" << setw(2) << (int)sdata.fAddr[i] << "</td>";
2347	str << "<td align='center'>:</td>";
2348	str << "<td align='center'>0x" << setw(16) << sdata.fDNA[i] << "</td>";
2349	str << "</tr>";
2350	}
2351	str << "</table>";
2352
2353	fFtuDNA->setText(str.str().c_str());
2354
2355	fFtuAnswersTotal->setValue(sdata.fNumBoards);
2356	fFtuAnswersCrate0->setValue(sdata.fNumBoardsCrate[0]);
2357	fFtuAnswersCrate1->setValue(sdata.fNumBoardsCrate[1]);
2358	fFtuAnswersCrate2->setValue(sdata.fNumBoardsCrate[2]);
2359	fFtuAnswersCrate3->setValue(sdata.fNumBoardsCrate[3]);
2360
2361	for (int i=0; i<40; i++)
2362	SetFtuLed(i, sdata.IsActive(i) ? sdata.fPing[i] : -1, d.time);
2363
2364	SetFtuStatusLed(d.time);
2365	}
2366
2367	void handleFtmError(const DimData &d)
2368	{
2369	if (!CheckSize(d, sizeof(FTM::DimError)))
2370	return;
2371
2372	const FTM::DimError &sdata = d.ref<FTM::DimError>();
2373
2374	SetFtuLed(sdata.fError.fDestAddress, sdata.fError.fNumCalls, d.time);
2375	SetFtuStatusLed(d.time);
2376
2377	// FIXME: Write to special window!
2378	//Out() << "Error:" << endl;
2379	//Out() << sdata.fError << endl;
2380	}
2381
2382	// ========================== FSC =======================================
2383
2384	void SetFscValue(QDoubleSpinBox *box, const DimData &d, int idx, bool enable)
2385	{
2386	//box->setEnabled(enable);
2387	if (!enable)
2388	{
2389	box->setToolTip(d.time.GetAsStr().c_str());
2390	return;
2391	}
2392
2393	ostringstream str;
2394	str << d.time << " -- " << d.get<float>() << "s";
2395
2396	box->setToolTip(str.str().c_str());
2397	box->setValue(d.get<float>(idx*4+4));
2398	}
2399
2400
2401	void handleFscTemp(const DimData &d)
2402	{
2403	const bool enable = d.size()>0 && CheckSize(d, 60*sizeof(float));
2404	if (!enable)
2405	return;
2406
2407	QDoubleSpinBox *boxes[] = {
2408	fTempCam00, fTempCam01,
2409	fTempCam10, fTempCam11, fTempCam12, fTempCam13, fTempCam14,
2410	fTempCam20, fTempCam21, fTempCam22, fTempCam23, fTempCam24, fTempCam25,
2411	fTempCam30, fTempCam31, fTempCam32, fTempCam33, fTempCam34,
2412	fTempCam40, fTempCam41, fTempCam42, fTempCam43, fTempCam44, fTempCam45,
2413	fTempCam50, fTempCam51, fTempCam52, fTempCam53, fTempCam54,
2414	fTempCam60, fTempCam61,
2415	// 0:b/f 1:b/f 2:b/f 3:b/f
2416	fTempCrate0back, fTempCrate0front,
2417	fTempCrate1back, fTempCrate1front,
2418	fTempCrate2back, fTempCrate2front,
2419	fTempCrate3back, fTempCrate3front,
2420	// 0:b/f 1:b/f 2:b/f 3:b/f
2421	fTempPS0back, fTempPS0front,
2422	fTempPS1back, fTempPS1front,
2423	fTempPS2back, fTempPS2front,
2424	fTempPS3back, fTempPS3front,
2425	// AUX PS: FTM t/b; FSC t/b
2426	fTempAuxFTMtop, fTempAuxFTMbottom,
2427	fTempAuxFSCtop, fTempAuxFSCbottom,
2428	// Backpanel: FTM t/b; FSC t/b
2429	fTempBackpanelFTMtop, fTempBackpanelFTMbottom,
2430	fTempBackpanelFSCtop, fTempBackpanelFSCbottom,
2431	// top front/back; bottom front/back
2432	fTempSwitchboxTopFront, fTempSwitchboxTopBack,
2433	fTempSwitchboxBottomFront, fTempSwitchboxBottomBack,
2434	};
2435
2436	for (int i=0; i<59; i++)
2437	SetFscValue(boxes[i], d, i, enable);
2438
2439	if (!enable)
2440	return;
2441
2442	const float *ptr = d.ptr<float>();
2443
2444	double avg = 0;
2445	int num = 0;
2446	for (int i=1; i<32; i++)
2447	if (ptr[i]!=0)
2448	{
2449	avg += ptr[i];
2450	num ++;
2451	}
2452
2453	fTempCamAvg->setValue(num?avg/num:0);
2454	}
2455
2456	void handleFscVolt(const DimData &d)
2457	{
2458	const bool enable = d.size()>0 && CheckSize(d, 31*sizeof(float));
2459	if (!enable)
2460	return;
2461
2462	QDoubleSpinBox *boxes[] = {
2463	fVoltFad00, fVoltFad10, fVoltFad20, fVoltFad30,
2464	fVoltFad01, fVoltFad11, fVoltFad21, fVoltFad31,
2465	fVoltFad02, fVoltFad12, fVoltFad22, fVoltFad32,
2466	fVoltFPA00, fVoltFPA10, fVoltFPA20, fVoltFPA30,
2467	fVoltFPA01, fVoltFPA11, fVoltFPA21, fVoltFPA31,
2468	fVoltFPA02, fVoltFPA12, fVoltFPA22, fVoltFPA32,
2469	fVoltETH0, fVoltETH1,
2470	fVoltFTM0, fVoltFTM1,
2471	fVoltFFC, fVoltFLP,
2472	};
2473
2474	for (int i=0; i<30; i++)
2475	SetFscValue(boxes[i], d, i, enable);
2476	}
2477
2478	void handleFscCurrent(const DimData &d)
2479	{
2480	const bool enable = d.size()>0 && CheckSize(d, 31*sizeof(float));
2481	if (!enable)
2482	return;
2483
2484	QDoubleSpinBox *boxes[] = {
2485	fAmpFad00, fAmpFad10, fAmpFad20, fAmpFad30,
2486	fAmpFad01, fAmpFad11, fAmpFad21, fAmpFad31,
2487	fAmpFad02, fAmpFad12, fAmpFad22, fAmpFad32,
2488	fAmpFPA00, fAmpFPA10, fAmpFPA20, fAmpFPA30,
2489	fAmpFPA01, fAmpFPA11, fAmpFPA21, fAmpFPA31,
2490	fAmpFPA02, fAmpFPA12, fAmpFPA22, fAmpFPA32,
2491	fAmpETH0, fAmpETH1,
2492	fAmpFTM0, fAmpFTM1,
2493	fAmpFFC, fAmpFLP,
2494	};
2495
2496	for (int i=0; i<30; i++)
2497	SetFscValue(boxes[i], d, i, enable);
2498	}
2499
2500	void handleFscHumidity(const DimData &d)
2501	{
2502	const bool enable = d.size()>0 && CheckSize(d, 5*sizeof(float));
2503
2504	SetFscValue(fHumidity1, d, 0, enable);
2505	SetFscValue(fHumidity2, d, 1, enable);
2506	SetFscValue(fHumidity3, d, 2, enable);
2507	SetFscValue(fHumidity4, d, 3, enable);
2508	}
2509
2510	// ========================== Feedback ==================================
2511
2512	#ifdef HAVE_ROOT
2513	TGraphErrors fGraphFeedbackDev;
2514	TGraphErrors fGraphFeedbackCmd;
2515
2516	void UpdateFeedback(TQtWidget &rwidget, const Time &time, TGraphErrors &graph, double avg, double rms)
2517	{
2518	TCanvas *c = rwidget.GetCanvas();
2519
2520	TH1 h = (TH1)c->FindObject("TimeFrame");
2521
2522	while (graph.GetN()>500)
2523	graph.RemovePoint(0);
2524
2525	const double now = time.RootTime();
2526
2527	while (graph.GetN()>0 && now-graph.GetX()[0]>3600)
2528	graph.RemovePoint(0);
2529
2530	const int n = graph.GetN();
2531
2532	const double xmin = n>0 ? graph.GetX()[0] : now;
2533
2534	h->SetBins(n+1, xmin-1, now+1);
2535	graph.SetPoint(n, now, avg);
2536	graph.SetPointError(n, 0, rms);
2537
2538	h->GetXaxis()->SetTimeFormat(now-xmin>300 ? "%Hh%M'" : "%M'%S\"");
2539
2540	c->Modified();
2541	c->Update();
2542	}
2543	#endif
2544
2545	void handleFeedbackDeviation(const DimData &d)
2546	{
2547	if (!CheckSize(d, 2416sizeof(float)))
2548	return;
2549
2550	const float *ptr = d.ptr<float>();
2551
2552	valarray<float> dev(1440);
2553	valarray<float> cmd(1440);
2554
2555	double avgdev = 0;
2556	double avgcmd = 0;
2557
2558	double rmsdev = 0;
2559	double rmscmd = 0;
2560
2561	for (int i=0; i<1440; i++)
2562	{
2563	const PixelMapEntry &entry = fPixelMap.index(i);
2564
2565	dev[i] = /1000/ptr[entry.hv()];
2566	cmd[i] = 1000*ptr[entry.hv()+416];
2567
2568	avgdev += dev[i];
2569	avgcmd += cmd[i];
2570
2571	rmsdev += dev[i]*dev[i];
2572	rmscmd += cmd[i]*cmd[i];
2573	}
2574
2575	avgdev /= 1440;
2576	avgcmd /= 1440;
2577
2578	rmsdev = sqrt(rmsdev/1440 - avgdev*avgdev);
2579	rmscmd = sqrt(rmscmd/1440 - avgcmd*avgcmd);
2580
2581	fFeedbackDevCam->SetData(dev);
2582	fFeedbackCmdCam->SetData(cmd);
2583
2584	fFeedbackDevCam->updateCamera();
2585	fFeedbackCmdCam->updateCamera();
2586
2587	#ifdef HAVE_ROOT
2588	UpdateFeedback(*fFeedbackDev, d.time, fGraphFeedbackDev, avgdev, rmsdev);
2589	UpdateFeedback(*fFeedbackCmd, d.time, fGraphFeedbackCmd, avgcmd, rmscmd);
2590	#endif
2591	}
2592
2593	void handleFeedbackReference(const DimData &d)
2594	{
2595	if (!CheckSize(d, 416*sizeof(float)))
2596	return;
2597
2598	const float *ptr = d.ptr<float>();
2599
2600	// fFeedbackRefCam->SetData(valarray<float>(ptr, 416));
2601	// fFeedbackRefCam->updateCamera();
2602	}
2603
2604	// ========================== FSC =======================================
2605
2606	vector<int16_t> fVecBiasVolt;
2607	vector<int16_t> fVecBiasCurrent;
2608
2609	void handleBiasVolt(const DimData &d)
2610	{
2611	if (!CheckSize(d, 2416sizeof(int16_t)))
2612	return;
2613
2614	const int16_t *ptr = d.ptr<int16_t>();
2615
2616	fVecBiasVolt.assign(ptr, ptr+2*416);
2617
2618	on_fBiasDispRefVolt_stateChanged();
2619	UpdateBiasValues();
2620	}
2621
2622	void handleBiasCurrent(const DimData &d)
2623	{
2624	if (!CheckSize(d, 416*sizeof(int16_t)))
2625	return;
2626
2627	const int16_t *ptr = d.ptr<int16_t>();
2628
2629	fVecBiasCurrent.assign(ptr, ptr+416);
2630
2631	valarray<double> dat(0., 1440);
2632
2633	// fPatch converts from software id to software patch id
2634	for (int i=0; i<1440; i++)
2635	{
2636	const PixelMapEntry &entry = fPixelMap.index(i);
2637
2638	// FIXME: Display Overcurrent
2639	dat[i] = abs(ptr[entry.hv()])*5000./4096;
2640
2641	fBiasCamA->SetEnable(i, uint16_t(ptr[entry.hv()])!=0x8000);
2642	fBiasCamA->highlightPixel(i, ptr[entry.hv()]<0);
2643	}
2644
2645	fBiasCamA->SetData(dat);
2646	fBiasCamA->updateCamera();
2647
2648	UpdateBiasValues();
2649	}
2650
2651	// ====================== MessageImp ====================================
2652
2653	bool fChatOnline;
2654
2655	void handleStateChanged(const Time &time, const std::string &server,
2656	const State &s)
2657	{
2658	// FIXME: Prefix tooltip with time
2659	if (server=="MCP")
2660	{
2661	// FIXME: Enable FTU page!!!
2662	fStatusMCPLabel->setText(s.name.c_str());
2663	fStatusMCPLabel->setToolTip(s.comment.c_str());
2664
2665	if (s.index<2) // No Dim connection
2666	SetLedColor(fStatusMCPLed, kLedGray, time);
2667	if (s.index==2) // Disconnected
2668	SetLedColor(fStatusMCPLed, kLedRed, time);
2669	if (s.index==3) // Connecting
2670	SetLedColor(fStatusMCPLed, kLedOrange, time);
2671	if (s.index==4) // Connected
2672	SetLedColor(fStatusMCPLed, kLedYellow, time);
2673	if (s.index==5 \|\| s.index==10) // Idle
2674	SetLedColor(fStatusMCPLed, kLedGreen, time);
2675
2676	if (s.index>=7 && s.index<=9)
2677	SetLedColor(fStatusMCPLed, kLedGreenBar, time);
2678
2679	fMcpStartRun->setEnabled(s.index>=5);
2680	fMcpStopRun->setEnabled(s.index>=5);
2681	fMcpReset->setEnabled(s.index>=7 && s.index<=10);
2682	}
2683
2684	if (server=="FTM_CONTROL")
2685	{
2686	// FIXME: Enable FTU page!!!
2687	fStatusFTMLabel->setText(s.name.c_str());
2688	fStatusFTMLabel->setToolTip(s.comment.c_str());
2689
2690	bool enable = false;
2691	const bool configuring =
2692	s.index==FTM::StateMachine::kConfiguring1 \|\|
2693	s.index==FTM::StateMachine::kConfiguring2 \|\|
2694	s.index==FTM::StateMachine::kConfigured;
2695
2696
2697	if (s.index<FTM::StateMachine::kDisconnected) // No Dim connection
2698	SetLedColor(fStatusFTMLed, kLedGray, time);
2699	if (s.index==FTM::StateMachine::kDisconnected) // Dim connection / FTM disconnected
2700	SetLedColor(fStatusFTMLed, kLedYellow, time);
2701	if (s.index==FTM::StateMachine::kConnected \|\|
2702	s.index==FTM::StateMachine::kIdle \|\|
2703	configuring \|\|
2704	s.index==FTM::StateMachine::kTakingData) // Dim connection / FTM connected
2705	SetLedColor(fStatusFTMLed, kLedGreen, time);
2706
2707	if (s.index==FTM::StateMachine::kConnected \|\|
2708	s.index==FTM::StateMachine::kIdle) // Dim connection / FTM connected
2709	enable = true;
2710
2711	fFtmStartRun->setEnabled(!configuring && enable);
2712	fFtmStopRun->setEnabled(!configuring && (enable \|\| s.index==FTM::StateMachine::kTakingData));
2713
2714	fTriggerWidget->setEnabled(enable);
2715	fFtuGroupEnable->setEnabled(enable);
2716	fRatesControls->setEnabled(enable);
2717	fFtuWidget->setEnabled(s.index>FTM::StateMachine::kDisconnected);
2718
2719	if (s.index>=FTM::StateMachine::kConnected)
2720	SetFtuStatusLed(time);
2721	else
2722	{
2723	SetLedColor(fStatusFTULed, kLedGray, time);
2724	fStatusFTULabel->setText("Offline");
2725	fStatusFTULabel->setToolTip("FTM is not online.");
2726	}
2727	}
2728
2729	if (server=="FAD_CONTROL")
2730	{
2731	fStatusFADLabel->setText(s.name.c_str());
2732	fStatusFADLabel->setToolTip(s.comment.c_str());
2733
2734	bool enable = false;
2735
2736	if (s.index<FAD::kOffline) // No Dim connection
2737	{
2738	SetLedColor(fStatusFADLed, kLedGray, time);
2739
2740	// Timing problem - sometimes they stay gray :(
2741	//for (int i=0; i<40; i++)
2742	// SetLedColor(fFadLED[i], kLedGray, time);
2743
2744	/*
2745	fStatusEventBuilderLabel->setText("Offline");
2746	fStatusEventBuilderLabel->setToolTip("No connection to fadctrl.");
2747	fEvtBldWidget->setEnabled(false);
2748
2749	SetLedColor(fStatusEventBuilderLed, kLedGray, time);
2750	*/
2751	}
2752	if (s.index==FAD::kOffline) // Dim connection / FTM disconnected
2753	SetLedColor(fStatusFADLed, kLedRed, time);
2754	if (s.index==FAD::kDisconnected) // Dim connection / FTM disconnected
2755	SetLedColor(fStatusFADLed, kLedOrange, time);
2756	if (s.index==FAD::kConnecting) // Dim connection / FTM disconnected
2757	{
2758	SetLedColor(fStatusFADLed, kLedYellow, time);
2759	// FIXME FIXME FIXME: The LEDs are not displayed when disabled!
2760	enable = true;
2761	}
2762	if (s.index>=FAD::kConnected) // Dim connection / FTM connected
2763	{
2764	SetLedColor(fStatusFADLed, kLedGreen, time);
2765	enable = true;
2766	}
2767
2768	fFadWidget->setEnabled(enable);
2769
2770	fFadStart->setEnabled(s.index==FAD::kOffline);
2771	fFadStop->setEnabled(s.index>FAD::kOffline);
2772	fFadAbort->setEnabled(s.index>FAD::kOffline);
2773	fFadSoftReset->setEnabled(s.index>FAD::kOffline);
2774	fFadHardReset->setEnabled(s.index>FAD::kOffline);
2775	}
2776
2777	if (server=="FSC_CONTROL")
2778	{
2779	fStatusFSCLabel->setText(s.name.c_str());
2780	fStatusFSCLabel->setToolTip(s.comment.c_str());
2781
2782	bool enable = false;
2783
2784	if (s.index<1) // No Dim connection
2785	SetLedColor(fStatusFSCLed, kLedGray, time);
2786	if (s.index==1) // Dim connection / FTM disconnected
2787	SetLedColor(fStatusFSCLed, kLedRed, time);
2788	if (s.index>=2) // Dim connection / FTM disconnected
2789	{
2790	SetLedColor(fStatusFSCLed, kLedGreen, time);
2791	enable = true;
2792	}
2793
2794	fAuxWidget->setEnabled(enable);
2795	}
2796
2797	if (server=="BIAS_CONTROL")
2798	{
2799	fStatusBiasLabel->setText(s.name.c_str());
2800	fStatusBiasLabel->setToolTip(s.comment.c_str());
2801
2802	if (s.index<1) // No Dim connection
2803	SetLedColor(fStatusBiasLed, kLedGray, time);
2804	if (s.index==BIAS::kDisconnected) // Dim connection / FTM disconnected
2805	SetLedColor(fStatusBiasLed, kLedRed, time);
2806	if (s.index==BIAS::kConnecting \|\| s.index==BIAS::kInitializing) // Connecting / Initializing
2807	SetLedColor(fStatusBiasLed, kLedOrange, time);
2808	if (s.index==BIAS::kVoltageOff) // At reference
2809	SetLedColor(fStatusBiasLed, kLedGreen, time);
2810	if (s.index==BIAS::kNotReferenced) // At reference
2811	SetLedColor(fStatusBiasLed, kLedGreenWarn, time);
2812	if (s.index==BIAS::kRamping) // Ramping
2813	SetLedColor(fStatusBiasLed, kLedInProgress, time);
2814	if (s.index==BIAS::kVoltageOn) // At reference
2815	SetLedColor(fStatusBiasLed, kLedGreenCheck, time);
2816	if (s.index==BIAS::kOverCurrent) // Over current
2817	SetLedColor(fStatusBiasLed, kLedWarnBorder, time);
2818	if (s.index==BIAS::kExpertMode) // ExpertMode
2819	SetLedColor(fStatusBiasLed, kLedWarnTriangleBorder, time);
2820
2821	fBiasWidget->setEnabled(s.index>=3);
2822	}
2823
2824	if (server=="FEEDBACK")
2825	{
2826	fStatusFeedbackLabel->setText(s.name.c_str());
2827	fStatusFeedbackLabel->setToolTip(s.comment.c_str());
2828
2829	if (s.index>6) // Running
2830	SetLedColor(fStatusFeedbackLed, kLedGreenCheck, time);
2831	if (s.index==5 \|\| s.index==6) // Idle
2832	SetLedColor(fStatusFeedbackLed, kLedGreen, time);
2833	if (s.index==4) // Connected
2834	SetLedColor(fStatusFeedbackLed, kLedYellow, time);
2835	if (s.index==3) // Connecting
2836	SetLedColor(fStatusFeedbackLed, kLedOrange, time);
2837	if (s.index<3) // NoDim / Disconnected
2838	SetLedColor(fStatusFeedbackLed, kLedRed, time);
2839	if (s.index<1) // No Dim connection
2840	SetLedColor(fStatusFeedbackLed, kLedGray, time);
2841
2842	fFeedbackWidget->setEnabled(s.index>=3);
2843	fFeedbackStop->setEnabled(s.index>4);
2844	fFeedbackTempStart->setEnabled(s.index==4);
2845	fFeedbackTempOffset->setEnabled(s.index<=4);
2846	fFeedbackOutputEnable->setEnabled(s.index<=6);
2847	fFeedbackOutputDisable->setEnabled(s.index!=5 && s.index!=6);
2848
2849	fFeedbackFrameLeft->setEnabled(s.index!=5 && s.index!=7);
2850	fFeedbackCanvLeft->setEnabled(s.index!=5 && s.index!=7);
2851	}
2852
2853	if (server=="DATA_LOGGER")
2854	{
2855	fStatusLoggerLabel->setText(s.name.c_str());
2856	fStatusLoggerLabel->setToolTip(s.comment.c_str());
2857
2858	bool enable = true;
2859
2860	if (s.index<30) // Ready/Waiting
2861	SetLedColor(fStatusLoggerLed, kLedYellow, time);
2862	if (s.index==30) // Ready/Waiting
2863	SetLedColor(fStatusLoggerLed, kLedGreen, time);
2864	if (s.index<-1) // Offline
2865	{
2866	SetLedColor(fStatusLoggerLed, kLedGray, time);
2867	enable = false;
2868	}
2869	if (s.index>=0x100) // Error
2870	SetLedColor(fStatusLoggerLed, kLedRed, time);
2871	if (s.index==40) // Logging
2872	SetLedColor(fStatusLoggerLed, kLedGreen, time);
2873
2874	fLoggerWidget->setEnabled(enable);
2875	fLoggerStart->setEnabled(s.index>-1 && s.index<30);
2876	fLoggerStop->setEnabled(s.index>=30);
2877	}
2878
2879	if (server=="CHAT")
2880	{
2881	fStatusChatLabel->setText(s.name.c_str());
2882
2883	fChatOnline = s.index==0;
2884
2885	SetLedColor(fStatusChatLed, fChatOnline ? kLedGreen : kLedGray, time);
2886
2887	fChatSend->setEnabled(fChatOnline);
2888	fChatMessage->setEnabled(fChatOnline);
2889	}
2890
2891	if (server=="SCHEDULER")
2892	{
2893	fStatusSchedulerLabel->setText(s.name.c_str());
2894
2895	SetLedColor(fStatusSchedulerLed, s.index>=0 ? kLedGreen : kLedRed, time);
2896	}
2897	}
2898
2899	void on_fTabWidget_currentChanged(int which)
2900	{
2901	if (fTabWidget->tabText(which)=="Chat")
2902	fTabWidget->setTabIcon(which, QIcon());
2903	}
2904
2905	void handleWrite(const Time &time, const string &text, int qos)
2906	{
2907	stringstream out;
2908
2909	if (text.substr(0, 6)=="CHAT: ")
2910	{
2911	if (qos==MessageImp::kDebug)
2912	return;
2913
2914	out << "<font size='-1' color='navy'>[<B>";
2915	out << time.GetAsStr("%H:%M:%S");
2916	out << "</B>]</FONT> " << text.substr(6);
2917	fChatText->append(out.str().c_str());
2918
2919	if (fTabWidget->tabText(fTabWidget->currentIndex())=="Chat")
2920	return;
2921
2922	static int num = 0;
2923	if (num++<2)
2924	return;
2925
2926	for (int i=0; i<fTabWidget->count(); i++)
2927	if (fTabWidget->tabText(i)=="Chat")
2928	{
2929	fTabWidget->setTabIcon(i, QIcon(":/Resources/icons/warning 3.png"));
2930	break;
2931	}
2932
2933	return;
2934	}
2935
2936
2937	out << "<font style='font-family:monospace' color='";
2938
2939	switch (qos)
2940	{
2941	case kMessage: out << "black"; break;
2942	case kInfo: out << "green"; break;
2943	case kWarn: out << "#FF6600"; break;
2944	case kError: out << "maroon"; break;
2945	case kFatal: out << "maroon"; break;
2946	case kDebug: out << "navy"; break;
2947	default: out << "navy"; break;
2948	}
2949	out << "'>";
2950	out << time.GetAsStr("%H:%M:%S.%f").substr(0,12);
2951	out << " - " << text << "</font>";
2952
2953	fLogText->append(out.str().c_str());
2954
2955	if (qos>=kWarn && qos!=kDebug)
2956	fTextEdit->append(out.str().c_str());
2957	}
2958
2959	void IndicateStateChange(const Time &time, const std::string &server)
2960	{
2961	const State s = GetState(server, GetCurrentState(server));
2962
2963	QApplication::postEvent(this,
2964	new FunctionEvent(boost::bind(&FactGui::handleStateChanged, this, time, server, s)));
2965	}
2966
2967	int Write(const Time &time, const string &txt, int qos)
2968	{
2969	QApplication::postEvent(this,
2970	new FunctionEvent(boost::bind(&FactGui::handleWrite, this, time, txt, qos)));
2971
2972	return 0;
2973	}
2974
2975	// ====================== Dim infoHandler================================
2976
2977	void handleDimService(const string &txt)
2978	{
2979	fDimSvcText->append(txt.c_str());
2980	}
2981
2982	void infoHandlerService(DimInfo &info)
2983	{
2984	const string fmt = string(info.getFormat()).empty() ? "C" : info.getFormat();
2985
2986	stringstream dummy;
2987	const Converter conv(dummy, fmt, false);
2988
2989	const Time tm(info.getTimestamp(), info.getTimestampMillisecs()*1000);
2990
2991	stringstream out;
2992	out << "<font size'-1' color='navy'>[";
2993	out << tm.GetAsStr("%H:%M:%S.%f").substr(0,12);
2994	out << "]</font> <B>" << info.getName() << "</B> - ";
2995
2996	bool iserr = 2;
2997	if (!conv)
2998	{
2999	out << "Compilation of format string '" << fmt << "' failed!";
3000	}
3001	else
3002	{
3003	try
3004	{
3005	const string dat = info.getSize()==0 ? "<empty>" : conv.GetString(info.getData(), info.getSize());
3006	out << dat;
3007	iserr = info.getSize()==0;
3008	}
3009	catch (const runtime_error &e)
3010	{
3011	out << "Conversion to string failed!<pre>" << e.what() << "</pre>";
3012	}
3013	}
3014
3015	// srand(hash<string>()(string(info.getName())));
3016	// int bg = rand()&0xffffff;
3017
3018	int bg = hash<string>()(string(info.getName()));
3019
3020	// allow only light colors
3021	bg = ~(bg&0x1f1f1f)&0xffffff;
3022
3023	if (iserr==2)
3024	bg = 0xffffff;
3025
3026	stringstream bgcol;
3027	bgcol << hex << setfill('0') << setw(6) << bg;
3028
3029	const string col = iserr==0 ? "black" : (iserr==1 ? "#FF6600" : "black");
3030	const string str = "<table width='100%' bgcolor=#"+bgcol.str()+"><tr><td><font color='"+col+"'>"+out.str()+"</font></td></tr></table>";
3031
3032	QApplication::postEvent(this,
3033	new FunctionEvent(boost::bind(&FactGui::handleDimService, this, str)));
3034	}
3035
3036	void CallInfoHandler(void (FactGui::*handler)(const DimData&), const DimData &d)
3037	{
3038	fInHandler = true;
3039	(this->*handler)(d);
3040	fInHandler = false;
3041	}
3042
3043	/*
3044	void CallInfoHandler(const boost::function<void()> &func)
3045	{
3046	// This ensures that newly received values are not sent back to the emitter
3047	// because changing the value emits the valueChanged signal (or similar)
3048	fInHandler = true;
3049	func();
3050	fInHandler = false;
3051	}*/
3052
3053	void PostInfoHandler(void (FactGui::*handler)(const DimData&))
3054	{
3055	//const boost::function<void()> f = boost::bind(handler, this, DimData(getInfo()));
3056
3057	FunctionEvent *evt = new FunctionEvent(boost::bind(&FactGui::CallInfoHandler, this, handler, DimData(getInfo())));
3058	// FunctionEvent *evt = new FunctionEvent(boost::bind(&FactGui::CallInfoHandler, this, f));
3059	// FunctionEvent *evt = new FunctionEvent(boost::bind(handler, this, DimData(getInfo()))));
3060
3061	QApplication::postEvent(this, evt);
3062	}
3063
3064	void infoHandler()
3065	{
3066	// Initialize the time-stamp (what a weird workaround...)
3067	if (getInfo())
3068	getInfo()->getTimestamp();
3069
3070	if (getInfo()==&fDimDNS)
3071	return PostInfoHandler(&FactGui::handleDimDNS);
3072	#ifdef DEBUG_DIM
3073	cout << "HandleDimInfo " << getInfo()->getName() << endl;
3074	#endif
3075	if (getInfo()==&fDimLoggerStats)
3076	return PostInfoHandler(&FactGui::handleLoggerStats);
3077
3078	// if (getInfo()==&fDimFadFiles)
3079	// return PostInfoHandler(&FactGui::handleFadFiles);
3080
3081	if (getInfo()==&fDimFadWriteStats)
3082	return PostInfoHandler(&FactGui::handleFadWriteStats);
3083
3084	if (getInfo()==&fDimFadConnections)
3085	return PostInfoHandler(&FactGui::handleFadConnections);
3086
3087	if (getInfo()==&fDimFadFwVersion)
3088	return PostInfoHandler(&FactGui::handleFadFwVersion);
3089
3090	if (getInfo()==&fDimFadRunNumber)
3091	return PostInfoHandler(&FactGui::handleFadRunNumber);
3092
3093	if (getInfo()==&fDimFadDNA)
3094	return PostInfoHandler(&FactGui::handleFadDNA);
3095
3096	if (getInfo()==&fDimFadTemperature)
3097	return PostInfoHandler(&FactGui::handleFadTemperature);
3098
3099	if (getInfo()==&fDimFadRefClock)
3100	return PostInfoHandler(&FactGui::handleFadRefClock);
3101
3102	if (getInfo()==&fDimFadRoi)
3103	return PostInfoHandler(&FactGui::handleFadRoi);
3104
3105	if (getInfo()==&fDimFadDac)
3106	return PostInfoHandler(&FactGui::handleFadDac);
3107
3108	if (getInfo()==&fDimFadDrsCalibration)
3109	return PostInfoHandler(&FactGui::handleFadDrsCalibration);
3110
3111	if (getInfo()==&fDimFadPrescaler)
3112	return PostInfoHandler(&FactGui::handleFadPrescaler);
3113
3114	if (getInfo()==&fDimFadStatus)
3115	return PostInfoHandler(&FactGui::handleFadStatus);
3116
3117	if (getInfo()==&fDimFadStatistics1)
3118	return PostInfoHandler(&FactGui::handleFadStatistics1);
3119
3120	if (getInfo()==&fDimFadStatistics2)
3121	return PostInfoHandler(&FactGui::handleFadStatistics2);
3122
3123	if (getInfo()==&fDimFadEvents)
3124	return PostInfoHandler(&FactGui::handleFadEvents);
3125
3126	if (getInfo()==&fDimFadRuns)
3127	return PostInfoHandler(&FactGui::handleFadRuns);
3128
3129	if (getInfo()==&fDimFadStartRun)
3130	return PostInfoHandler(&FactGui::handleFadStartRun);
3131
3132	if (getInfo()==&fDimFadRawData)
3133	return PostInfoHandler(&FactGui::handleFadRawData);
3134
3135	if (getInfo()==&fDimFadEventData)
3136	return PostInfoHandler(&FactGui::handleFadEventData);
3137
3138	/*
3139	if (getInfo()==&fDimFadSetup)
3140	return PostInfoHandler(&FactGui::handleFadSetup);
3141	*/
3142	if (getInfo()==&fDimLoggerFilenameNight)
3143	return PostInfoHandler(&FactGui::handleLoggerFilenameNight);
3144
3145	if (getInfo()==&fDimLoggerNumSubs)
3146	return PostInfoHandler(&FactGui::handleLoggerNumSubs);
3147
3148	if (getInfo()==&fDimLoggerFilenameRun)
3149	return PostInfoHandler(&FactGui::handleLoggerFilenameRun);
3150
3151	if (getInfo()==&fDimFtmTriggerRates)
3152	return PostInfoHandler(&FactGui::handleFtmTriggerRates);
3153
3154	if (getInfo()==&fDimFtmCounter)
3155	return PostInfoHandler(&FactGui::handleFtmCounter);
3156
3157	if (getInfo()==&fDimFtmDynamicData)
3158	return PostInfoHandler(&FactGui::handleFtmDynamicData);
3159
3160	if (getInfo()==&fDimFtmPassport)
3161	return PostInfoHandler(&FactGui::handleFtmPassport);
3162
3163	if (getInfo()==&fDimFtmFtuList)
3164	return PostInfoHandler(&FactGui::handleFtmFtuList);
3165
3166	if (getInfo()==&fDimFtmStaticData)
3167	return PostInfoHandler(&FactGui::handleFtmStaticData);
3168
3169	if (getInfo()==&fDimFtmError)
3170	return PostInfoHandler(&FactGui::handleFtmError);
3171
3172	if (getInfo()==&fDimFscTemp)
3173	return PostInfoHandler(&FactGui::handleFscTemp);
3174
3175	if (getInfo()==&fDimFscVolt)
3176	return PostInfoHandler(&FactGui::handleFscVolt);
3177
3178	if (getInfo()==&fDimFscCurrent)
3179	return PostInfoHandler(&FactGui::handleFscCurrent);
3180
3181	if (getInfo()==&fDimFscHumidity)
3182	return PostInfoHandler(&FactGui::handleFscHumidity);
3183
3184	if (getInfo()==&fDimBiasVolt)
3185	return PostInfoHandler(&FactGui::handleBiasVolt);
3186
3187	if (getInfo()==&fDimBiasCurrent)
3188	return PostInfoHandler(&FactGui::handleBiasCurrent);
3189
3190	if (getInfo()==&fDimFeedbackReference)
3191	return PostInfoHandler(&FactGui::handleFeedbackReference);
3192
3193	if (getInfo()==&fDimFeedbackDeviation)
3194	return PostInfoHandler(&FactGui::handleFeedbackDeviation);
3195
3196	// if (getInfo()==&fDimFadFiles)
3197	// return PostInfoHandler(&FactGui::handleFadFiles);
3198
3199	for (map<string,DimInfo*>::iterator i=fServices.begin(); i!=fServices.end(); i++)
3200	if (i->second==getInfo())
3201	{
3202	infoHandlerService(*i->second);
3203	return;
3204	}
3205
3206	DimNetwork::infoHandler();
3207	}
3208
3209
3210	// ======================================================================
3211
3212	bool event(QEvent *evt)
3213	{
3214	if (dynamic_cast<FunctionEvent*>(evt))
3215	return static_cast<FunctionEvent*>(evt)->Exec();
3216
3217	if (dynamic_cast<CheckBoxEvent*>(evt))
3218	{
3219	const QStandardItem &item = static_cast<CheckBoxEvent*>(evt)->item;
3220	const QStandardItem *par = item.parent();
3221	if (par)
3222	{
3223	const QString server = par->text();
3224	const QString service = item.text();
3225
3226	const string s = (server+'/'+service).toStdString();
3227
3228	if (item.checkState()==Qt::Checked)
3229	SubscribeService(s);
3230	else
3231	UnsubscribeService(s);
3232	}
3233	}
3234
3235	return MainWindow::event(evt); // unrecognized
3236	}
3237
3238	void on_fDimCmdSend_clicked()
3239	{
3240	const QString server = fDimCmdServers->currentIndex().data().toString();
3241	const QString command = fDimCmdCommands->currentIndex().data().toString();
3242	const QString arguments = fDimCmdLineEdit->displayText();
3243
3244	// FIXME: Sending a command exactly when the info Handler changes
3245	// the list it might lead to confusion.
3246	try
3247	{
3248	SendDimCommand(server.toStdString(), command.toStdString()+" "+arguments.toStdString());
3249	fTextEdit->append("<font color='green'>Command '"+server+'/'+command+"' successfully emitted.</font>");
3250	fDimCmdLineEdit->clear();
3251	}
3252	catch (const runtime_error &e)
3253	{
3254	stringstream txt;
3255	txt << e.what();
3256
3257	string buffer;
3258	while (getline(txt, buffer, '\n'))
3259	fTextEdit->append(("<font color='red'><pre>"+buffer+"</pre></font>").c_str());
3260	}
3261	}
3262
3263	#ifdef HAVE_ROOT
3264	void slot_RootEventProcessed(TObject obj, unsigned int evt, TCanvas canv)
3265	{
3266	// kMousePressEvent // TCanvas processed QEvent mousePressEvent
3267	// kMouseMoveEvent // TCanvas processed QEvent mouseMoveEvent
3268	// kMouseReleaseEvent // TCanvas processed QEvent mouseReleaseEvent
3269	// kMouseDoubleClickEvent // TCanvas processed QEvent mouseDoubleClickEvent
3270	// kKeyPressEvent // TCanvas processed QEvent keyPressEvent
3271	// kEnterEvent // TCanvas processed QEvent enterEvent
3272	// kLeaveEvent // TCanvas processed QEvent leaveEvent
3273
3274	if (dynamic_cast<TCanvas*>(obj))
3275	return;
3276
3277	TQtWidget tipped = static_cast<TQtWidget>(sender());
3278
3279	if (evt==11/kMouseReleaseEvent/)
3280	return;
3281
3282	if (evt==61/kMouseDoubleClickEvent/)
3283	return;
3284
3285	if (obj)
3286	{
3287	// Find the object which will get picked by the GetObjectInfo
3288	// due to buffer overflows in many root-versions
3289	// in TH1 and TProfile we have to work around and implement
3290	// our own GetObjectInfo which make everything a bit more
3291	// complicated.
3292	canv->cd();
3293	#if ROOT_VERSION_CODE > ROOT_VERSION(5,22,00)
3294	const char *objectInfo =
3295	obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
3296	#else
3297	const char objectInfo = dynamic_cast<TH1>(obj) ?
3298	"" : obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
3299	#endif
3300
3301	QString tipText;
3302	tipText += obj->GetName();
3303	tipText += " [";
3304	tipText += obj->ClassName();
3305	tipText += "]: ";
3306	tipText += objectInfo;
3307
3308	fStatusBar->showMessage(tipText, 3000);
3309	}
3310
3311	gSystem->DispatchOneEvent(kFALSE);
3312	//gSystem->ProcessEvents();
3313	//QWhatsThis::display(tipText)
3314	}
3315
3316	void slot_RootUpdate()
3317	{
3318	gSystem->DispatchOneEvent(kFALSE);
3319	//gSystem->ProcessEvents();
3320	QTimer::singleShot(10, this, SLOT(slot_RootUpdate()));
3321	}
3322	#endif
3323
3324	void ChoosePatchThreshold(Camera &cam, int isw)
3325	{
3326	cam.Reset();
3327
3328	fThresholdIdx->setValue(isw);
3329
3330	const int ihw = isw<0 ? 0 : fPatchMapHW[isw];
3331
3332	fPatchRate->setEnabled(isw>=0);
3333	fThresholdCrate->setEnabled(isw>=0);
3334	fThresholdBoard->setEnabled(isw>=0);
3335	fThresholdPatch->setEnabled(isw>=0);
3336
3337	if (isw<0)
3338	return;
3339
3340	const int patch = ihw%4;
3341	const int board = (ihw/4)%10;
3342	const int crate = (ihw/4)/10;
3343
3344	fInChoosePatchTH = true;
3345
3346	fThresholdCrate->setValue(crate);
3347	fThresholdBoard->setValue(board);
3348	fThresholdPatch->setValue(patch);
3349
3350	fInChoosePatchTH = false;
3351
3352	fThresholdVal->setValue(fFtmStaticData.fThreshold[ihw]);
3353	fPatchRate->setValue(fTriggerRates.fPatchRate[ihw]);
3354	fBoardRate->setValue(fTriggerRates.fBoardRate[ihw/4]);
3355
3356	// Loop over the software idx of all pixels
3357	// for (unsigned int i=0; i<1440; i++)
3358	// if (fPatchHW[i]==ihw)
3359	// cam.SetBold(i);
3360	}
3361
3362	/*
3363	void ChoosePatchBias(Camera &cam, int isw)
3364	{
3365	cam.Reset();
3366
3367	fBiasChannel->setValue(isw);
3368
3369	const int ihw = isw<0 ? 0 : fPatchMapHW[isw];
3370
3371	fBiasCurrent->setEnabled(isw>=0);
3372	fBiasCrate->setEnabled(isw>=0);
3373	fBiasBoard->setEnabled(isw>=0);
3374	fBiasPatch->setEnabled(isw>=0);
3375
3376	if (isw<0)
3377	return;
3378
3379	const int patch = ihw%4;
3380	const int board = (ihw/4)%10;
3381	const int crate = (ihw/4)/10;
3382
3383	fInChoosePatchBias = true;
3384
3385	fBiasCrate->setValue(crate);
3386	fBiasBoard->setValue(board);
3387	fBiasPatch->setValue(patch);
3388
3389	fInChoosePatchBias = false;
3390
3391	if (fVecBias.size()>0)
3392	{
3393	// FIXME: Mapping
3394	fBiasVoltDac->setValue(fVecBias[ihw]);
3395	fBiasVolt->setValue(fVecBias[ihw]*90./4096);
3396	}
3397
3398	fBiasCurrent->setValue(cam.GetData(isw));
3399
3400	// Loop over the software idx of all pixels
3401	for (unsigned int i=0; i<1440; i++)
3402	if (fPatchHW[i]==ihw)
3403	cam.SetBold(i);
3404	}*/
3405
3406	void slot_ChoosePixelThreshold(int isw)
3407	{
3408	fPixelIdx->setValue(isw);
3409
3410	const PixelMapEntry &entry = fPixelMap.index(isw);
3411	fPixelEnable->setChecked(fFtmStaticData.IsEnabled(entry.hw()));
3412	}
3413
3414	void slot_CameraDoubleClick(int isw)
3415	{
3416	fPixelIdx->setValue(isw);
3417
3418	const PixelMapEntry &entry = fPixelMap.index(isw);
3419	Dim::SendCommand("FTM_CONTROL/TOGGLE_PIXEL", uint16_t(entry.hw()));
3420	}
3421
3422	void slot_CameraMouseMove(int isw)
3423	{
3424	const PixelMapEntry &entry = fPixelMap.index(isw);
3425
3426	QString tipText;
3427	tipText += fRatesCanv->GetName();
3428	ostringstream str;
3429	str << setfill('0') <<
3430	" \|\| HW: " << entry.crate() << "\|" << entry.board() << "\|" << entry.patch() << "\|" << entry.pixel() << " (crate\|board\|patch\|pixel)" <<
3431	" \|\| HV: " << entry.hv_board << "\|" << setw(2) << entry.hv_channel << " (board\|channel)" <<
3432	" \|\| ID: " << isw;
3433
3434
3435	tipText += str.str().c_str();
3436	fStatusBar->showMessage(tipText, 3000);
3437	}
3438
3439	void on_fThresholdIdx_valueChanged(int isw)
3440	{
3441	// fRatesCanv->SetBold(isw);
3442	// fRatesCanv->updateGL();
3443	}
3444
3445	void UpdateThresholdIdx()
3446	{
3447	if (fInChoosePatchTH)
3448	return;
3449
3450	const int crate = fThresholdCrate->value();
3451	const int board = fThresholdBoard->value();
3452	const int patch = fThresholdPatch->value();
3453
3454	const int ihw = patch + board4 + crate40;
3455
3456	int isw = 0;
3457	for (; isw<160; isw++)
3458	if (ihw==fPatchMapHW[isw])
3459	break;
3460
3461	on_fThresholdIdx_valueChanged(isw);
3462	}
3463
3464	void on_fPixelIdx_valueChanged(int isw)
3465	{
3466	int ii = 0;
3467	for (; ii<160; ii++)
3468	if (fPixelMap.index(isw).hw()/9==fPatchMapHW[ii])
3469	break;
3470
3471	fRatesCanv->SetWhite(isw);
3472	ChoosePatchThreshold(*fRatesCanv, ii);
3473
3474	const PixelMapEntry &entry = fPixelMap.index(isw);
3475	fPixelEnable->setChecked(fFtmStaticData.IsEnabled(entry.hw()));
3476	}
3477
3478	// ------------------- Bias display ---------------------
3479
3480	void UpdateBiasValues()
3481	{
3482	const int b = fBiasHvBoard->value();
3483	const int c = fBiasHvChannel->value();
3484
3485	const int ihw = b*32+c;
3486
3487	if (fVecBiasVolt.size()>0)
3488	{
3489	fBiasVoltCur->setValue(fVecBiasVolt[ihw]*90./4096);
3490	fBiasVoltRef->setValue(fVecBiasVolt[ihw+416]*90./4096);
3491
3492	SetLedColor(fBiasNominalLed,
3493	fVecBiasVolt[ihw]==fVecBiasVolt[ihw+416]?kLedGreen:kLedRed, Time());
3494	}
3495
3496	if (fVecBiasCurrent.size()>0)
3497	{
3498	fBiasCurrent->setValue(abs(fVecBiasCurrent[ihw])*5000./4096);
3499	SetLedColor(fBiasOverCurrentLed,
3500	fVecBiasCurrent[ihw]<0?kLedRed:kLedGreen, Time());
3501	}
3502	}
3503
3504	void UpdateBiasCam(const PixelMapEntry &entry)
3505	{
3506	fInChooseBiasCam = true;
3507
3508	fBiasCamCrate->setValue(entry.crate());
3509	fBiasCamBoard->setValue(entry.board());
3510	fBiasCamPatch->setValue(entry.patch());
3511	fBiasCamPixel->setValue(entry.pixel());
3512
3513	fInChooseBiasCam = false;
3514	}
3515
3516	void BiasHvChannelChanged()
3517	{
3518	if (fInChooseBiasHv)
3519	return;
3520
3521	const int b = fBiasHvBoard->value();
3522	const int ch = fBiasHvChannel->value();
3523
3524	// FIXME: Mark corresponding patch in camera
3525	const PixelMapEntry &entry = fPixelMap.hv(b, ch);
3526	fBiasCamV->SetWhite(entry.index);
3527	fBiasCamA->SetWhite(entry.index);
3528	fBiasCamV->updateCamera();
3529	fBiasCamA->updateCamera();
3530
3531	UpdateBiasCam(entry);
3532	UpdateBiasValues();
3533	}
3534
3535	void UpdateBiasHv(const PixelMapEntry &entry)
3536	{
3537	fInChooseBiasHv = true;
3538
3539	fBiasHvBoard->setValue(entry.hv_board);
3540	fBiasHvChannel->setValue(entry.hv_channel);
3541
3542	fInChooseBiasHv = false;
3543	}
3544
3545	void BiasCamChannelChanged()
3546	{
3547	if (fInChooseBiasCam)
3548	return;
3549
3550	const int crate = fBiasCamCrate->value();
3551	const int board = fBiasCamBoard->value();
3552	const int patch = fBiasCamPatch->value();
3553	const int pixel = fBiasCamPixel->value();
3554
3555	// FIXME: Display corresponding patches
3556	const PixelMapEntry &entry = fPixelMap.cbpx(crate, board, patch, pixel);
3557	fBiasCamV->SetWhite(entry.index);
3558	fBiasCamA->SetWhite(entry.index);
3559	fBiasCamV->updateCamera();
3560	fBiasCamA->updateCamera();
3561
3562	UpdateBiasHv(entry);
3563	UpdateBiasValues();
3564	}
3565
3566	void slot_ChooseBiasChannel(int isw)
3567	{
3568	const PixelMapEntry &entry = fPixelMap.index(isw);
3569
3570	UpdateBiasHv(entry);
3571	UpdateBiasCam(entry);
3572	UpdateBiasValues();
3573	}
3574
3575	void on_fBiasDispRefVolt_stateChanged(int = 0)
3576	{
3577	// FIXME: Display patches for which ref==cur
3578
3579	valarray<double> dat(0., 1440);
3580
3581	int offset = 0;
3582	if (!fBiasDispRefVolt->isChecked())
3583	fBiasCamV->setTitle("Applied BIAS voltage");
3584	else
3585	{
3586	fBiasCamV->setTitle("Reference BIAS voltage");
3587	offset = 416;
3588	}
3589
3590	if (fVecBiasVolt.size()>0)
3591	{
3592	for (int i=0; i<1440; i++)
3593	{
3594	const PixelMapEntry &entry = fPixelMap.index(i);
3595	dat[i] = fVecBiasVolt[entry.hv()+offset]*90./4096;
3596
3597	fBiasCamV->highlightPixel(i, fVecBiasVolt[entry.hv()]!=fVecBiasVolt[entry.hv()+416]);
3598	}
3599
3600	fBiasCamV->SetData(dat);
3601	}
3602
3603	fBiasCamV->updateCamera();
3604	}
3605
3606	// ------------------------------------------------------
3607
3608	void on_fPixelEnable_stateChanged(int b)
3609	{
3610	if (fInHandler)
3611	return;
3612
3613	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
3614
3615	Dim::SendCommand(b==Qt::Unchecked ?
3616	"FTM_CONTROL/DISABLE_PIXEL" : "FTM_CONTROL/ENABLE_PIXEL",
3617	uint16_t(entry.hw()));
3618	}
3619
3620	void on_fPixelDisableOthers_clicked()
3621	{
3622	const PixelMapEntry &entry = fPixelMap.index(fPixelIdx->value());
3623	Dim::SendCommand("FTM_CONTROL/DISABLE_ALL_PIXELS_EXCEPT", uint16_t(entry.hw()));
3624	}
3625
3626	void on_fThresholdDisableOthers_clicked()
3627	{
3628	const int16_t isw = fThresholdIdx->value();
3629	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3630	if (ihw<0)
3631	return;
3632
3633	Dim::SendCommand("FTM_CONTROL/DISABLE_ALL_PATCHES_EXCEPT", ihw);
3634	}
3635
3636	void on_fThresholdEnablePatch_clicked()
3637	{
3638	const int16_t isw = fThresholdIdx->value();
3639	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3640	if (ihw<0)
3641	return;
3642
3643	Dim::SendCommand("FTM_CONTROL/ENABLE_PATCH", ihw);
3644	}
3645
3646	void on_fThresholdDisablePatch_clicked()
3647	{
3648	const int16_t isw = fThresholdIdx->value();
3649	const int16_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3650	if (ihw<0)
3651	return;
3652
3653	Dim::SendCommand("FTM_CONTROL/DISABLE_PATCH", ihw);
3654	}
3655
3656	void on_fThresholdVal_valueChanged(int v)
3657	{
3658	fThresholdVolt->setValue(2500./4095*v);
3659
3660	const int32_t isw = fThresholdIdx->value();
3661	const int32_t ihw = isw<0 ? -1 : fPatchMapHW[isw];
3662
3663	const int32_t d[2] = { ihw, v };
3664
3665	if (!fInHandler)
3666	Dim::SendCommand("FTM_CONTROL/SET_THRESHOLD", d);
3667	}
3668
3669	TGraph fGraphFtmTemp[4];
3670	TGraph fGraphFtmRate;
3671	TGraph fGraphPatchRate[160];
3672	TGraph fGraphBoardRate[40];
3673
3674	#ifdef HAVE_ROOT
3675	TH1 DrawTimeFrame(const char ytitle)
3676	{
3677	const double tm = Time().RootTime();
3678
3679	TH1F *h=new TH1F("TimeFrame", "", 1, tm, tm+60);//Time().RootTime()-1./24/60/60, Time().RootTime());
3680	h->SetDirectory(0);
3681	h->SetBit(kCanDelete);
3682	h->SetStats(kFALSE);
3683	// h.SetMinimum(0);
3684	// h.SetMaximum(1);
3685	h->SetXTitle("Time");
3686	h->SetYTitle(ytitle);
3687	h->GetXaxis()->CenterTitle();
3688	h->GetYaxis()->CenterTitle();
3689	h->GetXaxis()->SetTimeDisplay(true);
3690	h->GetXaxis()->SetTimeFormat("%Mh%S'");
3691	h->GetXaxis()->SetLabelSize(0.025);
3692	h->GetYaxis()->SetLabelSize(0.025);
3693	h->GetYaxis()->SetTitleOffset(1.2);
3694	// h.GetYaxis()->SetTitleSize(1.2);
3695	h->Draw();
3696
3697	return h;
3698	}
3699	#endif
3700
3701	pair<string,string> Split(const string &str) const
3702	{
3703	const size_t p = str.find_first_of('\|');
3704	if (p==string::npos)
3705	return make_pair(str, "");
3706
3707	return make_pair(str.substr(0, p), str.substr(p+1));
3708	}
3709
3710	public:
3711	FactGui(Configuration &conf) :
3712	fFtuStatus(40),
3713	/fPixelMapHW(1440),/ fPatchMapHW(160),
3714	fInChoosePatchTH(false),
3715	fInChooseBiasHv(false), fInChooseBiasCam(false),
3716	fDimDNS("DIS_DNS/VERSION_NUMBER", 1, int(0), this),
3717	//-
3718	fDimLoggerStats ("DATA_LOGGER/STATS", (void*)NULL, 0, this),
3719	fDimLoggerFilenameNight("DATA_LOGGER/FILENAME_NIGHTLY", (void*)NULL, 0, this),
3720	fDimLoggerFilenameRun ("DATA_LOGGER/FILENAME_RUN", (void*)NULL, 0, this),
3721	fDimLoggerNumSubs ("DATA_LOGGER/NUM_SUBS", (void*)NULL, 0, this),
3722	//-
3723	fDimFtmPassport ("FTM_CONTROL/PASSPORT", (void*)NULL, 0, this),
3724	fDimFtmTriggerRates ("FTM_CONTROL/TRIGGER_RATES", (void*)NULL, 0, this),
3725	fDimFtmError ("FTM_CONTROL/ERROR", (void*)NULL, 0, this),
3726	fDimFtmFtuList ("FTM_CONTROL/FTU_LIST", (void*)NULL, 0, this),
3727	fDimFtmStaticData ("FTM_CONTROL/STATIC_DATA", (void*)NULL, 0, this),
3728	fDimFtmDynamicData ("FTM_CONTROL/DYNAMIC_DATA", (void*)NULL, 0, this),
3729	fDimFtmCounter ("FTM_CONTROL/COUNTER", (void*)NULL, 0, this),
3730	//-
3731	fDimFadWriteStats ("FAD_CONTROL/STATS", (void*)NULL, 0, this),
3732	fDimFadStartRun ("FAD_CONTROL/START_RUN", (void*)NULL, 0, this),
3733	fDimFadRuns ("FAD_CONTROL/RUNS", (void*)NULL, 0, this),
3734	fDimFadEvents ("FAD_CONTROL/EVENTS", (void*)NULL, 0, this),
3735	fDimFadRawData ("FAD_CONTROL/RAW_DATA", (void*)NULL, 0, this),
3736	fDimFadEventData ("FAD_CONTROL/EVENT_DATA", (void*)NULL, 0, this),
3737	fDimFadConnections ("FAD_CONTROL/CONNECTIONS", (void*)NULL, 0, this),
3738	fDimFadFwVersion ("FAD_CONTROL/FIRMWARE_VERSION", (void*)NULL, 0, this),
3739	fDimFadRunNumber ("FAD_CONTROL/RUN_NUMBER", (void*)NULL, 0, this),
3740	fDimFadDNA ("FAD_CONTROL/DNA", (void*)NULL, 0, this),
3741	fDimFadTemperature ("FAD_CONTROL/TEMPERATURE", (void*)NULL, 0, this),
3742	fDimFadPrescaler ("FAD_CONTROL/PRESCALER", (void*)NULL, 0, this),
3743	fDimFadRefClock ("FAD_CONTROL/REFERENCE_CLOCK", (void*)NULL, 0, this),
3744	fDimFadRoi ("FAD_CONTROL/REGION_OF_INTEREST", (void*)NULL, 0, this),
3745	fDimFadDac ("FAD_CONTROL/DAC", (void*)NULL, 0, this),
3746	fDimFadDrsCalibration ("FAD_CONTROL/DRS_CALIBRATION", (void*)NULL, 0, this),
3747	fDimFadStatus ("FAD_CONTROL/STATUS", (void*)NULL, 0, this),
3748	fDimFadStatistics1 ("FAD_CONTROL/STATISTICS1", (void*)NULL, 0, this),
3749	fDimFadStatistics2 ("FAD_CONTROL/STATISTICS2", (void*)NULL, 0, this),
3750	//-
3751	fDimFscTemp ("FSC_CONTROL/TEMPERATURE", (void*)NULL, 0, this),
3752	fDimFscVolt ("FSC_CONTROL/VOLTAGE", (void*)NULL, 0, this),
3753	fDimFscCurrent ("FSC_CONTROL/CURRENT", (void*)NULL, 0, this),
3754	fDimFscHumidity ("FSC_CONTROL/HUMIDITY", (void*)NULL, 0, this),
3755	//-
3756	fDimBiasVolt ("BIAS_CONTROL/VOLTAGE", (void*)NULL, 0, this),
3757	fDimBiasCurrent ("BIAS_CONTROL/CURRENT", (void*)NULL, 0, this),
3758	//-
3759	fDimFeedbackDeviation ("FEEDBACK/DEVIATION", (void*)NULL, 0, this),
3760	fDimFeedbackReference ("FEEDBACK/REFERENCE", (void*)NULL, 0, this),
3761	//-
3762	fEventData(0), fDrsCalibration(144010246),
3763	fTimeStamp0(0)
3764	{
3765	fClockCondFreq->addItem("--- Hz", QVariant(-1));
3766	fClockCondFreq->addItem("800 MHz", QVariant(800));
3767	fClockCondFreq->addItem("1 GHz", QVariant(1000));
3768	fClockCondFreq->addItem("2 GHz", QVariant(2000));
3769	fClockCondFreq->addItem("3 GHz", QVariant(3000));
3770	fClockCondFreq->addItem("4 GHz", QVariant(4000));
3771	fClockCondFreq->addItem("5 GHz", QVariant(5000));
3772
3773	cout << "-- run counter ---" << endl;
3774	fMcpNumEvents->addItem("unlimited", QVariant(0));
3775	const vector<uint32_t> runcount = conf.Vec<uint32_t>("run-count");
3776	for (vector<uint32_t>::const_iterator it=runcount.begin(); it!=runcount.end(); it++)
3777	{
3778	cout << *it << endl;
3779	ostringstream str;
3780	str << *it;
3781	fMcpNumEvents->addItem(str.str().c_str(), QVariant(*it));
3782	}
3783
3784	cout << "-- run times ---" << endl;
3785	fMcpTime->addItem("unlimited", QVariant(0));
3786	const vector<string> runtime = conf.Vec<string>("run-time");
3787	for (vector<string>::const_iterator it=runtime.begin(); it!=runtime.end(); it++)
3788	{
3789	const pair<string,string> p = Split(*it);
3790	cout << *it << "\|" << p.second << "\|" << p.first << "\|" << endl;
3791	fMcpTime->addItem(p.second.c_str(), QVariant(stoi(p.first)));
3792	}
3793
3794	cout << "-- run types ---" << endl;
3795	const vector<string> runtype = conf.Vec<string>("run-type");
3796	for (vector<string>::const_iterator it=runtype.begin(); it!=runtype.end(); it++)
3797	{
3798	const pair<string,string> p = Split(*it);
3799	cout << *it << "\|" << p.second << "\|" << p.first << "\|" << endl;
3800	fMcpRunType->addItem(p.second.c_str(), QVariant(p.first.c_str()));
3801	}
3802
3803	fTriggerWidget->setEnabled(false);
3804	fFtuWidget->setEnabled(false);
3805	fFtuGroupEnable->setEnabled(false);
3806	fRatesControls->setEnabled(false);
3807	fFadWidget->setEnabled(false);
3808	fEvtBldWidget->setEnabled(false);
3809	fLoggerWidget->setEnabled(false);
3810	fBiasWidget->setEnabled(false);
3811	fAuxWidget->setEnabled(false);
3812
3813	fChatSend->setEnabled(false);
3814	fChatMessage->setEnabled(false);
3815
3816	DimClient::sendCommand("CHAT/MSG", "GUI online.");
3817	// + MessageDimRX
3818
3819	// --------------------------------------------------------------------------
3820
3821	if (!fPixelMap.Read(conf.Get<string>("pixel-map-file")))
3822	{
3823	cerr << "ERROR - Problems reading " << conf.Get<string>("pixel-map-file") << endl;
3824	exit(-1);
3825	}
3826
3827	// --------------------------------------------------------------------------
3828
3829	/*
3830	ifstream fin1("Trigger-Patches.txt");
3831
3832	string buf;
3833
3834	int l = 0;
3835	while (getline(fin1, buf, '\n'))
3836	{
3837	buf = Tools::Trim(buf);
3838	if (buf[0]=='#')
3839	continue;
3840
3841	stringstream str(buf);
3842	for (int i=0; i<9; i++)
3843	{
3844	unsigned int n;
3845	str >> n;
3846
3847	if (n>=fPatchHW.size())
3848	continue;
3849
3850	fPatchHW[n] = l;
3851	}
3852	l++;
3853	}
3854
3855	if (l!=160)
3856	cerr << "WARNING - Problems reading Trigger-Patches.txt" << endl;
3857	*/
3858	// --------------------------------------------------------------------------
3859
3860	/*
3861	ifstream fin2("MasterList-v3.txt");
3862
3863	l = 0;
3864
3865	while (getline(fin2, buf, '\n'))
3866	{
3867	buf = Tools::Trim(buf);
3868	if (buf[0]=='#')
3869	continue;
3870
3871	unsigned int softid, hardid, dummy;
3872
3873	stringstream str(buf);
3874
3875	str >> softid;
3876	str >> dummy;
3877	str >> hardid;
3878
3879	if (softid>=fPixelMapHW.size())
3880	continue;
3881
3882	fPixelMapHW[softid] = hardid;
3883
3884	l++;
3885	}
3886
3887	if (l!=1440)
3888	cerr << "WARNING - Problems reading MasterList-v3.txt" << endl;
3889	*/
3890	// --------------------------------------------------------------------------
3891
3892	ifstream fin3("PatchList.txt");
3893
3894	string buf;
3895
3896	int l = 0;
3897	while (getline(fin3, buf, '\n'))
3898	{
3899	buf = Tools::Trim(buf);
3900	if (buf[0]=='#')
3901	continue;
3902
3903	unsigned int softid, hardid;
3904
3905	stringstream str(buf);
3906
3907	str >> softid;
3908	str >> hardid;
3909
3910	if (softid>=fPatchMapHW.size())
3911	continue;
3912
3913	fPatchMapHW[softid] = hardid-1;
3914
3915	l++;
3916	}
3917
3918	if (l!=160)
3919	cerr << "WARNING - Problems reading PatchList.txt" << endl;
3920
3921	// --------------------------------------------------------------------------
3922	#ifdef HAVE_ROOT
3923
3924	fGraphFeedbackDev.SetLineColor(kBlue);
3925	fGraphFeedbackDev.SetMarkerColor(kBlue);
3926	fGraphFeedbackDev.SetMarkerStyle(kFullDotMedium);
3927
3928	fGraphFeedbackCmd.SetLineColor(kBlue);
3929	fGraphFeedbackCmd.SetMarkerColor(kBlue);
3930	fGraphFeedbackCmd.SetMarkerStyle(kFullDotMedium);
3931
3932	// Evolution of control deviation
3933	// Evolution of command values (bias voltage change)
3934	fGraphFeedbackDev.SetName("ControlDev");
3935	fGraphFeedbackCmd.SetName("CommandVal");
3936
3937	TCanvas *c = fFeedbackDev->GetCanvas();
3938	c->SetBorderMode(0);
3939	c->SetFrameBorderMode(0);
3940	c->SetFillColor(kWhite);
3941	c->SetRightMargin(0.03);
3942	c->SetTopMargin(0.03);
3943	c->SetGrid();
3944	c->cd();
3945
3946	TH1 *hf = DrawTimeFrame("Control deviation [mV] ");
3947	hf->GetXaxis()->SetLabelSize(0.07);
3948	hf->GetYaxis()->SetLabelSize(0.07);
3949	hf->GetYaxis()->SetTitleSize(0.08);
3950	hf->GetYaxis()->SetTitleOffset(0.55);
3951	hf->GetXaxis()->SetTitle("");
3952	hf->GetYaxis()->SetRangeUser(-99, 99);
3953
3954	fGraphFeedbackDev.Draw("LP");
3955
3956	c = fFeedbackCmd->GetCanvas();
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("Command delta value [mV] ");
3966	hf->GetXaxis()->SetLabelSize(0.07);
3967	hf->GetYaxis()->SetLabelSize(0.07);
3968	hf->GetYaxis()->SetTitleSize(0.08);
3969	hf->GetYaxis()->SetTitleOffset(0.55);
3970	hf->GetXaxis()->SetTitle("");
3971	hf->GetYaxis()->SetRangeUser(-9910, 9910);
3972
3973	fGraphFeedbackCmd.Draw("LP");
3974
3975	// --------------------------------------------------------------------------
3976
3977	c = fFtmRateCanv->GetCanvas();
3978	//c->SetBit(TCanvas::kNoContextMenu);
3979	c->SetBorderMode(0);
3980	c->SetFrameBorderMode(0);
3981	c->SetFillColor(kWhite);
3982	c->SetRightMargin(0.03);
3983	c->SetTopMargin(0.03);
3984	c->SetGrid();
3985	c->cd();
3986
3987	hf = DrawTimeFrame("Trigger rate [Hz]");
3988	hf->GetYaxis()->SetRangeUser(0, 1010);
3989
3990	for (int i=0; i<160; i++)
3991	{
3992	fGraphPatchRate[i].SetName("PatchRate");
3993	//fGraphPatchRate[i].SetLineColor(kBlue);
3994	//fGraphPatchRate[i].SetMarkerColor(kBlue);
3995	fGraphPatchRate[i].SetMarkerStyle(kFullDotMedium);
3996	}
3997	for (int i=0; i<40; i++)
3998	{
3999	fGraphBoardRate[i].SetName("BoardRate");
4000	//fGraphBoardRate[i].SetLineColor(kBlue);
4001	//fGraphBoardRate[i].SetMarkerColor(kBlue);
4002	fGraphBoardRate[i].SetMarkerStyle(kFullDotMedium);
4003	}
4004
4005	fGraphFtmRate.SetLineColor(kBlue);
4006	fGraphFtmRate.SetMarkerColor(kBlue);
4007	fGraphFtmRate.SetMarkerStyle(kFullDotSmall);
4008	fGraphFtmRate.Draw("LP");
4009
4010	/*
4011	TCanvas *c = fFtmTempCanv->GetCanvas();
4012	c->SetBit(TCanvas::kNoContextMenu);
4013	c->SetBorderMode(0);
4014	c->SetFrameBorderMode(0);
4015	c->SetFillColor(kWhite);
4016	c->SetRightMargin(0.03);
4017	c->SetTopMargin(0.03);
4018	c->cd();
4019	*/
4020	//CreateTimeFrame("Temperature / �C");
4021
4022	fGraphFtmTemp[0].SetMarkerStyle(kFullDotSmall);
4023	fGraphFtmTemp[1].SetMarkerStyle(kFullDotSmall);
4024	fGraphFtmTemp[2].SetMarkerStyle(kFullDotSmall);
4025	fGraphFtmTemp[3].SetMarkerStyle(kFullDotSmall);
4026
4027	fGraphFtmTemp[1].SetLineColor(kBlue);
4028	fGraphFtmTemp[2].SetLineColor(kRed);
4029	fGraphFtmTemp[3].SetLineColor(kGreen);
4030
4031	fGraphFtmTemp[1].SetMarkerColor(kBlue);
4032	fGraphFtmTemp[2].SetMarkerColor(kRed);
4033	fGraphFtmTemp[3].SetMarkerColor(kGreen);
4034
4035	//fGraphFtmTemp[0].Draw("LP");
4036	//fGraphFtmTemp[1].Draw("LP");
4037	//fGraphFtmTemp[2].Draw("LP");
4038	//fGraphFtmTemp[3].Draw("LP");
4039
4040	// --------------------------------------------------------------------------
4041
4042	c = fAdcDataCanv->GetCanvas();
4043	//c->SetBit(TCanvas::kNoContextMenu);
4044	c->SetBorderMode(0);
4045	c->SetFrameBorderMode(0);
4046	c->SetFillColor(kWhite);
4047	c->SetRightMargin(0.10);
4048	c->SetGrid();
4049	//c->cd();
4050	#endif
4051
4052	// --------------------------------------------------------------------------
4053	fFeedbackDevCam->assignPixelMap(fPixelMap);
4054	fFeedbackDevCam->setAutoscaleLowerLimit((fFeedbackDevMin->minimum()+0.5*fFeedbackDevMin->singleStep()));
4055	fFeedbackDevCam->SetMin(fFeedbackDevMin->value());
4056	fFeedbackDevCam->SetMax(fFeedbackDevMax->value());
4057	fFeedbackDevCam->updateCamera();
4058
4059	fFeedbackCmdCam->assignPixelMap(fPixelMap);
4060	fFeedbackCmdCam->setAutoscaleLowerLimit((fFeedbackCmdMin->minimum()+0.5*fFeedbackCmdMin->singleStep()));
4061	fFeedbackCmdCam->SetMin(fFeedbackCmdMin->value());
4062	fFeedbackCmdCam->SetMax(fFeedbackCmdMax->value());
4063	fFeedbackCmdCam->updateCamera();
4064
4065	// --------------------------------------------------------------------------
4066
4067	fBiasCamV->assignPixelMap(fPixelMap);
4068	fBiasCamV->setAutoscaleLowerLimit((fBiasVoltMin->minimum()+0.5*fBiasVoltMin->singleStep()));
4069	fBiasCamV->SetMin(fBiasVoltMin->value());
4070	fBiasCamV->SetMax(fBiasVoltMax->value());
4071	fBiasCamV->updateCamera();
4072
4073	fBiasCamA->assignPixelMap(fPixelMap);
4074	fBiasCamA->setAutoscaleLowerLimit((fBiasCurrentMin->minimum()+0.5*fBiasCurrentMin->singleStep()));
4075	fBiasCamA->SetMin(fBiasCurrentMin->value());
4076	fBiasCamA->SetMax(fBiasCurrentMax->value());
4077	fBiasCamA->updateCamera();
4078
4079	// --------------------------------------------------------------------------
4080
4081	fRatesCanv->assignPixelMap(fPixelMap);
4082	fRatesCanv->setAutoscaleLowerLimit((fRatesMin->minimum()+0.5fRatesMin->singleStep())0.001);
4083	fRatesCanv->SetMin(fRatesMin->value());
4084	fRatesCanv->SetMax(fRatesMax->value());
4085	fRatesCanv->updateCamera();
4086	on_fPixelIdx_valueChanged(0);
4087
4088	// --------------------------------------------------------------------------
4089
4090	fRatesCanv->setTitle("Patch rates");
4091	fRatesCanv->setUnits("Hz");
4092
4093	fBiasCamA->setTitle("BIAS current");
4094	fBiasCamA->setUnits("uA");
4095
4096	fBiasCamV->setTitle("Applied BIAS voltage");
4097	fBiasCamV->setUnits("V");
4098
4099	fEventCanv1->setTitle("Average (all slices)");
4100	fEventCanv2->setTitle("RMS (all slices)");
4101	fEventCanv3->setTitle("Maximum (all slices)");
4102	fEventCanv4->setTitle("Position of maximum (all slices)");
4103
4104	fEventCanv1->setUnits("mV");
4105	fEventCanv2->setUnits("mV");
4106	fEventCanv3->setUnits("mV");
4107	fEventCanv4->setUnits("slice");
4108
4109	// --------------------------------------------------------------------------
4110
4111	fFeedbackDevCam->setTitle("Control deviation (Pulser amplitude voltage)");
4112	fFeedbackCmdCam->setTitle("Applied voltage change (BIAS voltage)");
4113
4114	fFeedbackDevCam->setUnits("mV");
4115	fFeedbackCmdCam->setUnits("mV");
4116
4117	// --------------------------------------------------------------------------
4118
4119	QTimer::singleShot(1000, this, SLOT(slot_RootUpdate()));
4120
4121	//widget->setMouseTracking(true);
4122	//widget->EnableSignalEvents(kMouseMoveEvent);
4123
4124	fFtmRateCanv->setMouseTracking(true);
4125	fFtmRateCanv->EnableSignalEvents(kMouseMoveEvent);
4126
4127	fAdcDataCanv->setMouseTracking(true);
4128	fAdcDataCanv->EnableSignalEvents(kMouseMoveEvent);
4129
4130	fRatesCanv->setMouseTracking(true);
4131	fEventCanv1->setMouseTracking(true);
4132	fEventCanv2->setMouseTracking(true);
4133	fEventCanv3->setMouseTracking(true);
4134	fEventCanv4->setMouseTracking(true);
4135
4136	fBiasCamV->setMouseTracking(true);
4137	fBiasCamA->setMouseTracking(true);
4138
4139	fFeedbackDevCam->setMouseTracking(true);
4140	fFeedbackCmdCam->setMouseTracking(true);
4141
4142	fEventCanv1->ShowPixelCursor(true);
4143	fEventCanv2->ShowPixelCursor(true);
4144	fEventCanv3->ShowPixelCursor(true);
4145	fEventCanv4->ShowPixelCursor(true);
4146
4147	fEventCanv1->ShowPatchCursor(true);
4148	fEventCanv2->ShowPatchCursor(true);
4149	fEventCanv3->ShowPatchCursor(true);
4150	fEventCanv4->ShowPatchCursor(true);
4151
4152	fFeedbackDevCam->ShowPixelCursor(true);
4153	fFeedbackCmdCam->ShowPixelCursor(true);
4154
4155	fFeedbackDevCam->ShowPatchCursor(true);
4156	fFeedbackCmdCam->ShowPatchCursor(true);
4157
4158	connect(fRatesCanv, SIGNAL(signalPixelMoveOver(int)),
4159	this, SLOT(slot_CameraMouseMove(int)));
4160	connect(fEventCanv1, SIGNAL(signalPixelMoveOver(int)),
4161	this, SLOT(slot_CameraMouseMove(int)));
4162	connect(fEventCanv2, SIGNAL(signalPixelMoveOver(int)),
4163	this, SLOT(slot_CameraMouseMove(int)));
4164	connect(fEventCanv3, SIGNAL(signalPixelMoveOver(int)),
4165	this, SLOT(slot_CameraMouseMove(int)));
4166	connect(fEventCanv4, SIGNAL(signalPixelMoveOver(int)),
4167	this, SLOT(slot_CameraMouseMove(int)));
4168
4169	connect(fBiasCamV, SIGNAL(signalPixelMoveOver(int)),
4170	this, SLOT(slot_CameraMouseMove(int)));
4171	connect(fBiasCamA, SIGNAL(signalPixelMoveOver(int)),
4172	this, SLOT(slot_CameraMouseMove(int)));
4173
4174	connect(fFeedbackDevCam, SIGNAL(signalPixelMoveOver(int)),
4175	this, SLOT(slot_CameraMouseMove(int)));
4176	connect(fFeedbackCmdCam, SIGNAL(signalPixelMoveOver(int)),
4177	this, SLOT(slot_CameraMouseMove(int)));
4178
4179	connect(fRatesCanv, SIGNAL(signalPixelDoubleClick(int)),
4180	this, SLOT(slot_CameraDoubleClick(int)));
4181	connect(fRatesCanv, SIGNAL(signalCurrentPixel(int)),
4182	this, SLOT(slot_ChoosePixelThreshold(int)));
4183	connect(fBiasCamV, SIGNAL(signalCurrentPixel(int)),
4184	this, SLOT(slot_ChooseBiasChannel(int)));
4185	connect(fBiasCamA, SIGNAL(signalCurrentPixel(int)),
4186	this, SLOT(slot_ChooseBiasChannel(int)));
4187
4188	connect(fFtmRateCanv, SIGNAL( RootEventProcessed(TObject, unsigned int, TCanvas)),
4189	this, SLOT (slot_RootEventProcessed(TObject, unsigned int, TCanvas)));
4190	connect(fAdcDataCanv, SIGNAL( RootEventProcessed(TObject, unsigned int, TCanvas)),
4191	this, SLOT (slot_RootEventProcessed(TObject, unsigned int, TCanvas)));
4192	}
4193
4194	~FactGui()
4195	{
4196	// Unsubscribe all services
4197	for (map<string,DimInfo*>::iterator i=fServices.begin();
4198	i!=fServices.end(); i++)
4199	delete i->second;
4200
4201	delete fEventData;
4202	}
4203	};
4204
4205	#endif

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

Download in other formats: