Added support for CROB-wise time offset to BMON unpacker parameters.

algo/detectors/bmon/ReadoutConfig.cxx

@@ -61,6 +61,22 @@ namespace cbm::algo::bmon
   }
   // ------------------------------------------------------------------------------------
 
+
+  // ---  Mapping (equimentId, elink) -> time offset  -------------------------------------
+  int64_t ReadoutConfig::TimeOffsetMap(uint16_t equipmentId, uint16_t elinkId)
+  {
+    int64_t result = 0;
+    auto equipIter = fTimeOffsetMap.find(equipmentId);
+    if (equipIter != fTimeOffsetMap.end()) {
+      if (elinkId < equipIter->second.size()) {
+        result = equipIter->second.at(elinkId);
+      }
+    }
+    return result;
+  }
+  // ------------------------------------------------------------------------------------
+
+
   void ReadoutConfig::Init(const ReadoutSetup& pars)
   {
     // Constructing the map (equipmentId, eLink, channel) -> (TOF address)
@@ -73,10 +89,14 @@ namespace cbm::algo::bmon
 
       uint16_t equipment = pars.eqIds.at(comp);
       fReadoutMap[equipment].resize(pars.NElinksPerComponent());
+      fTimeOffsetMap[equipment].resize(pars.NElinksPerComponent());
 
       for (uint16_t elink = 0; elink < pars.NElinksPerComponent(); elink++) {
         fReadoutMap[equipment][elink].resize(pars.nChannelsPerAsic);
 
+        const uint32_t crob              = elink / pars.NElinksPerCrob() + comp * pars.NCrobsPerComponent();
+        fTimeOffsetMap[equipment][elink] = pars.crobs[crob].timeOffset;
+
         for (uint16_t channel = 0; channel < pars.nChannelsPerAsic; channel++) {
 
           const uint32_t chanInComp = elink * pars.nChannelsPerAsic + channel;

algo/detectors/bmon/ReadoutConfig.h

@@ -23,12 +23,14 @@ namespace cbm::algo::bmon
       i32 rpcType;
       i32 rpcSide;
       i32 nRPC;
+      i64 timeOffset;
 
       CBM_YAML_PROPERTIES(
         yaml::Property(&CROB::moduleId, "moduleId", "Unique ID of module the CROB resides in"),
         yaml::Property(&CROB::rpcType, "rpcType", "add explanation."),
         yaml::Property(&CROB::rpcSide, "rpcSide", "add explanation."),
-        yaml::Property(&CROB::nRPC, "nRPC", "number of RPCs."));
+        yaml::Property(&CROB::nRPC, "nRPC", "number of RPCs."),
+	yaml::Property(&CROB::timeOffset, "timeOffset", "time offset for CROB"));
     };
 
     i32 nFebsPerComponent;
@@ -52,6 +54,7 @@ namespace cbm::algo::bmon
     i32 NChansPerComponent() const { return nChannelsPerAsic * NElinksPerComponent(); }
     i32 NElinksPerCrob() const { return nAsicsPerFeb * NFebsPerCrob(); }
     i32 NElinksPerComponent() const { return NElinksPerCrob() * nCrobPerComponent; }
+    i32 NCrobsPerComponent() const { return nCrobPerComponent; }
 
     bool CheckBmonComp(uint32_t uCompId) const { return ((uCompId & 0xFFF0) == 0xABF0); }
     bool CheckInnerComp(uint32_t uCompId) const { return ((uCompId & 0xFFF0) == 0xBBC0); }
@@ -85,7 +88,18 @@ namespace cbm::algo::bmon
      */
     std::vector<uint32_t> Map(uint16_t equipId, uint16_t elink);
 
+    /** @brief API: Mapping from component and elink to time offset
+     ** @param equipId     Equipment identifier (component)
+     ** @param elink       Elink number within component
+     ** @return Time Offset
+     */
+    int64_t TimeOffsetMap(uint16_t equipId, uint16_t elink);
+
    private:
+    // --- Bmon elink time offsets
+    // --- Map index: (equipment, elink), map value: (time offset)
+    std::map<uint16_t, std::vector<uint64_t>> fTimeOffsetMap = {};
+
     // --- Bmon readout map
     // --- Map index: (equipment, elink, channel), map value: (TOF address)
     std::map<uint16_t, std::vector<std::vector<uint32_t>>> fReadoutMap = {};

algo/detectors/bmon/Unpack.cxx

@@ -11,8 +11,7 @@ using fles::Subsystem;
 
 Unpack::Unpack(const ReadoutConfig& readout) : fReadout(readout)
 {
-  constexpr i64 SystemTimeOffset = 0;
-  constexpr u8 SystemVersion     = 0x00;
+  constexpr u8 SystemVersion = 0x00;
 
   // Create one algorithm per component for Bmon and configure it with parameters
   auto equipIdsBmon = fReadout.GetEquipmentIds();
@@ -21,8 +20,8 @@ Unpack::Unpack(const ReadoutConfig& readout) : fReadout(readout)
     const size_t numElinks = fReadout.GetNumElinks(equip);
     for (size_t elink = 0; elink < numElinks; elink++) {
       bmon::UnpackElinkPar elinkPar;
-      elinkPar.fChannelUId = fReadout.Map(equip, elink);  // Vector of Bmon addresses for this elink
-      elinkPar.fTimeOffset = SystemTimeOffset;
+      elinkPar.fChannelUId = fReadout.Map(equip, elink);            // Vector of Bmon addresses for this elink
+      elinkPar.fTimeOffset = fReadout.TimeOffsetMap(equip, elink);  // Time offset for this elink
       par.fElinkParams.push_back(elinkPar);
     }
     auto algo                      = std::make_unique<UnpackMS>(par);