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

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