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

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