source: trunk/FACT++/src/EventBuilderWrapper.h@ 11290

Last change on this file since 11290 was 11286, checked in by tbretz, 14 years ago
Updated to new statistic; changed to new runStat values; added ResetThread
File size: 49.2 KB
Line 
1#ifndef FACT_EventBuilderWrapper
2#define FACT_EventBuilderWrapper
3
4#include <sstream>
5
6#if BOOST_VERSION < 104400
7#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4))
8#undef BOOST_HAS_RVALUE_REFS
9#endif
10#endif
11#include <boost/thread.hpp>
12#include <boost/date_time/posix_time/posix_time_types.hpp>
13
14#include <CCfits/CCfits>
15
16#include "EventBuilder.h"
17
18extern "C" {
19 extern void StartEvtBuild();
20 extern int CloseRunFile(uint32_t runId, uint32_t closeTime);
21}
22
23namespace ba = boost::asio;
24namespace bs = boost::system;
25
26using ba::ip::tcp;
27
28using namespace std;
29
30class DataFileImp
31{
32 uint32_t fRunId;
33
34public:
35 DataFileImp(uint32_t id) : fRunId(id) { }
36 virtual ~DataFileImp() { }
37
38 virtual bool OpenFile(RUN_HEAD* h) = 0;
39 virtual bool Write(EVENT *) = 0;
40 virtual bool Close(RUN_TAIL * = 0) = 0;
41
42 uint32_t GetRunId() const { return fRunId; }
43
44 // --------------------------------------------------------------------------
45 //
46 //! This creates an appropriate file name for a particular run number and type
47 //! @param runNumber the run number for which a filename is to be created
48 //! @param runType an int describing the kind of run. 0=Data, 1=Pedestal, 2=Calibration, 3=Calibrated data
49 //! @param extension a string containing the extension to be appened to the file name
50 //
51 string FormFileName(uint32_t runType, string extension)
52 {
53 //TODO where am I supposed to get the base directory from ?
54 //TODO also, for creating subsequent directories, should I use the functions from the dataLogger ?
55 string baseDirectory = "./Run";
56
57 ostringstream result;
58// result << baseDirectory;
59// result << Time::fmt("/%Y/%m/%d/") << (Time() - boost::posix_time::time_duration(12,0,0));
60 result << setfill('0') << setw(8) << fRunId;
61 result << ".001_";
62 switch (runType)
63 {
64 case -1:
65 result << 'T';
66 break;
67 case 0:
68 result << 'D';
69 break;
70 case 1:
71 result << 'P';
72 break;
73 case 2:
74 result << 'C';
75 break;
76 case 3:
77 result << 'N';
78 break;
79 default:
80 result << runType;
81 };
82 result << "." << extension;
83
84 return result.str();
85 }
86};
87
88class DataFileNone : public DataFileImp
89{
90public:
91 DataFileNone(uint32_t id) : DataFileImp(id) { }
92
93 bool OpenFile(RUN_HEAD* h)
94 {
95 cout << "OPEN_FILE #" << GetRunId() << " (" << this << ")" << endl;
96 cout << " Ver= " << h->Version << endl;
97 cout << " Typ= " << h->RunType << endl;
98 cout << " Nb = " << h->NBoard << endl;
99 cout << " Np = " << h->NPix << endl;
100 cout << " NTm= " << h->NTm << endl;
101 cout << " roi= " << h->Nroi << endl;
102
103 return true;
104 }
105 bool Write(EVENT *)
106 {
107 return true;
108 }
109 bool Close(RUN_TAIL * = 0)
110 {
111 cout << "CLOSE FILE #" << GetRunId() << " (" << this << ")" << endl;
112 return true;
113 }
114};
115
116class DataFileDebug : public DataFileNone
117{
118public:
119 DataFileDebug(uint32_t id) : DataFileNone(id) { }
120
121 bool Write(EVENT *e)
122 {
123 cout << "WRITE_EVENT #" << GetRunId() << " (" << e->EventNum << ")" << endl;
124 cout << " Typ=" << e->TriggerType << endl;
125 cout << " roi=" << e->Roi << endl;
126 cout << " trg=" << e->SoftTrig << endl;
127 cout << " tim=" << e->PCTime << endl;
128
129 return true;
130 }
131};
132
133#include "FAD.h"
134
135class DataFileRaw : public DataFileImp
136{
137 ofstream fOut;
138
139 off_t fPosTail;
140
141 uint32_t fCounter;
142
143
144 // WRITE uint32_t 0xFAC77e1e (FACT Tele)
145 // ===
146 // WRITE uint32_t TYPE(>0) == 1
147 // WRITE uint32_t ID(>0) == 0
148 // WRITE uint32_t VERSION(>0) == 1
149 // WRITE uint32_t LENGTH
150 // -
151 // WRITE uint32_t TELESCOPE ID
152 // WRITE uint32_t RUNID
153 // ===
154 // WRITE uint32_t TYPE(>0) == 2
155 // WRITE uint32_t ID(>0) == 0
156 // WRITE uint32_t VERSION(>0) == 1
157 // WRITE uint32_t LENGTH
158 // -
159 // WRITE HEADER
160 // ===
161 // [ 40 TIMES
162 // WRITE uint32_t TYPE(>0) == 3
163 // WRITE uint32_t ID(>0) == 0..39
164 // WRITE uint32_t VERSION(>0) == 1
165 // WRITE uint32_t LENGTH
166 // -
167 // WRITE BOARD-HEADER
168 // ]
169 // ===
170 // WRITE uint32_t TYPE(>0) == 4
171 // WRITE uint32_t ID(>0) == 0
172 // WRITE uint32_t VERSION(>0) == 1
173 // WRITE uint32_t LENGTH
174 // -
175 // WRITE FOOTER (empty)
176 // ===
177 // [ N times
178 // WRITE uint32_t TYPE(>0) == 10
179 // WRITE uint32_t ID(>0) == counter
180 // WRITE uint32_t VERSION(>0) == 1
181 // WRITE uint32_t LENGTH HEADER
182 // -
183 // WRITE HEADER+DATA
184 // ]
185 // ===
186 // WRITE uint32_t TYPE ==0
187 // WRITE uint32_t VERSION==0
188 // WRITE uint32_t LENGTH ==0
189 // ===
190 // Go back and write footer
191
192public:
193 DataFileRaw(uint32_t id) : DataFileImp(id) { }
194 ~DataFileRaw() { Close(); }
195
196 void WriteBlockHeader(uint32_t type, uint32_t ver, uint32_t cnt, uint32_t len)
197 {
198 const uint32_t val[4] = { type, ver, cnt, len };
199
200 fOut.write(reinterpret_cast<const char*>(val), sizeof(val));
201 }
202
203 template<typename T>
204 void WriteValue(const T &t)
205 {
206 fOut.write(reinterpret_cast<const char*>(&t), sizeof(T));
207 }
208
209 enum
210 {
211 kEndOfFile = 0,
212 kIdentifier = 1,
213 kRunHeader,
214 kBoardHeader,
215 kRunSummary,
216 kEvent,
217 };
218
219 virtual bool OpenFile(RUN_HEAD *h)
220 {
221 const string name = FormFileName(h->RunType, "bin");
222
223 errno = 0;
224 fOut.open(name.c_str(), ios_base::out);
225 if (!fOut)
226 {
227 //ostringstream str;
228 //str << "Open file " << name << ": " << strerror(errno) << " (errno=" << errno << ")";
229 //Error(str);
230
231 return false;
232 }
233
234 fCounter = 0;
235
236 static uint32_t FACT = 0xFAC77e1e;
237
238 fOut.write(reinterpret_cast<char*>(&FACT), 4);
239
240 WriteBlockHeader(kIdentifier, 1, 0, 8);
241 WriteValue(uint32_t(0));
242 WriteValue(GetRunId());
243
244 WriteBlockHeader(kRunHeader, 1, 0, sizeof(RUN_HEAD)-sizeof(PEVNT_HEADER*));
245 fOut.write(reinterpret_cast<char*>(h), sizeof(RUN_HEAD)-sizeof(PEVNT_HEADER*));
246
247 for (int i=0; i<40; i++)
248 {
249 WriteBlockHeader(kBoardHeader, 1, i, sizeof(PEVNT_HEADER));
250 fOut.write(reinterpret_cast<char*>(h->FADhead+i), sizeof(PEVNT_HEADER));
251 }
252
253 // FIXME: Split this
254 const vector<char> block(sizeof(uint32_t)+sizeof(RUN_TAIL));
255 WriteBlockHeader(kRunSummary, 1, 0, block.size());
256
257 fPosTail = fOut.tellp();
258 fOut.write(block.data(), block.size());
259
260 if (!fOut)
261 {
262 //ostringstream str;
263 //str << "Open file " << name << ": " << strerror(errno) << " (errno=" << errno << ")";
264 //Error(str);
265
266 return false;
267 }
268
269 return true;
270 }
271 virtual bool Write(EVENT *evt)
272 {
273 const int sh = sizeof(EVENT)-2 + NPIX*evt->Roi*2;
274
275 WriteBlockHeader(kEvent, 1, fCounter++, sh);
276 fOut.write(reinterpret_cast<char*>(evt)+2, sh);
277 return true;
278 }
279 virtual bool Close(RUN_TAIL *tail= 0)
280 {
281 WriteBlockHeader(kEndOfFile, 0, 0, 0);
282
283 if (tail)
284 {
285 fOut.seekp(fPosTail);
286
287 WriteValue(uint32_t(1));
288 fOut.write(reinterpret_cast<char*>(tail), sizeof(RUN_TAIL));
289 }
290
291 if (!fOut)
292 {
293 //ostringstream str;
294 //str << "Open file " << name << ": " << strerror(errno) << " (errno=" << errno << ")";
295 //Error(str);
296
297 return false;
298 }
299
300 fOut.close();
301
302 if (!fOut)
303 {
304 //ostringstream str;
305 //str << "Open file " << name << ": " << strerror(errno) << " (errno=" << errno << ")";
306 //Error(str);
307
308 return false;
309 }
310
311 return true;
312 }
313};
314
315#ifdef HAS_FITS
316class DataFileFits : public DataFileImp
317{
318 CCfits::FITS* fFile; /// The pointer to the CCfits FITS file
319 CCfits::Table* fTable; /// The pointer to the CCfits binary table
320
321 uint64_t fNumRows; ///the number of rows that have been written already to the FITS file.
322
323public:
324 DataFileFits(uint32_t runid) : DataFileImp(runid), fFile(0)
325 {
326 }
327
328 // --------------------------------------------------------------------------
329 //
330 //! Default destructor
331 //! The Fits file SHOULD have been closed already, otherwise the informations
332 //! related to the RUN_TAIL will NOT be written to the file.
333 //
334 ~DataFileFits() { Close(); }
335
336 // --------------------------------------------------------------------------
337 //
338 //! Add a new column to the vectors storing the column data.
339 //! @param names the vector of string storing the columns names
340 //! @param types the vector of string storing the FITS data format
341 //! @param numElems the number of elements in this column
342 //! @param type the char describing the FITS data format
343 //! @param name the name of the particular column to be added.
344 //
345 inline void AddColumnEntry(vector<string>& names, vector<string>& types, int numElems, char type, string name)
346 {
347 names.push_back(name);
348
349 ostringstream str;
350 if (numElems != 1)
351 str << numElems;
352 str << type;
353 types.push_back(str.str());
354 }
355
356 // --------------------------------------------------------------------------
357 //
358 //! Writes a single header key entry
359 //! @param name the name of the key
360 //! @param value its value
361 //! @param comment the comment associated to that key
362 //
363 //FIXME this function is a duplicate from the class Fits. should we try to merge it ?
364 template <typename T>
365 void WriteKey(const string &name, const T &value, const string &comment)
366 {
367 try
368 {
369 fTable->addKey(name, value, comment);
370 }
371 catch (CCfits::FitsException e)
372 {
373 ostringstream str;
374 str << "Could not add header key ";
375 //TODO pipe the error message somewhere
376 }
377 }
378
379 template <typename T>
380 void WriteKey(const string &name, const int idx, const T &value, const string &comment)
381 {
382 ostringstream str;
383 str << name << idx;
384
385 WriteKey(str.str(), value, comment);
386 }
387
388 // --------------------------------------------------------------------------
389 //
390 //! DataFileFits constructor. This is the one that should be used, not the default one (parameter-less)
391 //! @param runid This parameter should probably be removed. I first thought it was the run number, but apparently it is not
392 //! @param h a pointer to the RUN_HEAD structure that contains the informations relative to this run
393 //
394 bool OpenFile(RUN_HEAD* h)
395 {
396 //Form filename, based on runid and run-type
397 const string fileName = FormFileName(h->RunType, "fits");
398
399 //create the FITS object
400 try
401 {
402 fFile = new CCfits::FITS(fileName, CCfits::RWmode::Write);
403 }
404 catch (CCfits::FitsException e)
405 {
406 ostringstream str;
407 str << "Could not open FITS file " << fileName << " reason: " << e.message();
408 //TODO display the message somewhere
409
410 return false;
411 }
412
413 //create columns according to header
414 ostringstream arrayTypes;
415
416 // uint32_t EventNum ; // EventNumber as from FTM
417 // uint16_t TriggerType ; // Trigger Type from FTM
418 // uint32_t SoftTrig ; // SoftTrigger Info (TBD)
419 // uint32_t PCTime ; // when did event start to arrive at PC
420 // uint32_t BoardTime[NBOARDS];//
421 // int16_t StartPix[NPIX]; // First Channel per Pixel (Pixels sorted according Software ID) ; -1 if not filled
422 // int16_t StartTM[NTMARK]; // First Channel for TimeMark (sorted Hardware ID) ; -1 if not filled
423 // uint16_t Adc_Data[]; // final length defined by malloc ....
424
425 vector<string> colNames;
426 vector<string> dataTypes;
427 AddColumnEntry(colNames, dataTypes, 1, 'V', "EventNum");
428 AddColumnEntry(colNames, dataTypes, 1, 'U', "TriggerType");
429 AddColumnEntry(colNames, dataTypes, 1, 'V', "SoftTrig");
430 AddColumnEntry(colNames, dataTypes, 1, 'V', "PCTime");
431 AddColumnEntry(colNames, dataTypes, NBOARDS, 'V', "BoardTime");
432 AddColumnEntry(colNames, dataTypes, NPIX, 'I', "StartPix");
433 AddColumnEntry(colNames, dataTypes, NTMARK, 'I', "StartTM");
434 AddColumnEntry(colNames, dataTypes, NPIX*h->Nroi, 'U', "Data");
435
436 //actually create the table
437 try
438 {
439 fTable = fFile->addTable("Events", 0, colNames, dataTypes);
440 if (fTable->rows() != 0)
441 {
442 ostringstream str;
443 str << "Error: table created on the fly looks non-empty.";
444 //TODO giev the error text to some error handler
445 //FIXME I guess that this error checking is useless. remove it for performances.
446 }
447 }
448 catch (const CCfits::FitsException &e)
449 {
450 ostringstream str;
451 str << "Could not create FITS table " << "Events" << " in file " << fileName << " reason: " << e.message();
452 //TODO give the error text to some error handler
453
454 Close();
455 return false;
456 }
457
458 //write header data
459 //first the "standard" keys
460 string stringValue;
461 WriteKey("EXTREL", 1.0f, "Release Number");
462 WriteKey("TELESCOP", "FACT", "Telescope that acquired this data");
463 WriteKey("ORIGIN", "ISDC", "Institution that wrote the file");
464 WriteKey("CREATOR", "FACT++ Event Builder", "Program that wrote this file");
465
466 stringValue = Time().GetAsStr();
467 stringValue[10]= 'T';
468 WriteKey("DATE", stringValue, "File creation data");
469 WriteKey("TIMESYS", "TT", "Time frame system");
470 WriteKey("TIMEUNIT", "d", "Time unit");
471 WriteKey("TIMEREF", "UTC", "Time reference frame");
472 //FIXME should we also put the start and stop time of the received data ?
473 //now the events header related variables
474 WriteKey("VERSION", h->Version, "Builder version");
475 WriteKey("RUNTYPE", h->RunType, "Type of run");
476 WriteKey("NBOARD", h->NBoard, "Number of acquisition boards");
477 WriteKey("NPIX", h->NPix, "Number of pixels");
478 WriteKey("NTM", h->NTm, "Number of Time marks");
479 WriteKey("NROI", h->Nroi, "Number of slices per pixels");
480
481 //now the boards related keywords
482 for (int i=0; i<h->NBoard; i++)
483 {
484 const PEVNT_HEADER &hh = h->FADhead[i];
485
486 WriteKey("STPKGFG", i, hh.start_package_flag,
487 "Start package flag");
488
489 WriteKey("PKGLEN", i, hh.package_length,
490 "Package length");
491
492 WriteKey("VERNO", i, hh.version_no,
493 "Version number");
494
495 WriteKey("STATUS", i, hh.PLLLCK,
496 "");
497/*
498 WriteKey("TRIGCRC", i, hh.trigger_crc,
499 "Trigger CRC");
500
501 WriteKey("TRIGTYP", i, hh.trigger_type,
502 "Trigger type");
503
504 WriteKey("TRIGID", i, hh.trigger_id,
505 "Trigger ID");
506
507 WriteKey("EVTCNTR", i, hh.fad_evt_counter,
508 "FAD Event Counter");
509
510 WriteKey("REFCLK", i, hh.REFCLK_frequency,
511 "Reference Clock Frequency");
512*/
513 WriteKey("BOARDID", i, hh.board_id,
514 "Board ID");
515
516 WriteKey("PHASESH", i, hh.adc_clock_phase_shift,
517 "ADC clock phase shift");
518
519 WriteKey("TRGGEN", i, hh.number_of_triggers_to_generate,
520 "Number of triggers to generate");
521
522 WriteKey("PRESC", i, hh.trigger_generator_prescaler,
523 "Trigger generator prescaler");
524
525 WriteKey("DNA", i, hh.DNA, "DNA");
526 WriteKey("TIME", i, hh.time, "Time");
527 WriteKey("RUNNB", i, hh.runnumber, "Run number");
528/*
529 for (int j=0;j<NTemp;j++)
530 {
531 str.str(""); str2.str("");
532 str << "DRS_T" << i << j;
533 str2 << "DRS temperature #" << i << " " << j;
534 WriteKey(str.str(), h->FADhead[i].drs_temperature[j], str2.str());
535 }
536*/
537 for (int j=0;j<NDAC;j++)
538 WriteKey("DAC", i*NDAC+j, hh.dac[j], "DAC");
539
540 //Last but not least, add header keys that will be updated when closing the file
541 WriteFooter(NULL);
542 }
543
544 return true;
545 }
546
547
548 int WriteColumns(size_t &start, size_t size, void *e)
549 {
550 int status = 0;
551 fits_write_tblbytes(fFile->fitsPointer(), fNumRows, start, size, reinterpret_cast<unsigned char*>(e), &status);
552 if (status)
553 {
554 char text[30];//max length of cfitsio error strings (from doc)
555 fits_get_errstatus(status, text);
556 //ostringstream str;
557 //str << "Writing FITS row " << i << " in " << groupName << ": " << text << " (file_write_tblbytes, rc=" << status << ")";
558 //Error(str);
559 }
560
561 start += size;
562 return status;
563 }
564
565 // --------------------------------------------------------------------------
566 //
567 //! This writes one event to the file
568 //! @param e the pointer to the EVENT
569 //
570 virtual bool Write(EVENT *e)
571 {
572 //FIXME As discussed earlier, we do not swap the bytes yet.
573 fTable->makeThisCurrent();
574
575 //insert a new row
576 int status(0);
577 if (fits_insert_rows(fTable->fitsPointer(), fNumRows, 1, &status))
578 {
579 //ostringstream str;
580 //str << "Inserting row into " << fFileName << " failed (fits_insert_rows, rc=" << status << ")";
581 //fMess->Error(str);
582 //TODO pipe this error message to the appropriate error stream
583 }
584 fNumRows++;
585
586 const int sh = sizeof(EVENT)+NPIX*e->Roi*2;
587
588 // column size pointer
589 size_t col = 1;
590 if (!WriteColumns(col, sh, e))
591 return true;
592
593 //TODO output an error
594 return false;
595
596 /*
597 //write the data, chunk by chunk
598 //FIXME hard-coded size corresponds to current variables of the event, in bytes.
599 //FIXME no padding was taken into account. Because smallest member is 2 bytes, I don't think that this should be a problem.
600 const long sizeInBytesOfEventBeforePointers = 16;
601
602 long col = 1;
603 if (FitsWriteTblBytes(col, sizeInBytesOfEventBeforePointers, e))
604 {
605 //TODO output an error
606 return false;
607 }
608 if (FitsWriteTblBytes(col, NBOARDS*2, e->BoardTime))
609 {
610 //TODO output an error
611 return false;
612 }
613 if (FitsWriteTblBytes(col, NPIX*2, e->StartPix))
614 {
615 //TODO output an error
616 return false;
617 }
618 if (FitsWriteTblBytes(col, NTMARK*2, e->StartTM))
619 {
620 //TODO output an error
621 return false;
622 }
623 if (FitsWriteTblBytes(col, NPIX*fRoi*2, e->Adc_Data))
624 {
625 //TODO output an error
626 return false;
627 }
628 return true;*/
629 }
630
631 void WriteFooter(RUN_TAIL *rt)
632 {
633 //write final header keys
634 fTable->makeThisCurrent();
635
636 WriteKey("NBEVTOK", rt ? rt->nEventsOk : uint32_t(0),
637 "How many events were written");
638
639 WriteKey("NBEVTREJ", rt ? rt->nEventsRej : uint32_t(0),
640 "How many events were rejected by SW-trig");
641
642 WriteKey("NBEVTBAD", rt ? rt->nEventsBad : uint32_t(0),
643 "How many events were rejected by Error");
644
645 //FIXME shouldn't we convert start and stop time to MjD first ?
646 //FIXME shouldn't we also add an MjD reference ?
647
648 WriteKey("TSTART", rt ? rt->PCtime0 : uint32_t(0),
649 "Time when first event received");
650
651 WriteKey("TSTOP", rt ? rt->PCtimeX : uint32_t(0),
652 "Time when last event received");
653 }
654
655 // --------------------------------------------------------------------------
656 //
657 //! Closes the file, and before this it write the TAIL data
658 //! @param rt the pointer to the RUN_TAIL data structure
659 //
660 virtual bool Close(RUN_TAIL *rt = 0)
661 {
662 if (!fFile)
663 return false;
664
665 WriteFooter(rt);
666
667 delete fFile;
668 fFile = NULL;
669
670 return true;
671 }
672
673};
674#else
675#define DataFileFits DataFileRaw
676#endif
677
678class EventBuilderWrapper
679{
680public:
681 // FIXME
682 static EventBuilderWrapper *This;
683
684 MessageImp &fMsg;
685
686private:
687 boost::thread fThread;
688
689 enum CommandStates_t // g_runStat
690 {
691 kAbort = -40, // quit as soon as possible ('abort')
692 kExit = -30, // stop reading, quit when buffered events done ('exit')
693 kReset = -20, // Like EXIT but without closing files and sockets
694 kStop = -10, // Like ABORT but without closing files and sockets
695 kInitialize = 0, // 'initialize' (e.g. dim not yet started)
696 kHybernate = 1, // do nothing for long time ('hybernate') [wakeup within ~1sec]
697 kSleep = 2, // do nothing ('sleep') [wakeup within ~10msec]
698 kModeFlush = 10, // read data from camera, but skip them ('flush')
699 kModeTest = 20, // read data and process them, but do not write to disk ('test')
700 kModeFlag = 30, // read data, process and write all to disk ('flag')
701 kModeRun = 40, // read data, process and write selected to disk ('run')
702 };
703
704 enum
705 {
706 kCurrent = 0,
707 kTotal = 1,
708 kEventId = 2,
709 kTriggerId = 3,
710 };
711
712 enum FileFormat_t
713 {
714 kNone = 0,
715 kDebug,
716 kFits,
717 kRaw
718 };
719
720 FileFormat_t fFileFormat;
721
722
723 uint32_t fMaxRun;
724 uint32_t fLastOpened;
725 uint32_t fLastClosed;
726 uint32_t fNumEvts[4];
727
728 DimDescribedService fDimRuns;
729 DimDescribedService fDimEvents;
730 DimDescribedService fDimEventData;
731 DimDescribedService fDimFwVersion;
732 DimDescribedService fDimRunNumber;
733 DimDescribedService fDimStatus;
734 DimDescribedService fDimDNA;
735 DimDescribedService fDimTemperature;
736 DimDescribedService fDimRefClock;
737 DimDescribedService fDimStatistics1;
738 DimDescribedService fDimStatistics2;
739
740 bool fDebugStream;
741 bool fDebugRead;
742
743 int Write(const Time &time, const std::string &txt, int qos)
744 {
745 return fMsg.Write(time, txt, qos);
746 }
747
748
749 int fRunNumber;
750
751
752 void InitRunNumber()
753 {
754 const int night = Time().NightAsInt();
755
756 fRunNumber = 1000;
757
758 while (--fRunNumber>=0)
759 {
760 ostringstream name;
761 name << night << '.' << setfill('0') << setw(3) << fRunNumber;
762
763 if (access((name.str()+".bin").c_str(), F_OK) == 0)
764 break;
765 if (access((name.str()+".fits").c_str(), F_OK) == 0)
766 break;
767 }
768
769 fRunNumber++;
770
771 cout << "FOUND: " << night << '.' << setfill('0') << setw(3) << fRunNumber << endl;
772 }
773
774public:
775 EventBuilderWrapper(MessageImp &imp) : fMsg(imp),
776 fFileFormat(kNone), fMaxRun(0), fLastOpened(0), fLastClosed(0),
777 fDimRuns ("FAD_CONTROL/RUNS", "I:5", ""),
778 fDimEvents ("FAD_CONTROL/EVENTS", "I:4", ""),
779 fDimEventData ("FAD_CONTROL/EVENT_DATA", "S:1;I:1;S:1;I:2;S:1;S", ""),
780 fDimFwVersion ("FAD_CONTROL/FIRMWARE_VERSION", "F:42", ""),
781 fDimRunNumber ("FAD_CONTROL/RUN_NUMBER", "I:42", ""),
782 fDimStatus ("FAD_CONTROL/STATUS", "S:42", ""),
783 fDimDNA ("FAD_CONTROL/DNA", "X:40", ""),
784 fDimTemperature ("FAD_CONTROL/TEMPERATURE", "F:82", ""),
785 fDimRefClock ("FAD_CONTROL/REFERENCE_CLOCK", "I:42", ""),
786 fDimStatistics1 ("FAD_CONTROL/STATISTICS1", "I:3;I:5;I:1;X:3", ""),
787 fDimStatistics2 ("FAD_CONTROL/STATISTICS2", "I:1;I:280;X:40;I:40;I:4;I:4;I:2;I:2;I:3;C:40", ""),
788 fDebugStream(false), fDebugRead(false)
789 {
790 if (This)
791 throw logic_error("EventBuilderWrapper cannot be instantiated twice.");
792
793 This = this;
794
795 memset(fNumEvts, 0, sizeof(fNumEvts));
796
797 fDimEvents.Update(fNumEvts);
798
799 for (size_t i=0; i<40; i++)
800 ConnectSlot(i, tcp::endpoint());
801
802 // InitRunNumber();
803 }
804 virtual ~EventBuilderWrapper()
805 {
806 Abort();
807
808 // FIXME: Used timed_join and abort afterwards
809 // What's the maximum time the eb need to abort?
810 fThread.join();
811 //ffMsg.Info("EventBuilder stopped.");
812
813 for (vector<DataFileImp*>::iterator it=fFiles.begin(); it!=fFiles.end(); it++)
814 delete *it;
815 }
816
817 bool IsThreadRunning()
818 {
819 return !fThread.timed_join(boost::posix_time::microseconds(0));
820 }
821
822 void SetMaxMemory(unsigned int mb) const
823 {
824 /*
825 if (mb*1000000<GetUsedMemory())
826 {
827 // ffMsg.Warn("...");
828 return;
829 }*/
830
831 g_maxMem = size_t(mb)*1000000;
832 }
833
834 void StartThread(const vector<tcp::endpoint> &addr)
835 {
836 if (IsThreadRunning())
837 {
838 fMsg.Warn("Start - EventBuilder still running");
839 return;
840 }
841
842 for (size_t i=0; i<40; i++)
843 ConnectSlot(i, addr[i]);
844
845 g_runStat = kModeRun;
846
847 fMsg.Message("Starting EventBuilder thread");
848
849 fThread = boost::thread(StartEvtBuild);
850 }
851 void ConnectSlot(unsigned int i, const tcp::endpoint &addr)
852 {
853 if (i>39)
854 return;
855
856 if (addr==tcp::endpoint())
857 {
858 DisconnectSlot(i);
859 return;
860 }
861
862 g_port[i].sockAddr.sin_family = AF_INET;
863 g_port[i].sockAddr.sin_addr.s_addr = htonl(addr.address().to_v4().to_ulong());
864 g_port[i].sockAddr.sin_port = htons(addr.port());
865 // In this order
866 g_port[i].sockDef = 1;
867 }
868 void DisconnectSlot(unsigned int i)
869 {
870 if (i>39)
871 return;
872
873 g_port[i].sockDef = 0;
874 // In this order
875 g_port[i].sockAddr.sin_family = AF_INET;
876 g_port[i].sockAddr.sin_addr.s_addr = 0;
877 g_port[i].sockAddr.sin_port = 0;
878 }
879 void IgnoreSlot(unsigned int i)
880 {
881 if (i>39)
882 return;
883 if (g_port[i].sockAddr.sin_port==0)
884 return;
885
886 g_port[i].sockDef = -1;
887 }
888
889
890 void Abort()
891 {
892 fMsg.Message("Signal abort to EventBuilder thread...");
893 g_runStat = kAbort;
894 }
895
896 void ResetThread()
897 {
898 fMsg.Message("Signal reset to EventBuilder thread...");
899 g_runStat = kReset;
900 }
901
902 void Exit()
903 {
904 fMsg.Message("Signal exit to EventBuilder thread...");
905 g_runStat = kExit;
906 }
907
908 /*
909 void Wait()
910 {
911 fThread.join();
912 ffMsg.Message("EventBuilder stopped.");
913 }*/
914
915 void Hybernate() const { g_runStat = kHybernate; }
916 void Sleep() const { g_runStat = kSleep; }
917 void FlushMode() const { g_runStat = kModeFlush; }
918 void TestMode() const { g_runStat = kModeTest; }
919 void FlagMode() const { g_runStat = kModeFlag; }
920 void RunMode() const { g_runStat = kModeRun; }
921
922 // FIXME: To be removed
923 void SetMode(int mode) const { g_runStat = mode; }
924
925 bool IsConnected(int i) const { return gi_NumConnect[i]==7; }
926 bool IsConnecting(int i) const { return !IsConnected(i) && !IsDisconnected(i); }
927 bool IsDisconnected(int i) const { return gi_NumConnect[i]<=0 && g_port[i].sockDef==0; }
928 int GetNumConnected(int i) const { return gi_NumConnect[i]; }
929
930 void SetIgnore(int i, bool b) const { if (g_port[i].sockDef!=0) g_port[i].sockDef=b?-1:1; }
931 bool IsIgnored(int i) const { return g_port[i].sockDef==-1; }
932
933 void SetOutputFormat(FileFormat_t f) { fFileFormat = f; }
934
935 void SetDebugStream(bool b)
936 {
937 fDebugStream = b;
938 if (b)
939 return;
940
941 for (int i=0; i<40; i++)
942 {
943 if (!fDumpStream[i].is_open())
944 continue;
945
946 fDumpStream[i].close();
947
948 ostringstream name;
949 name << "socket_dump-" << setfill('0') << setw(2) << i << ".bin";
950 fMsg.Message("Closed file '"+name.str()+"'");
951 }
952 }
953
954 void SetDebugRead(bool b)
955 {
956 fDebugRead = b;
957 if (b || !fDumpRead.is_open())
958 return;
959
960 fDumpRead.close();
961 fMsg.Message("Closed file 'socket_events.txt'");
962 }
963
964// size_t GetUsedMemory() const { return gi_usedMem; }
965
966 virtual int CloseOpenFiles() { CloseRunFile(0, 0); return 0; }
967
968
969 /*
970 struct OpenFileToDim
971 {
972 int code;
973 char fileName[FILENAME_MAX];
974 };
975
976 SignalRunOpened(runid, filename);
977 // Send num open files
978 // Send runid, (more info about the run?), filename via dim
979
980 SignalEvtWritten(runid);
981 // Send num events written of newest file
982
983 SignalRunClose(runid);
984 // Send new num open files
985 // Send empty file-name if no file is open
986
987 */
988
989 // -------------- Mapped event builder callbacks ------------------
990
991 void UpdateRuns()
992 {
993 uint32_t values[5] =
994 {
995 static_cast<uint32_t>(fFiles.size()),
996 0xffffffff,
997 0,
998 fLastOpened,
999 fLastClosed
1000 };
1001
1002 for (vector<DataFileImp*>::const_iterator it=fFiles.begin();
1003 it!=fFiles.end(); it++)
1004 {
1005 const DataFileImp *file = *it;
1006
1007 if (file->GetRunId()<values[1])
1008 values[1] = file->GetRunId();
1009
1010 if (file->GetRunId()>values[2])
1011 values[2] = file->GetRunId();
1012 }
1013
1014 fMaxRun = values[2];
1015
1016 fDimRuns.Update(values);
1017 }
1018
1019 vector<DataFileImp*> fFiles;
1020
1021 FileHandle_t runOpen(uint32_t runid, RUN_HEAD *h, size_t)
1022 {
1023 // Check if file already exists...
1024 DataFileImp *file = 0;
1025 switch (fFileFormat)
1026 {
1027 case kNone: file = new DataFileNone(runid); break;
1028 case kDebug: file = new DataFileDebug(runid); break;
1029 case kFits: file = new DataFileFits(runid); break;
1030 case kRaw: file = new DataFileRaw(runid); break;
1031 }
1032
1033 try
1034 {
1035 if (!file->OpenFile(h))
1036 return 0;
1037 }
1038 catch (const exception &e)
1039 {
1040 return 0;
1041 }
1042
1043 fFiles.push_back(file);
1044
1045 fLastOpened = runid;
1046 UpdateRuns();
1047
1048 fNumEvts[kEventId] = 0;
1049 fNumEvts[kTriggerId] = 0;
1050
1051 fNumEvts[kCurrent] = 0;
1052 fDimEvents.Update(fNumEvts);
1053 // fDimCurrentEvent.Update(uint32_t(0));
1054
1055 return reinterpret_cast<FileHandle_t>(file);
1056 }
1057
1058 int runWrite(FileHandle_t handler, EVENT *e, size_t)
1059 {
1060 DataFileImp *file = reinterpret_cast<DataFileImp*>(handler);
1061
1062 if (!file->Write(e))
1063 return -1;
1064
1065 if (file->GetRunId()==fMaxRun)
1066 {
1067 fNumEvts[kCurrent]++;
1068 fNumEvts[kEventId] = e->EventNum;
1069 fNumEvts[kTriggerId] = e->TriggerType;
1070 }
1071
1072 fNumEvts[kTotal]++;
1073
1074 static Time oldt(boost::date_time::neg_infin);
1075 Time newt;
1076 if (newt>oldt+boost::posix_time::seconds(1))
1077 {
1078 fDimEvents.Update(fNumEvts);
1079 oldt = newt;
1080 }
1081
1082
1083 // ===> SignalEvtWritten(runid);
1084 // Send num events written of newest file
1085
1086 /* close run runId (all all runs if runId=0) */
1087 /* return: 0=close scheduled / >0 already closed / <0 does not exist */
1088 //CloseRunFile(file->GetRunId(), time(NULL)+2) ;
1089
1090 return 0;
1091 }
1092
1093 int runClose(FileHandle_t handler, RUN_TAIL *tail, size_t)
1094 {
1095 DataFileImp *file = reinterpret_cast<DataFileImp*>(handler);
1096
1097 const vector<DataFileImp*>::iterator it = find(fFiles.begin(), fFiles.end(), file);
1098 if (it==fFiles.end())
1099 {
1100 ostringstream str;
1101 str << "File handler (" << handler << ") requested to close by event builder doesn't exist.";
1102 fMsg.Fatal(str);
1103 return -1;
1104 }
1105
1106 ostringstream str;
1107 str << "Closing file for run " << file->GetRunId() << " (" << file << ")" << endl;
1108 fMsg.Info(str);
1109
1110 fFiles.erase(it);
1111
1112 fLastClosed = file->GetRunId();
1113 UpdateRuns();
1114
1115 fDimEvents.Update(fNumEvts);
1116
1117 const bool rc = file->Close(tail);
1118 if (!rc)
1119 {
1120 // Error message
1121 }
1122
1123 delete file;
1124
1125 // ==> SignalRunClose(runid);
1126 // Send new num open files
1127 // Send empty file-name if no file is open
1128
1129 return rc ? 0 : -1;
1130 }
1131
1132 ofstream fDumpStream[40];
1133
1134 void debugStream(int isock, void *buf, int len)
1135 {
1136 if (!fDebugStream)
1137 return;
1138
1139 const int slot = isock/7;
1140 if (slot<0 || slot>39)
1141 return;
1142
1143 if (!fDumpStream[slot].is_open())
1144 {
1145 ostringstream name;
1146 name << "socket_dump-" << setfill('0') << setw(2) << slot << ".bin";
1147
1148 fDumpStream[slot].open(name.str().c_str(), ios::app);
1149 if (!fDumpStream[slot])
1150 {
1151 ostringstream str;
1152 str << "Open file '" << name << "': " << strerror(errno) << " (errno=" << errno << ")";
1153 fMsg.Error(str);
1154
1155 return;
1156 }
1157
1158 fMsg.Message("Opened file '"+name.str()+"' for writing.");
1159 }
1160
1161 fDumpStream[slot].write(reinterpret_cast<const char*>(buf), len);
1162 }
1163
1164 ofstream fDumpRead; // Stream to possibly dump docket events
1165
1166 void debugRead(int isock, int ibyte, uint32_t event, uint32_t ftmevt, uint32_t runno, int state, uint32_t tsec, uint32_t tusec)
1167 {
1168 // isock = socketID (0-279)
1169 // ibyte = #bytes gelesen
1170 // event = eventId (oder 0 wenn noch nicht bekannt)
1171 // state : 1=finished reading data
1172 // 0=reading data
1173 // -1=start reading data (header)
1174 // -2=start reading data,
1175 // eventId not known yet (too little data)
1176 // tsec, tusec = time when reading seconds, microseconds
1177 //
1178 if (!fDebugRead || ibyte==0)
1179 return;
1180
1181 if (!fDumpRead.is_open())
1182 {
1183 fDumpRead.open("socket_events.txt", ios::app);
1184 if (!fDumpRead)
1185 {
1186 ostringstream str;
1187 str << "Open file 'socket_events.txt': " << strerror(errno) << " (errno=" << errno << ")";
1188 fMsg.Error(str);
1189
1190 return;
1191 }
1192
1193 fMsg.Message("Opened file 'socket_events.txt' for writing.");
1194
1195 fDumpRead << "# START: " << Time().GetAsStr() << endl;
1196 fDumpRead << "# state time_sec time_usec socket slot runno event_id trigger_id bytes_received" << endl;
1197 }
1198
1199 fDumpRead
1200 << setw(2) << state << " "
1201 << setw(8) << tsec << " "
1202 << setw(9) << tusec << " "
1203 << setw(3) << isock << " "
1204 << setw(2) << isock/7 << " "
1205 << runno << " "
1206 << event << " "
1207 << ftmevt << " "
1208 << ibyte << endl;
1209 }
1210
1211 struct DimEventData
1212 {
1213 uint16_t Roi ; // #slices per pixel (same for all pixels and tmarks)
1214 uint32_t EventNum ; // EventNumber as from FTM
1215 uint16_t TriggerType ; // Trigger Type from FTM
1216
1217 uint32_t PCTime ; // when did event start to arrive at PC
1218 uint32_t BoardTime; //
1219
1220 int16_t StartPix; // First Channel per Pixel (Pixels sorted according Software ID) ; -1 if not filled
1221 int16_t StartTM; // First Channel for TimeMark (sorted Hardware ID) ; -1 if not filled
1222
1223 uint16_t Adc_Data[]; // final length defined by malloc ....
1224
1225 } __attribute__((__packed__));;
1226
1227 int eventCheck(PEVNT_HEADER *fadhd, EVENT *event)
1228 {
1229 /*
1230 fadhd[i] ist ein array mit den 40 fad-headers
1231 (falls ein board nicht gelesen wurde, ist start_package_flag =0 )
1232
1233 event ist die Struktur, die auch die write routine erhaelt;
1234 darin sind im header die 'soll-werte' fuer z.B. eventID
1235 als auch die ADC-Werte (falls Du die brauchst)
1236
1237 Wenn die routine einen negativen Wert liefert, wird das event
1238 geloescht (nicht an die write-routine weitergeleitet [mind. im Prinzip]
1239 */
1240
1241 static Time oldt(boost::date_time::neg_infin);
1242 Time newt;
1243
1244 if (newt<oldt+boost::posix_time::seconds(1))
1245 return 0;
1246
1247 oldt = newt;
1248
1249 static DimEventData *data = 0;
1250
1251 const size_t sz = sizeof(DimEventData)+event->Roi*2*1440;
1252
1253 if (data && data->Roi != event->Roi)
1254 {
1255 delete data;
1256 data = 0;
1257 }
1258
1259 if (!data)
1260 data = reinterpret_cast<DimEventData*>(new char[sz]);
1261
1262// cout << sizeof(DimEventData) << " " << event->Roi << " " << sz << " " << sizeof(*data) << endl;
1263
1264 data->Roi = event->Roi;
1265 data->EventNum = event->EventNum;
1266 data->TriggerType = event->TriggerType;
1267 data->PCTime = event->PCTime;
1268 data->BoardTime = event->BoardTime[0];
1269 data->StartPix = event->StartPix[0];
1270 data->StartTM = event->StartTM[0];
1271
1272 memcpy(data->Adc_Data, event->Adc_Data, event->Roi*2*1440);
1273
1274 fDimEventData.setData(data, sz);
1275 fDimEventData.updateService();
1276
1277 //delete data;
1278
1279 return 0;
1280 }
1281
1282 void factOut(int severity, int err, const char *message)
1283 {
1284 // FIXME: Make the output to the console stream thread-safe
1285 ostringstream str;
1286 str << "EventBuilder(";
1287 if (err<0)
1288 str << "---";
1289 else
1290 str << err;
1291 str << "): " << message;
1292
1293 static string last;
1294 if (str.str()==last)
1295 return;
1296
1297 last = str.str();
1298 fMsg.Update(str, severity);
1299 }
1300/*
1301 void factStat(int64_t *stat, int len)
1302 {
1303 if (len!=7)
1304 {
1305 fMsg.Warn("factStat received unknown number of values.");
1306 return;
1307 }
1308
1309 vector<int64_t> data(1, g_maxMem);
1310 data.insert(data.end(), stat, stat+len);
1311
1312 static vector<int64_t> last(8);
1313 if (data==last)
1314 return;
1315 last = data;
1316
1317 fDimStatistics.Update(data);
1318
1319 // len ist die Laenge des arrays.
1320 // array[4] enthaelt wieviele bytes im Buffer aktuell belegt sind; daran
1321 // kannst Du pruefen, ob die 100MB voll sind ....
1322
1323 ostringstream str;
1324 str
1325 << "Wait=" << stat[0] << " "
1326 << "Skip=" << stat[1] << " "
1327 << "Del=" << stat[2] << " "
1328 << "Tot=" << stat[3] << " "
1329 << "Mem=" << stat[4] << "/" << g_maxMem << " "
1330 << "Read=" << stat[5] << " "
1331 << "Conn=" << stat[6];
1332
1333 fMsg.Info(str);
1334 }
1335 */
1336
1337 void factStat(const EVT_STAT &stat)
1338 {
1339 fDimStatistics2.Update(stat);
1340 /*
1341 //some info about what happened since start of program (or last 'reset')
1342 uint32_t reset ; //#if increased, reset all counters
1343 uint32_t numRead[MAX_SOCK] ; //how often succesfull read from N sockets per loop
1344
1345 uint64_t gotByte[NBOARDS] ; //#Bytes read per Board
1346 uint32_t gotErr[NBOARDS] ; //#Communication Errors per Board
1347 uint32_t evtGet; //#new Start of Events read
1348 uint32_t evtTot; //#complete Events read
1349 uint32_t evtErr; //#Events with Errors
1350 uint32_t evtSkp; //#Events incomplete (timeout)
1351
1352 uint32_t procTot; //#Events processed
1353 uint32_t procErr; //#Events showed problem in processing
1354 uint32_t procTrg; //#Events accepted by SW trigger
1355 uint32_t procSkp; //#Events rejected by SW trigger
1356
1357 uint32_t feedTot; //#Events used for feedBack system
1358 uint32_t feedErr; //#Events rejected by feedBack
1359
1360 uint32_t wrtTot; //#Events written to disk
1361 uint32_t wrtErr; //#Events with write-error
1362
1363 uint32_t runOpen; //#Runs opened
1364 uint32_t runClose; //#Runs closed
1365 uint32_t runErr; //#Runs with open/close errors
1366
1367
1368 //info about current connection status
1369 uint8_t numConn[NBOARDS] ; //#Sockets succesfully open per board
1370 */
1371 }
1372
1373 void factStat(const GUI_STAT &stat)
1374 {
1375 fDimStatistics1.Update(stat);
1376 /*
1377 //info about status of the main threads
1378 int32_t readStat ; //read thread
1379 int32_t procStat ; //processing thread(s)
1380 int32_t writStat ; //write thread
1381
1382 //info about some rates
1383 int32_t deltaT ; //time in milli-seconds for rates
1384 int32_t readEvt ; //#events read
1385 int32_t procEvt ; //#events processed
1386 int32_t writEvt ; //#events written
1387 int32_t skipEvt ; //#events skipped
1388
1389 //some info about current state of event buffer (snapspot)
1390 int32_t evtBuf; //#Events currently waiting in Buffer
1391 uint64_t totMem; //#Bytes available in Buffer
1392 uint64_t usdMem; //#Bytes currently used
1393 uint64_t maxMem; //max #Bytes used during past Second
1394 */
1395 }
1396
1397
1398 boost::array<FAD::EventHeader, 40> fVecHeader;
1399
1400 template<typename T>
1401 boost::array<T, 42> Compare(const FAD::EventHeader *h, const T *t)
1402 {
1403 const int offset = reinterpret_cast<const char *>(t) - reinterpret_cast<const char *>(h);
1404
1405 const T *min = NULL;
1406 const T *val = NULL;
1407 const T *max = NULL;
1408
1409 boost::array<T, 42> vec;
1410
1411 bool rc = true;
1412 for (int i=0; i<40; i++)
1413 {
1414 const char *base = reinterpret_cast<const char*>(&fVecHeader[i]);
1415 const T *ref = reinterpret_cast<const T*>(base+offset);
1416
1417 vec[i] = *ref;
1418
1419 if (gi_NumConnect[i]!=7)
1420 {
1421 vec[i] = 0;
1422 continue;
1423 }
1424
1425 if (!val)
1426 {
1427 min = ref;
1428 val = ref;
1429 max = ref;
1430 }
1431
1432 if (*val<*min)
1433 min = val;
1434
1435 if (*val>*max)
1436 max = val;
1437
1438 if (*val!=*ref)
1439 rc = false;
1440 }
1441
1442 vec[40] = val ? *min : 0xffffffff;
1443 vec[41] = val ? *max : 0;
1444
1445 return vec;
1446 }
1447
1448 template<typename T>
1449 boost::array<T, 42> CompareBits(const FAD::EventHeader *h, const T *t)
1450 {
1451 const int offset = reinterpret_cast<const char *>(t) - reinterpret_cast<const char *>(h);
1452
1453 T val = 0;
1454 T rc = 0;
1455
1456 boost::array<T, 42> vec;
1457
1458 bool first = true;
1459
1460 for (int i=0; i<40; i++)
1461 {
1462 const char *base = reinterpret_cast<const char*>(&fVecHeader[i]);
1463 const T *ref = reinterpret_cast<const T*>(base+offset);
1464
1465 vec[i+2] = *ref;
1466
1467 if (gi_NumConnect[i]!=7)
1468 {
1469 vec[i+2] = 0;
1470 continue;
1471 }
1472
1473 if (first)
1474 {
1475 first = false;
1476 val = *ref;
1477 rc = 0;
1478 }
1479
1480 rc |= val^*ref;
1481 }
1482
1483 vec[0] = rc;
1484 vec[1] = val;
1485
1486 return vec;
1487 }
1488
1489 template<typename T, size_t N>
1490 void Update(DimDescribedService &svc, const boost::array<T, N> &data, int n=N)
1491 {
1492// svc.setQuality(vec[40]<=vec[41]);
1493 svc.setData(const_cast<T*>(data.data()), sizeof(T)*n);
1494 svc.updateService();
1495 }
1496
1497 template<typename T>
1498 void Print(const char *name, const pair<bool,boost::array<T, 43>> &data)
1499 {
1500 cout << name << "|" << data.first << "|" << data.second[1] << "|" << data.second[0] << "<x<" << data.second[1] << ":";
1501 for (int i=0; i<40;i++)
1502 cout << " " << data.second[i+3];
1503 cout << endl;
1504 }
1505
1506 vector<uint> fNumConnected;
1507
1508 void debugHead(int socket, const FAD::EventHeader &h)
1509 {
1510 const uint16_t id = h.Id();
1511 if (id>39)
1512 return;
1513
1514 if (fNumConnected.size()!=40)
1515 fNumConnected.resize(40);
1516
1517 const vector<uint> con(gi_NumConnect, gi_NumConnect+40);
1518
1519 const bool changed = con!=fNumConnected || !IsThreadRunning();
1520
1521 fNumConnected = con;
1522
1523 const FAD::EventHeader old = fVecHeader[id];
1524 fVecHeader[id] = h;
1525
1526 if (old.fVersion != h.fVersion || changed)
1527 {
1528 const boost::array<uint16_t,42> ver = Compare(&h, &h.fVersion);
1529
1530 boost::array<float,42> data;
1531 for (int i=0; i<42; i++)
1532 {
1533 ostringstream str;
1534 str << (ver[i]>>8) << '.' << (ver[i]&0xff);
1535 data[i] = atof(str.str().c_str());
1536 }
1537 Update(fDimFwVersion, data);
1538 }
1539
1540 if (old.fRunNumber != h.fRunNumber || changed)
1541 {
1542 const boost::array<uint32_t,42> run = Compare(&h, &h.fRunNumber);
1543 fDimRunNumber.Update(run);
1544 }
1545
1546 if (old.fDNA != h.fDNA || changed)
1547 {
1548 const boost::array<uint64_t,42> dna = Compare(&h, &h.fDNA);
1549 Update(fDimDNA, dna, 40);
1550 }
1551
1552 if (old.fStatus != h.fStatus || changed)
1553 {
1554 const boost::array<uint16_t,42> sts = CompareBits(&h, &h.fStatus);
1555 Update(fDimStatus, sts);
1556 }
1557
1558 // -----------
1559
1560 static Time oldt(boost::date_time::neg_infin);
1561 Time newt;
1562
1563 if (newt>oldt+boost::posix_time::seconds(1))
1564 {
1565 oldt = newt;
1566
1567 // --- RefClock
1568
1569 const boost::array<uint32_t,42> clk = Compare(&h, &h.fFreqRefClock);
1570 Update(fDimRefClock, clk);
1571
1572 // --- Temperatures
1573
1574 const boost::array<int16_t,42> tmp[4] =
1575 {
1576 Compare(&h, &h.fTempDrs[0]),
1577 Compare(&h, &h.fTempDrs[1]),
1578 Compare(&h, &h.fTempDrs[2]),
1579 Compare(&h, &h.fTempDrs[3])
1580 };
1581
1582 vector<int16_t> data;
1583 data.reserve(82);
1584 data.push_back(tmp[0][0]);
1585 data.insert(data.end(), tmp[0].data()+2, tmp[0].data()+42);
1586 data.push_back(tmp[0][1]);
1587 data.insert(data.end(), tmp[0].data()+2, tmp[0].data()+42);
1588
1589 for (int j=0; j<=3; j++)
1590 {
1591 const boost::array<int16_t,42> &ref = tmp[j];
1592
1593 // Gloabl min
1594 if (ref[40]<data[0])
1595 data[0] = ref[40];
1596
1597 // Global max
1598 if (ref[41]>data[40])
1599 data[40] = ref[41];
1600
1601 for (int i=0; i<40; i++)
1602 {
1603 // min per board
1604 if (ref[i]<data[i+1])
1605 data[i+1] = ref[i];
1606
1607 // max per board
1608 if (ref[i]>data[i+41])
1609 data[i+41] = ref[i];
1610 }
1611 }
1612
1613 vector<float> deg(82);
1614 for (int i=0; i<82; i++)
1615 deg[i] = data[i]/16.;
1616 fDimTemperature.Update(deg);
1617 }
1618
1619 /*
1620 uint16_t fTriggerType;
1621 uint32_t fTriggerId;
1622 uint32_t fEventCounter;
1623 uint16_t fAdcClockPhaseShift;
1624 uint16_t fNumTriggersToGenerate;
1625 uint16_t fTriggerGeneratorPrescaler;
1626 uint32_t fTimeStamp;
1627 int16_t fTempDrs[kNumTemp]; // In units of 1/16 deg(?)
1628 uint16_t fDac[kNumDac];
1629 */
1630 }
1631};
1632
1633EventBuilderWrapper *EventBuilderWrapper::This = 0;
1634
1635// ----------- Event builder callbacks implementation ---------------
1636extern "C"
1637{
1638 FileHandle_t runOpen(uint32_t irun, RUN_HEAD *runhd, size_t len)
1639 {
1640 return EventBuilderWrapper::This->runOpen(irun, runhd, len);
1641 }
1642
1643 int runWrite(FileHandle_t fileId, EVENT *event, size_t len)
1644 {
1645 return EventBuilderWrapper::This->runWrite(fileId, event, len);
1646 }
1647
1648 int runClose(FileHandle_t fileId, RUN_TAIL *runth, size_t len)
1649 {
1650 return EventBuilderWrapper::This->runClose(fileId, runth, len);
1651 }
1652
1653 void factOut(int severity, int err, const char *message)
1654 {
1655 if (severity!=99)
1656 EventBuilderWrapper::This->factOut(severity, err, message);
1657 }
1658
1659 void factStat(GUI_STAT stat)
1660 {
1661 EventBuilderWrapper::This->factStat(stat);
1662 }
1663
1664 void factStatNew(EVT_STAT stat)
1665 {
1666 EventBuilderWrapper::This->factStat(stat);
1667 }
1668
1669 void debugHead(int socket, int/*board*/, void *buf)
1670 {
1671 const uint16_t *ptr = reinterpret_cast<uint16_t*>(buf);
1672
1673 EventBuilderWrapper::This->debugHead(socket, FAD::EventHeader(ptr));
1674 }
1675
1676 void debugStream(int isock, void *buf, int len)
1677 {
1678 return EventBuilderWrapper::This->debugStream(isock, buf, len);
1679 }
1680
1681 void debugRead(int isock, int ibyte, int32_t event, int32_t ftmevt, int32_t runno, int state, uint32_t tsec, uint32_t tusec)
1682 {
1683 EventBuilderWrapper::This->debugRead(isock, ibyte, event, ftmevt, runno, state, tsec, tusec);
1684 }
1685
1686 int eventCheck(PEVNT_HEADER *fadhd, EVENT *event)
1687 {
1688 return EventBuilderWrapper::This->eventCheck(fadhd, event);
1689 }
1690}
1691
1692#endif
Note: See TracBrowser for help on using the repository browser.