Changeset 17332

Timestamp:

11/21/13 17:18:41 (11 years ago)

Author:

tbretz

Message:

Added a trigger counter in the run and event object and count the events; replaced the arguments to Open/Write/Close to have access to the full infomation including the trigger counters; added a new service TRIGGER_COUNTER

Location:

trunk/FACT++/src

Files:

• EventBuilder.cc (modified) (4 diffs)
• EventBuilder.h (modified) (4 diffs)
• EventBuilderWrapper.h (modified) (15 diffs)

trunk/FACT++/src/EventBuilder.cc

@@ -15 +15 @@
 #include "MessageImp.h"
 #include "EventBuilder.h"
+#include "HeadersFAD.h"
 
 using namespace std;
@@ -59 +60 @@
 bool runOpen(const EVT_CTRL2 &evt);
 bool runWrite(const EVT_CTRL2 &evt);
-void runClose(RUN_CTRL2 &run);
+void runClose(const EVT_CTRL2 &run);
 void applyCalib(const EVT_CTRL2 &evt, const size_t &size);
 void factOut(int severity, const char *message);
@@ -866 +867 @@
         return true;
 
-    runClose(run);
+    runClose(*evt);
     run.fileStat = kFileClosed;
 
@@ -914 +915 @@
             event->BoardTime[ib] = evt->FADhead[ib].time;
 
+        RUN_CTRL2 &run = *evt->runCtrl;
+
+        // Physics trigger
+        if (evt->trgTyp && !(evt->trgTyp & FAD::EventHeader::kAll))
+            run.triggerCounter[0]++;
+        // Pure pedestal trigger
+        else  if ((evt->trgTyp&FAD::EventHeader::kPedestal) && !(evt->trgTyp&FAD::EventHeader::kTIM))
+            run.triggerCounter[1]++;
+        // external light pulser trigger
+        else if (evt->trgTyp & FAD::EventHeader::kLPext)
+            run.triggerCounter[2]++;
+        // time calibration triggers
+        else if (evt->trgTyp & (FAD::EventHeader::kTIM|FAD::EventHeader::kPedestal))
+            run.triggerCounter[3]++;
+        // internal light pulser trigger
+        else if (evt->trgTyp & FAD::EventHeader::kLPint)
+            run.triggerCounter[4]++;
+        // external trigger input 1
+        else if (evt->trgTyp & FAD::EventHeader::kExt1)
+            run.triggerCounter[5]++;
+        // external trigger input 2
+        else if (evt->trgTyp & FAD::EventHeader::kExt2)
+            run.triggerCounter[6]++;
+        // other triggers
+        else
+            run.triggerCounter[7]++;
+
+        evt->triggerCounter = run.triggerCounter;
+
         if (!eventCheck(*evt))
         {

trunk/FACT++/src/EventBuilder.h

@@ -4 +4 @@
 #include "FAD.h"
 
+#include <list>
 #include <array>
 #include <forward_list>
+
 
 /* global variables; 
@@ -67 +69 @@
     FileStatus_t fileStat;
 
+    std::array<uint32_t, 8> triggerCounter;
+
     std::shared_ptr<DrsCalibration> calib;
     std::list<std::array<int16_t,1440>> prevStart; // History for start cells of previous events (for step calibration)
@@ -72 +76 @@
     RUN_CTRL2() : runId(-1), reportMem(0), lastTime(0), lastEvt(0), maxEvt(1<<31), fileStat(kFileNotYetOpen)
     {
+        triggerCounter.fill(0);
+
         // runId   = -1;
         // fileId  = kFileNotYetOpen;
@@ -123 +129 @@
     int closeRequest;
 
+    std::array<uint32_t, 8> triggerCounter;
+
     std::shared_ptr<RUN_CTRL2> runCtrl;
 

trunk/FACT++/src/EventBuilderWrapper.h

@@ -72 +72 @@
     DimDescribedService fDimRuns;
     DimDescribedService fDimEvents;
+    DimDescribedService fDimTrigger;
     DimDescribedService fDimRawData;
     DimDescribedService fDimEventData;
@@ -94 +95 @@
     Queue<tuple<Time,bool,FAD::EventHeader>>        fQueueProcHeader;
     Queue<pair<Time,array<uint32_t,4>>>             fQueueEvents;
+    Queue<tuple<Time,char,array<uint32_t,8>>>       fQueueTrigger;
     Queue<pair<Time,array<uint16_t,2>>>             fQueueRoi;
     Queue<vector<char>>                             fQueueRawData;
@@ -216 +218 @@
                                                            "Event counts"
                                                            "|evtsCount[int]:Num evts cur. run, total (all run), evt ID, trig. Num"),
+        fDimTrigger     ("FAD_CONTROL/TRIGGER_COUNTER",    "I:1;I:1;I:1;I:1;I:1;I:1;I:1;I:1",
+                                                           "Trigger counter"
+                                                           "|N_trg[uint32]:Number of physics triggers"
+                                                           "|N_ped[uint32]:Number of pure pedestal triggers"
+                                                           "|N_lpe[uint32]:Number of external light pulser triggers"
+                                                           "|N_tim[uint32]:Number of time calibration triggers"
+                                                           "|N_lpi[uint32]:Number of internal light pulser triggers"
+                                                           "|N_ext1[uint32]:Number of external triggers at input ext1"
+                                                           "|N_ext2[uint32]:Number of external triggers at input ext2"
+                                                           "|N_misc[uint32]:Number of all other triggers"),
         fDimRawData     ("FAD_CONTROL/RAW_DATA",           "S:1;S:1;I:1;I:1;S:1;I:1;I:2;I:40;S:1440;S:160;F",
                                                            "|roi[uint16]:number of samples per pixel"
@@ -279 +291 @@
         fQueueProcHeader( std::bind(&EventBuilderWrapper::procHeader,           this, placeholders::_1)),
         fQueueEvents(     std::bind(&EventBuilderWrapper::UpdateDimEvents,      this, placeholders::_1)),
+        fQueueTrigger(    std::bind(&EventBuilderWrapper::UpdateDimTrigger,     this, placeholders::_1)),
         fQueueRoi(        std::bind(&EventBuilderWrapper::UpdateDimRoi,         this, placeholders::_1)),
         fQueueRawData(    std::bind(&EventBuilderWrapper::UpdateDimRawData,     this, placeholders::_1)),
@@ -521 +534 @@
     }
 
+    bool UpdateDimTrigger(const tuple<Time,char,array<uint32_t,8>> &stat)
+    {
+        fDimTrigger.setQuality(get<1>(stat));
+        fDimTrigger.setData(get<2>(stat).data(), sizeof(uint32_t)*8);
+        fDimTrigger.Update(get<0>(stat));
+        return true;
+    }
+
     bool runOpen(const EVT_CTRL2 &evt)
     {
@@ -528 +549 @@
         // If there is still an open file: close it
         if (fFile)
-            runClose(*evt.runCtrl);
+            runClose(evt);
 
         // Keep a copy of the currently valid drs calibration
@@ -576 +597 @@
         fNumEvts[kTriggerId] = 0;
         fNumEvts[kCurrent]   = 0;
-        fQueueEvents.emplace(Time(), fNumEvts);
+
+        const Time time;
+
+        fQueueEvents.emplace(time, fNumEvts);
+        fQueueTrigger.emplace(time, 'o', evt.triggerCounter);
 
         ostringstream str;
@@ -604 +629 @@
         }*/
 
-        const EVENT &evt = *e.fEvent;
-        if (!fFile->WriteEvt(evt))
+        if (!fFile->WriteEvt(e))
             return false;
 
+        //const EVENT &evt = *e.fEvent;
+
         fNumEvts[kCurrent]++;
-        fNumEvts[kEventId]   = evt.EventNum;
-        fNumEvts[kTriggerId] = evt.TriggerNum;
+        fNumEvts[kEventId]   = e.evNum;//evt.EventNum;
+        fNumEvts[kTriggerId] = e.trgNum;//evt.TriggerNum;
         fNumEvts[kTotal]++;
 
@@ -618 +644 @@
         {
             fQueueEvents.emplace(newt, fNumEvts);
+            fQueueTrigger.emplace(newt, 'w', e.triggerCounter);
             oldt = newt;
         }
@@ -624 +651 @@
     }
 
-    void runClose(RUN_CTRL2 &run)
+    void runClose(const EVT_CTRL2 &evt)
     {
         if (!fFile)
@@ -635 +662 @@
 
         // Close the file
-        const bool rc = fFile->Close(NULL);
+        const bool rc = fFile->Close(evt);
 
         fLastClosed = fFile->GetRunId();
@@ -653 +680 @@
 
         // Time for update events before time for update runs
-        fQueueEvents.emplace(Time(), fNumEvts);
+        const Time time;
+
+        fQueueEvents.emplace(time, fNumEvts);
+        fQueueTrigger.emplace(time, 'c', evt.triggerCounter);
+
         UpdateRuns();
 
@@ -667 +698 @@
         // the memory will stay in scope until the end of its operation.
         const DrsCalibration &cal = DataCalib::GetCalibration();
+
+        RUN_CTRL2 &run = *evt.runCtrl;
         if (!run.calib || run.calib->fStep != cal.fStep || run.calib->fRoi!=cal.fRoi)
             run.calib = make_shared<DrsCalibration>(cal);
@@ -893 +926 @@
         }
 
-        fQueueTempRefClk.emplace(tm, clk, tmp);
-
         // check REFCLK_frequency
         // check consistency with command configuration
         // how to log errors?
         // need gotNewRun/closedRun to know it is finished
+
+        fQueueTempRefClk.emplace(tm, clk, tmp);
+
+        if (evt.runCtrl->fileStat == kFileClosed)
+        {
+            static Time oldt(boost::date_time::neg_infin);
+            if (tm>oldt+boost::posix_time::seconds(1))
+            {
+                fQueueTrigger.emplace(tm, 0, evt.runCtrl->triggerCounter);
+                oldt = tm;
+            }
+        }
 
         return true;
@@ -1399 +1442 @@
 }
 
-void runClose(RUN_CTRL2 &run)
+void runClose(const EVT_CTRL2 &evt)
 {
-    EventBuilderWrapper::This->runClose(run);
+    EventBuilderWrapper::This->runClose(evt);
 }