Context Navigation

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

Visit:

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

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

Download in other formats: