Introduced monitoring for cbm::algo::EventBuilder.

Monitoring data is included in cbm::algo::EventBuilder.

In keeping with the style of other algorithms, a struct with monitoring data is introduced, and a special "resultType" is introduced which combines the regular output with the monitoring information.

Accordingly, GTestEventBuilder was modified to extend the test coverage to the monitoring data. In passing the TRD support for this test was fixed.

Overall, I'm not super happy with the aesthetics of this code. The added blocks of the form

   monitor.fSts.fNum += ts.fData.fSts.fDigis.size();
   monitor.fRich.fNum += ts.fData.fRich.fDigis.size();
   monitor.fMuch.fNum += ts.fData.fMuch.fDigis.size();
...

seem a bit cluttery. The only solution that comes to my mind however, would be to use a std::map<ECbmModuleId,EventBuilderDetectorMonitorData> inside the monitor struct. I guess this is not an option, due to the requirement of the monitoring data to be light-weight.

Another issue is that, in places where one only wants to access the constructed events, but not the monitoring data, the most compact expression is something like

*fEvents = fAlgo(*fTimeslice, *fTriggers).first;

which is a bit contrived.

I chose to put the monitoring incrementation outside of the switch(ECbmModuleId) statement, again for aesthetic reasons. This can in principle lead to some unnecessary "increment by zero" operations. These will be negligible against "CopyRange()" however, and might even be optimized away by the compiler.

What is nice, is that the output could immediately be verified, by using the existing GTest.

@v.friese

algo/evbuild/EventBuilder.cxx

@@ -14,16 +14,30 @@ namespace cbm
   namespace algo
   {
     // --- Execution
-    std::vector<CbmDigiEvent> EventBuilder::operator()(const CbmDigiTimeslice& ts, const vector<double> triggers) const
+    EventBuilder::resultType EventBuilder::operator()(const CbmDigiTimeslice& ts, const vector<double> triggers) const
     {
-      vector<CbmDigiEvent> eventVec(triggers.size());
-      std::transform(triggers.begin(), triggers.end(), eventVec.begin(),
-                     [&ts, this](const double& trigger) { return BuildEvent(ts, trigger); });
-      return eventVec;
+      // --- Output data
+      resultType result = {};
+      result.first.resize(triggers.size());
+
+      std::transform(triggers.begin(), triggers.end(), result.first.begin(),
+                     [&ts, &result, this](const double& trigger) { return BuildEvent(ts, result.second, trigger); });
+
+      EventBuilderMonitorData& monitor = result.second;
+      monitor.fSts.fNum += ts.fData.fSts.fDigis.size();
+      monitor.fRich.fNum += ts.fData.fRich.fDigis.size();
+      monitor.fMuch.fNum += ts.fData.fMuch.fDigis.size();
+      monitor.fTrd.fNum += ts.fData.fTrd.fDigis.size();
+      monitor.fTrd2d.fNum += ts.fData.fTrd2d.fDigis.size();
+      monitor.fTof.fNum += ts.fData.fTof.fDigis.size();
+      monitor.fPsd.fNum += ts.fData.fPsd.fDigis.size();
+      monitor.fBmon.fNum += ts.fData.fT0.fDigis.size();
+      return result;
     }
 
     // --- Build a single event
-    CbmDigiEvent EventBuilder::BuildEvent(const CbmDigiTimeslice& ts, double trigger) const
+    CbmDigiEvent EventBuilder::BuildEvent(const CbmDigiTimeslice& ts, EventBuilderMonitorData& monitor,
+                                          double trigger) const
     {
       CbmDigiEvent event;
       event.fTime = trigger;
@@ -72,6 +86,14 @@ namespace cbm
           default: break;
         }
       }
+      monitor.fSts.fNumInEvents += event.fData.fSts.fDigis.size();
+      monitor.fRich.fNumInEvents += event.fData.fRich.fDigis.size();
+      monitor.fMuch.fNumInEvents += event.fData.fMuch.fDigis.size();
+      monitor.fTrd.fNumInEvents += event.fData.fTrd.fDigis.size();
+      monitor.fTrd2d.fNumInEvents += event.fData.fTrd2d.fDigis.size();
+      monitor.fTof.fNumInEvents += event.fData.fTof.fDigis.size();
+      monitor.fPsd.fNumInEvents += event.fData.fPsd.fDigis.size();
+      monitor.fBmon.fNumInEvents += event.fData.fT0.fDigis.size();
       return event;
     }
   }  // namespace algo