update cbm:algo copy of the unpack TRD2D to the new ascii parameters

format (imported from MR 1198)

algo/detectors/trd2d/Trd2dReadoutConfig.cxx

@@ -62,21 +62,6 @@ namespace cbm::algo
   }
   // ------------------------------------------------------------------------------------
 
-
-  // ---  Initialise the component mapping structure   ----------------------------------
-  void Trd2dReadoutConfig::InitComponentMap(const std::map<uint32_t, uint16_t[NCROBMOD]>& map)
-  {
-    // Receive map (moduleId, crobId) -> (equipId)
-    // Invert to obtain component map (equipId) -> (module iq, crob id)
-    for (auto& entry : map) {
-      uint16_t mod_id = entry.first;
-      for (uint8_t crob_id = 0; crob_id < NCROBMOD; crob_id++) {
-        uint16_t eq_id     = entry.second[crob_id];
-        fReadoutMap[eq_id] = std::make_pair(mod_id, crob_id);
-      }
-    }
-  }
-
   // ---  Initialise the mapping structure   --------------------------------------------
   void Trd2dReadoutConfig::InitChannelMap(
     const std::map<size_t, std::map<size_t, std::map<size_t, std::tuple<int32_t, bool, uint64_t>>>>& channelMap)

algo/detectors/trd2d/Trd2dReadoutConfig.h

@@ -80,9 +80,6 @@ namespace cbm::algo
     /** @brief Debug output of readout map **/
     std::string PrintReadoutMap();
 
-    /** @brief Initialisation of readout map **/
-    void InitComponentMap(const std::map<uint32_t, uint16_t[NCROBMOD]>& crob_map);
-
     /** @brief Initialisation of channel map **/
     void InitChannelMap(
       const std::map<size_t, std::map<size_t, std::map<size_t, std::tuple<int32_t, bool, uint64_t>>>>& channelMap);

core/detectors/trd/CbmTrdParSet.cxx

@@ -29,7 +29,7 @@ CbmTrdParSet::CbmTrdParSet(const char* name, const char* title, const char* cont
 CbmTrdParSet::~CbmTrdParSet()
 {
   for (map<Int_t, CbmTrdParMod*>::iterator imod = fModuleMap.begin(); imod != fModuleMap.end(); imod++)
-    delete imod->second;
+    if (imod->second) delete imod->second;
   fModuleMap.clear();
 }
 

reco/tasks/CbmTaskUnpack.cxx

@@ -12,6 +12,7 @@
 #include "CbmDigiTimeslice.h"
 #include "CbmSourceTs.h"
 #include "CbmTrdParFasp.h"
+#include "CbmTrdParModAsic.h"
 #include "CbmTrdParModDigi.h"
 #include "CbmTrdParSetAsic.h"
 #include "CbmTrdParSetDigi.h"
@@ -166,83 +167,52 @@ cbm::algo::Trd2dReadoutConfig CbmTaskUnpack::InitTrd2dReadoutConfig()
   if (asciiInput.open(asicparfile.data())) { asicparset.init(&asciiInput); }
   asciiInput.close();
 
-  // Initialize map (moduleId, crobId) -> (equipId) explicitly
-  std::map<uint32_t, uint16_t[NCROBMOD]> crob_map;
-  uint16_t cmap[] = {0xffc2, 0xffc5, 0xffc1, 0, 0};        // "crob map 22" for run Id >= 2335
-  memcpy(crob_map[5], cmap, NCROBMOD * sizeof(uint16_t));  // only module Id 5 is used!
-
-  // Then pass to Trd2dReadoutConfig, will invert to obain map (equipId) -> (module iq, crob id)
-  Trd2dConfig.InitComponentMap(crob_map);
-
-  // FASP mapping update wrt the default setting (optional)
-  std::map<uint32_t, uint8_t[NFASPMOD]> fasp_map;
-
-  {  // Initialize the "fasp remapping"
-    // Hard coded for run Id >= 2335 (only module Id 5).
-    uint8_t map[NFASPMOD];
-    for (uint32_t i(0); i < NFASPMOD; i++) {
-      map[i] = i;
-    }
-    const size_t nfasp0 = 72;
-    const size_t nfasps = 36;
-    uint8_t map22[]     = {
-      84,  85,  86,  87,  88,  89,   // FEB14/0xffc1
-      90,  91,  92,  93,  94,  95,   // FEB17/0xffc1
-      96,  97,  98,  99,  100, 101,  // FEB18/0xffc1
-      102, 103, 104, 105, 106, 107,  // FEB16/0xffc1
-      72,  73,  74,  75,  76,  77,   // FEB9/0xffc1
-      78,  79,  80,  81,  82,  83    // FEB8/0xffc1
-    };
-    for (uint32_t i(0); i < nfasps; i++) {
-      map[i + nfasp0] = map22[i];
-    }
-    memcpy(fasp_map[5], map, NFASPMOD * sizeof(uint8_t));
-  }
-
-  // Map (equipId, asicId, chanId) -> (pad address, R pairing flag, daq offset)
+  // Map (moduleId) -> (array of crobId)
+  std::map<uint32_t, uint16_t[NCROBMOD]> crobMap;
+  // Map (equipId, asicId, chanId) -> (pad address, mask flag, daq offset [FASP clk])
   std::map<size_t, std::map<size_t, std::map<size_t, std::tuple<int32_t, bool, uint64_t>>>> channelMap;
 
   // Loop through a list of module IDs from the .digi file (can in principle contradict crob_map).
   for (auto entry : digiparset.GetModuleMap()) {
 
     const auto moduleId = entry.first;
-    if (crob_map.find(moduleId) == crob_map.end()) { continue; }  //skip if no entry in crob_map
 
     // Get ASIC parameters for this module
-    const CbmTrdParSetAsic* setDet = static_cast<const CbmTrdParSetAsic*>(asicparset.GetModuleSet(moduleId));
+    CbmTrdParModAsic* setDet = static_cast<CbmTrdParModAsic*>(asicparset.GetModulePar(moduleId));
     if (!setDet) continue;
-    if (setDet->GetAsicType() != int32_t(CbmTrdDigi::eCbmTrdAsicType::kFASP)) continue;
+    if (setDet->GetAsicType() != CbmTrdDigi::eCbmTrdAsicType::kFASP) continue;
+    auto digipar = entry.second;
+
+    const int* crobs = setDet->GetCrobAddresses();
+    for (int icrob(0); icrob < NCROBMOD; icrob++)
+      crobMap[moduleId][icrob] = crobs[icrob];
 
     // Loop through ASICs for this module
     std::vector<int32_t> addresses;
     setDet->GetAsicAddresses(&addresses);
     for (auto add : addresses) {
-
       //Get local IDs for this component / equipment.
       const int32_t fasp_in_mod = add - 1000 * moduleId;
       const int32_t fasp_in_eq  = fasp_in_mod % (NFASPCROB);
       const int32_t crob_in_mod = fasp_in_mod / (NFASPCROB);
-      const uint16_t eq_id      = crob_map[moduleId][crob_in_mod];
-
-      // Apply FASP remapping (optional)
-      const int32_t add_remap = fasp_map[moduleId][fasp_in_mod];
-      add                     = add_remap + 1000 * moduleId;
+      const uint16_t eq_id      = crobMap[moduleId][crob_in_mod];
 
       // ASIC parameter set
-      CbmTrdParFasp* fasppar = (CbmTrdParFasp*) setDet->GetModulePar(add);
+      CbmTrdParFasp* fasppar = (CbmTrdParFasp*) setDet->GetAsicPar(add);
 
       // Loop through channels for this ASIC and fill map
-      for (size_t chan = 0; chan < fasppar->GetNchannels(); chan++) {
-        const int32_t pad              = fasppar->GetPadAddress(chan);
-        const bool hasPairingR         = fasppar->GetChannel(chan)->HasPairingR();
-        const CbmTrdParModDigi* modpar = (CbmTrdParModDigi*) digiparset.GetModulePar(moduleId);
-        uint64_t daq_offset            = 0;
-        if (modpar->GetPadRow(pad) % 2 == 0) daq_offset = 3;
-        channelMap[eq_id][fasp_in_eq][chan] = std::make_tuple(pad, hasPairingR, daq_offset);
+      for (int chan = 0; chan < fasppar->GetNchannels(); chan++) {
+        const CbmTrdParFaspChannel* faspch = fasppar->GetChannel(chan);
+        const int32_t pad                  = fasppar->GetPadAddress(chan) * (faspch->HasPairingR() ? 1 : -1);
+        const bool isMasked                = faspch->IsMasked();
+        uint64_t daq_offset                = 0;
+        if (((CbmTrdParModDigi*) digipar)->GetPadRow(pad) % 2 == 0) daq_offset = 3;
+        channelMap[eq_id][fasp_in_eq][chan] = std::make_tuple(pad, isMasked, daq_offset);
       }
     }
   }
 
+  Trd2dConfig.InitComponentMap(crobMap);
   Trd2dConfig.InitChannelMap(channelMap);
   return Trd2dConfig;
 }
@@ -308,5 +278,4 @@ cbm::algo::TrdReadoutConfig CbmTaskUnpack::InitTrdReadoutConfig()
   return TrdConfig;
 }
 
-
 ClassImp(CbmTaskUnpack)