finalize absorbtion of CROB mapping in the setup parameters

core/detectors/trd/CbmTrdParModAsic.cxx

@@ -39,7 +39,8 @@ CbmTrdParModAsic::CbmTrdParModAsic(const char* name, const char* title)
 //_______________________________________________________________________________
 void CbmTrdParModAsic::clear()
 {
-  for(auto asic : fModPar) delete asic.second;
+  for (auto asic : fModPar)
+    delete asic.second;
   fModPar.clear();
 }
 
@@ -62,7 +63,8 @@ void CbmTrdParModAsic::GetAsicAddresses(std::vector<Int_t>* a) const
   /** Query the ASICs in the module set for their addresses. 
  * Returns the list of these addresses in the vector prepared by the user   
  */
-  for (auto asic : fModPar) a->push_back(asic.first);
+  for (auto asic : fModPar)
+    a->push_back(asic.first);
 }
 
 //_______________________________________________________________________________
@@ -83,18 +85,12 @@ CbmTrdParAsic* CbmTrdParModAsic::GetAsicPar(Int_t address)
 int CbmTrdParModAsic::GetNofAsics() const
 {
   switch (fType) {
-    case 1:
-      return 80;
-    case 3:
-      return 20;
-    case 5:
-      return 180;
-    case 7:
-      return 36;
-    case 8:
-      return 24;
-    case 9:
-      return 180;
+    case 1: return 80;
+    case 3: return 20;
+    case 5: return 180;
+    case 7: return 36;
+    case 8: return 24;
+    case 9: return 180;
     default:
       LOG(warn) << GetName() << "::GetNofAsics : The chamber type " << fType << " has no mapping to ASICs. Skip.";
   }
@@ -109,22 +105,32 @@ CbmTrdDigi::eCbmTrdAsicType CbmTrdParModAsic::GetAsicType() const
     case 3:
     case 5:
     case 7:
-    case 8:
-      return CbmTrdDigi::eCbmTrdAsicType::kSPADIC;
-    case 9:
-      return CbmTrdDigi::eCbmTrdAsicType::kFASP;
+    case 8: return CbmTrdDigi::eCbmTrdAsicType::kSPADIC;
+    case 9: return CbmTrdDigi::eCbmTrdAsicType::kFASP;
     default:
       LOG(warn) << GetName() << "::GetAsicType : The chamber type " << fType << " has no mapping to ASICs. Skip.";
   }
   return CbmTrdDigi::eCbmTrdAsicType::kNTypes;
 }
 
+//_______________________________________________________________________________
+int CbmTrdParModAsic::HasEqId(uint16_t eq) const
+{
+  int idx(0);
+  for (auto add : fCrobAdd) {
+    if (add == eq) return idx;
+    idx++;
+  }
+  return -1;
+}
+
 //_______________________________________________________________________________
 void CbmTrdParModAsic::Print(Option_t* opt) const
 {
   printf(" %s Asics[%d]\n", GetName(), GetNofAsics());
   if (strcmp(opt, "all") == 0) {
-    for (auto asic : fModPar) asic.second->Print(opt);
+    for (auto asic : fModPar)
+      asic.second->Print(opt);
   }
 }
 
@@ -148,11 +154,10 @@ void CbmTrdParModAsic::SetCrobAddresses(int* addresses)
     case 3:
     case 5:
     case 7:
-    case 8:
-      fCrobAdd[0] = addresses[0];
-      break;
+    case 8: fCrobAdd.push_back(addresses[0]); break;
     case 9:
-      for (int i(0); i < NCROBMOD; i++) fCrobAdd[i] = addresses[i];
+      for (int i(0); i < NCROBMOD; i++)
+        fCrobAdd.push_back(addresses[i]);
       break;
     default:
       LOG(warn) << GetName() << "::SetCrobAddresses : The chamber type " << fType << " has no mapping to CROBs. Skip.";

core/detectors/trd/CbmTrdParModAsic.h

@@ -28,6 +28,7 @@ class FairParamList;
   **/
 class CbmTrdParModAsic : public CbmTrdParMod {
   friend class CbmTrdParSetAsic;
+
 public:
   /** Standard constructor **/
   CbmTrdParModAsic(const char* name = "CbmTrdParModAsic", const char* title = "Generic list of ASICs for TRD modules");
@@ -71,6 +72,11 @@ public:
   /** \brief Query the type of chamber*/
   virtual const int* GetCrobAddresses() const { return fCrobAdd.data(); }
 
+  /** \brief Query the existence of an equipment (CROB) by HW id on the current module params.
+   * \return Returns the position of the equipment (CROB) on the current module; -1 in case of failure.  
+   */
+  virtual int HasEqId(uint16_t eqid) const;
+
   /** \brief Returns the number of INSTALLED ASICs for the current module
    * It applies to the list of ASICs.
    */

core/detectors/trd/CbmTrdParSetAsic.cxx

@@ -34,6 +34,18 @@ CbmTrdParSetAsic::CbmTrdParSetAsic(const char* name, const char* title, const ch
 {
 }
 
+//_______________________________________________________________________________
+int CbmTrdParSetAsic::FindModuleByEqId(uint16_t eqid, uint8_t& crob_id) const
+{
+  for (auto mod : fModuleMap) {
+    int crob = ((const CbmTrdParModAsic*) mod.second)->HasEqId(eqid);
+    if (crob < 0) continue;
+    crob_id = crob;
+    return mod.first;
+  }
+  return -1;
+}
+
 //_______________________________________________________________________________
 Bool_t CbmTrdParSetAsic::getParams(FairParamList* l)
 {
@@ -58,16 +70,17 @@ Bool_t CbmTrdParSetAsic::getParams(FairParamList* l)
   for (Int_t i = 0; i < fNrOfModules; i++) {
     mod = new CbmTrdParModAsic(GetName(), Form("%s for Module %d", GetTitle(), moduleId[i]));
     mod->SetChamberType(typeAsic[i]);
+    mod->SetModuleId(moduleId[i]);
     // only for FASP
     if (9 == typeAsic[i]) {
-      TArrayI crobAddress(NCROBMOD);
+      TArrayI crobAddress(int(NCROBMOD));
       if (!l->fill(Form("CrobInfo - Module %d", moduleId[i]), &crobAddress)) continue;
       mod->SetCrobAddresses(crobAddress.GetArray());
-      Int_t maxValues = maxNrAsics * (NFASPPARS);
+      Int_t maxValues = maxNrAsics * int(NFASPPARS);
       TArrayI values(maxValues);
       if (!l->fill(Form("FaspInfo - Module %d", moduleId[i]), &values)) continue;
       for (Int_t iasic = 0; iasic < nAsic[i]; iasic++) {
-        Int_t offset = iasic * (NFASPPARS);
+        Int_t offset = iasic * int(NFASPPARS);
         address      = values[offset++];
         if (address == moduleId[i] * 1000 + 999) continue;
         asic         = new CbmTrdParFasp(address);
@@ -159,15 +172,15 @@ void CbmTrdParSetAsic::putParams(FairParamList* l)
       l->add(Form("SpadicInfo - Module %d", mapEntry.first), asicInfo);
     }
     if (mod->GetAsicType() == CbmTrdDigi::eCbmTrdAsicType::kFASP) {
-      TArrayI crobAddress(NCROBMOD);
-      crobAddress.Set(NCROBMOD, mod->GetCrobAddresses());
+      TArrayI crobAddress(int(NCROBMOD));
+      crobAddress.Set(int(NCROBMOD), mod->GetCrobAddresses());
       l->add(Form("CrobInfo - Module %d", mapEntry.first), crobAddress);
-      Int_t fullSize = nAsic[idx] * NFASPPARS;
+      int fullSize = nAsic[idx] * int(NFASPPARS);
       TArrayI asicInfo(fullSize);
 
       iAsicNr = 0;
       for (auto iModuleIt : mod->fModPar) {
-        int offset         = iAsicNr * NFASPPARS;
+        int offset         = iAsicNr * int(NFASPPARS);
         asicInfo[offset++] = iModuleIt.first;
 
         CbmTrdParFasp* fasp = (CbmTrdParFasp*) iModuleIt.second;

core/detectors/trd/CbmTrdParSetAsic.h

@@ -37,6 +37,12 @@ public:
   /** \brief Reset all parameters **/
   virtual void clear() { ; }
 
+  /** \brief Search for the module in the setup parameters by equipement id 
+   * \param[in] eqid equipment id from HW
+   * \param[out] crob_id index of crob on the module
+   * \return module id in the setup
+   */
+  virtual int FindModuleByEqId(uint16_t eqid, uint8_t& crob_id) const;
   /** \brief Build the ASICs par for the current module from the info stored in the param file 
    * It applies to the list of ASICs.
    * \param module ASICs par (FASP or SPADIC)

reco/detectors/trd/unpack/CbmTrdUnpackFaspAlgo.cxx

@@ -52,27 +52,21 @@ CbmTrdUnpackFaspAlgo::~CbmTrdUnpackFaspAlgo() {}
 //_________________________________________________________________________________
 Bool_t CbmTrdUnpackFaspAlgo::initParSet(FairParGenericSet* parset)
 {
-  Int_t nModules(0);
+  Int_t nModules(0), nAsics(0);
   if (strcmp(parset->ClassName(), "CbmTrdParSetAsic") == 0) {
     CbmTrdParSetAsic* setPar = static_cast<CbmTrdParSetAsic*>(parset);
     for (auto did : fModuleId) {
-      auto setDet = static_cast<const CbmTrdParModAsic*>(setPar->GetModulePar(did));
+      auto setDet = static_cast<CbmTrdParModAsic*>(setPar->GetModulePar(did));
       if (!setDet) continue;
       if (setDet->GetAsicType() != CbmTrdDigi::eCbmTrdAsicType::kFASP) continue;
       if (fMonitor) fMonitor->addParam(did, setDet);
+      fAsicSet.addParam(setDet);
+      nAsics += setDet->GetNofAsicsOnModule();
       nModules++;
-      std::vector<Int_t> a;
-      setDet->GetAsicAddresses(&a);
-      for (auto add : a) {
-        CbmTrdParAsic* asic = (CbmTrdParAsic*) setDet->GetAsicPar(add);
-        if (asic->IsA() == CbmTrdParSpadic::Class()) continue;
-        fAsicSet.addParam(asic);
-        if (VERBOSE > 2) asic->Print();
     }
-    }
-    //      setPar->printParams();
+    // fAsicSet.printParams();
     LOG(info) << GetName() << "::initParSet - for container " << parset->ClassName() << " modules " << nModules
-              << " asics " << fAsicSet.GetNrOfModules();
+              << " asics " << nAsics;
   }
   else if (strcmp(parset->ClassName(), "CbmTrdParSetDigi") == 0) {
     fDigiSet                          = static_cast<CbmTrdParSetDigi*>(parset);
@@ -128,21 +122,6 @@ CbmTrdUnpackFaspAlgo::GetParContainerRequest(std::string geoTag, std::uint32_t r
   return &fParContVec;
 }
 
-//_________________________________________________________________________________
-void CbmTrdUnpackFaspAlgo::SetCrobMapping(const std::map<uint32_t, uint16_t[NCROBMOD]>& map)
-{
-  if (fCompMap) delete fCompMap;
-  fCompMap = new std::map<uint16_t, std::pair<uint16_t, uint16_t>>;  /// map eq_id -> (mod_id, 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];
-      (*fCompMap)[eq_id] = std::make_pair(mod_id, crob_id);
-    }
-  }
-}
-
 //_________________________________________________________________________________
 CbmTrdUnpackFaspAlgo::CbmTrdFaspMessageType CbmTrdUnpackFaspAlgo::mess_type(uint32_t wd)
 {
@@ -304,8 +283,8 @@ uint32_t CbmTrdUnpackFaspAlgo::ResetTimeslice()
   for (auto pad_id(0); pad_id < NFASPMOD * NFASPCH; pad_id++) {
     if (!fDigiBuffer[pad_id].size()) continue;
 
-    LOG(warn) << fName << "::ResetTimeslice - buffered digi @ CROB=" << fCrob << " / pad=" << pad_id << " store "
-              << fDigiBuffer[pad_id].size() << " unprocessed digi.";
+    LOG(warn) << fName << "::ResetTimeslice - buffered digi pad=" << pad_id << " store " << fDigiBuffer[pad_id].size()
+              << " unprocessed digi.";
     uNbLostDigis += fDigiBuffer[pad_id].size();
 
     fDigiBuffer[pad_id].clear();
@@ -337,11 +316,9 @@ void CbmTrdUnpackFaspAlgo::FinalizeComponent()
     // clear digi buffer wrt the digi which was forwarded to higher structures
     fDigiBuffer[ipad].clear();
     if (nIncomplete > 2) {
-      LOG(warn) << fName << "FinalizeComponent(" << fCrob << ") skip " << nIncomplete << " incomplete digi at pad "
-                << ipad << ".\n";
+      LOG(warn) << fName << "FinalizeComponent() skip " << nIncomplete << " incomplete digi at pad " << ipad << ".\n";
     }
   }
-  fCrob = 0xffff;  // reset current crob id
 }
 
 // ----unpack----
@@ -362,16 +339,9 @@ bool CbmTrdUnpackFaspAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp
   fTime = ULong64_t((msdesc.idx - fTsStartTime - fSystemTimeOffset) / 12.5);
 
   // get MOD_id and CROB id from the equipment, using the comp map: eq_id -> (mod_id, crob_id)
+  uint8_t crob_id(0);
   const uint16_t eq_id = msdesc.eq_id;
-  const auto it        = fCompMap->find(eq_id);
-  if (it == fCompMap->end() || std::find(fModuleId.begin(), fModuleId.end(), it->second.first) == fModuleId.end()) {
-    LOG(error) << GetName() << "::unpack - CROB eq_id=" << eq_id << " not registered in the unpacker.";
-    return false;
-  }
-  const uint16_t mod_id = (*fCompMap)[eq_id].first;
-  const uint8_t crob_id = (*fCompMap)[eq_id].second;
-
-  if (fCrob == 0xffff) fCrob = icomp;
+  uint16_t mod_id      = fAsicSet.FindModuleByEqId(eq_id, crob_id);
 
   // Get the µslice size in bytes to calculate the number of completed words
   auto mssize = msdesc.size;

reco/detectors/trd/unpack/CbmTrdUnpackFaspAlgo.h

@@ -113,9 +113,6 @@ public:
   */
   virtual std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>*
   GetParContainerRequest(std::string geoTag, std::uint32_t runId);
-
-  /** @brief Initialize CROB mapping for all modules*/
-  void SetCrobMapping(const std::map<uint32_t, uint16_t[NCROBMOD]>& map);
   /** @brief Set a predefined monitor 
    *  @param monitor predefined unpacking monitor */
   void SetMonitor(std::shared_ptr<CbmTrdUnpackFaspMonitor> monitor) { fMonitor = monitor; }
@@ -205,7 +202,6 @@ private:
     {}};  ///> Buffered digi for each pad in CROB component
   /** @brief Potential (online) monitor for the unpacking process */
   std::shared_ptr<CbmTrdUnpackFaspMonitor> fMonitor = nullptr;
-  uint16_t fCrob                                    = 0xffff;  //! current crob being processed
   std::vector<uint16_t> fModuleId = {};  ///> list of modules for which there is are calibration parameters
   CbmTrdParSetAsic fAsicSet;
   CbmTrdParSetDigi* fDigiSet = nullptr;

reco/detectors/trd/unpack/CbmTrdUnpackFaspConfig.cxx

@@ -42,7 +42,6 @@ void CbmTrdUnpackFaspConfig::reset()
 void CbmTrdUnpackFaspConfig::InitAlgo()
 {
   if (fDoLog) LOG(info) << fName << "::InitAlgo - Setup Fasp mapping";
-  fAlgo->SetCrobMapping(fCrobMap);
 
   // If we have a monitor in the config add it to the algo
   if (fMonitor) fAlgo->SetMonitor(fMonitor);
@@ -58,10 +57,4 @@ void CbmTrdUnpackFaspConfig::InitAlgo()
   }
 }
 
-//_____________________________________________________________________
-void CbmTrdUnpackFaspConfig::SetCrobMapping(int modAddress, uint16_t crobMap[NCROBMOD])
-{
-  memcpy(fCrobMap[modAddress], crobMap, NCROBMOD * sizeof(uint16_t));
-}
-
 ClassImp(CbmTrdUnpackFaspConfig)

reco/detectors/trd/unpack/CbmTrdUnpackFaspConfig.h

@@ -64,12 +64,6 @@ public:
   /** @brief Initialize the algorithm, include all calibration for Trd FASP.*/
   void InitAlgo();
 
-  /** @brief define crob id mapping for each module
-   * @param modAddress module address according to geometry
-   * @param crobMap mapped ids of CROBs eq_id for module
-   */
-  void SetCrobMapping(int modAddress, uint16_t crobMap[NFASPMOD]);
-
   /** @brief Add a monitor to the unpacker.
    *  @param value CbmTrdUnpackFaspMonitor */
   void SetMonitor(std::shared_ptr<CbmTrdUnpackFaspMonitor> value) { fMonitor = value; }
@@ -86,7 +80,6 @@ protected:
   virtual void reset();
 
 private:
-  std::map<uint32_t, uint16_t[NCROBMOD]> fCrobMap;  ///> Module address to CROB id mapping
   /** @brief pointer to the monitor object */
   std::shared_ptr<CbmTrdUnpackFaspMonitor> fMonitor = nullptr;