mvd/ReadoutConfig.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 IKF Frankfurt University, Frankfurt am Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Ajit Kumar [committer] */
 
#include "ReadoutConfig.h"
 
#include "AlgoFairloggerCompat.h"
 
#include <bitset>
#include <iostream>
#include <unordered_set>
 
using namespace std;
 
CBM_YAML_INSTANTIATE(cbm::algo::mvd::ReadoutSetup);
 
namespace cbm::algo::mvd
{
  // ---  Constructor  ------------------------------------------------------------------
  ReadoutConfig::ReadoutConfig() { InitHardcoded(); }
  // ------------------------------------------------------------------------------------
 
  // ---  Constructor with data from YAML file -------------------------------------------
  ReadoutConfig::ReadoutConfig(const ReadoutSetup& config) { Init(config); }
  // ------------------------------------------------------------------------------------
 
  // ---   Equipment IDs   --------------------------------------------------------------
  std::vector<uint16_t> ReadoutConfig::GetEquipmentIds()
  {
    std::vector<uint16_t> result;
    for (auto& entry : fReadoutMap)
      result.push_back(entry.first);
    return result;
  }
  // ------------------------------------------------------------------------------------
 
  // ---   Number of elinks for a component / equipment   -------------------------------
  size_t ReadoutConfig::GetNumElinks(uint16_t equipmentId)
  {
    size_t result = 0;
    auto it       = fReadoutMap.find(equipmentId);
    if (it != fReadoutMap.end()) result = fReadoutMap[equipmentId].size();
    return result;
  }
  // ------------------------------------------------------------------------------------
 
  // ---  Mapping (equimentId, elink) -> address[channel]  ------------------------------
  std::vector<uint32_t> ReadoutConfig::Map(uint16_t equipmentId, uint16_t elinkId)
  {
    std::vector<uint32_t> result;
    auto equipIter = fReadoutMap.find(equipmentId);
    if (equipIter != fReadoutMap.end()) {
      if (elinkId < equipIter->second.size()) {
        result = equipIter->second.at(elinkId);
      }
    }
    return result;
  }
  // ------------------------------------------------------------------------------------
 
  // ---  Mapping (equimentId, elink) -> (vector of mask flags)  ------------------------
  std::vector<uint8_t> ReadoutConfig::MaskMap(uint16_t equipmentId, uint16_t elinkId)
  {
    std::vector<uint8_t> result;
    auto equipIter = fMaskMap.find(equipmentId);
    if (equipIter != fMaskMap.end()) {
      auto elinkMap  = equipIter->second;
      auto elinkIter = elinkMap.find(elinkId);
      if (elinkIter != elinkMap.end()) {
        result = elinkIter->second;
      }
    }
    return result;
  }
  // ------------------------------------------------------------------------------------
 
  void ReadoutConfig::Init(const ReadoutSetup& pars)
  {
    fTimeOffset      = pars.timeOffset;
    fulFrameLengthNs = pars.frameLengthNs;
 
    for (auto& comp : pars.components) {
      fReadoutMap[comp.first].resize(comp.second.crobs.size());
      for (size_t crob_idx = 0; crob_idx < comp.second.crobs.size(); ++crob_idx) {
        fReadoutMap[comp.first][crob_idx].insert(fReadoutMap[comp.first][crob_idx].end(),
                                                 comp.second.crobs[crob_idx].sensorAddress.begin(),
                                                 comp.second.crobs[crob_idx].sensorAddress.end());
      }
    }
  }
 
  // ------------------------------------------------------------------------------------
 
  void ReadoutConfig::InitHardcoded()
  {
    // This here refers to the mCBM 2025 setup.
 
    // Array to hold the unique IDs (equipment ID) for all MVD DPBs
    uint16_t eqId[numComp] = {0x0000, 0x0001};
 
    // Constructing the map (equipmentId, eLink, channel) -> (MVD address)
    uint16_t numElinksPerComp = numCrobPerComp * numElinksPerCrob;
 
    std::cout << " ------------- " << numComp << " " << numCrobPerComp << " " << numElinksPerCrob << std::endl;
 
    for (uint16_t comp = 0; comp < numComp; comp++) {
      uint16_t equipment = eqId[comp];
      fReadoutMap[equipment].resize(numCrobPerComp);
      for (uint16_t crob = 0; crob < numCrobPerComp; crob++) {
        fReadoutMap[equipment][crob].resize(numElinksPerCrob);
        for (uint16_t elink = 0; elink < numElinksPerCrob; elink++) {
          L_(debug) << " comp id " << comp << " equipment " << equipment << " crob " << crob << " elink " << elink
                    << " number of elinks per crob " << numElinksPerComp << std::endl;
          // fReadoutMap[equipment][elink].resize(numChanPerAsic);
          // uint16_t elinkId   = numElinksPerCrob * crob + elink;    // elink within component
 
          // Skip unconnected FEB slots
        }  //# elink
      }    //# CROB
    }      //# component
  }
 
 
}  // namespace cbm::algo::mvd