Context Navigation

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

Visit:

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

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

Download in other formats: