Context Navigation

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

Visit:

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

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

Download in other formats: