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

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