much/ReadoutConfig.h

Go to the documentation of this file.

/* Copyright (C) 2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Dominik Smith [committer] */
 
#ifndef ALGO_DETECTORS_MUCH_READOUTCONFIG_H
#define ALGO_DETECTORS_MUCH_READOUTCONFIG_H
 
#include "CbmYaml.h"
 
#include <cstddef>
#include <cstdint>
#include <map>
#include <vector>
 
namespace cbm::algo::much
{
  struct ReadoutSetup {
    struct Component {
      uint16_t equipmentId;
      bool active;
 
      CBM_YAML_PROPERTIES(
        yaml::Property(&Component::equipmentId, "equipmentId",
                         "Equipment ID of component. Written to the data stream (MicrosliceDescriptor).", YAML::Hex),
        yaml::Property(&Component::active, "active", "Active/Inactive flag per component (Unused for now)"));
    };
 
    struct FebsIds {
      std::vector<int16_t> febsGemA;
      std::vector<int16_t> febsGemB;
      std::vector<int16_t> febsRpc;
 
      CBM_YAML_PROPERTIES(
        yaml::Property(&FebsIds::febsGemA, "febsGemA", "Mapping of FEBs IDs for GEM A"),
        yaml::Property(&FebsIds::febsGemB, "febsGemB", "Mapping of FEBs IDs for GEM B"),
        yaml::Property(&FebsIds::febsRpc, "febsRpc", "Mapping of FEBs IDs forRPC"));
    };
 
    struct PadsConfig {
      std::vector<int16_t> channelToPadX;
      std::vector<int16_t> channelToPadY;
 
      // PadX means CHANNEL for CbmMuchAddress
      // PadY means SECTOR for CbmMuchAddress
      CBM_YAML_PROPERTIES(
        yaml::Property(&PadsConfig::channelToPadX, "channelToPadX", "X means CHANNEL for CbmMuchAddressA"),
        yaml::Property(&PadsConfig::channelToPadY, "channelToPadY", "Y means SECTOR for CbmMuchAddress"));
    };
 
    int32_t timeOffset;
    uint16_t numAsicsPerFeb;
    std::vector<Component> components;
    FebsIds febsMapping;
    PadsConfig padsConfigGemA;
    PadsConfig padsConfigGemB;
    PadsConfig padsConfigRpc;
 
    CBM_YAML_PROPERTIES(yaml::Property(&ReadoutSetup::timeOffset, "timeOffset", "Time offset in ns of the MVD data relative to the reference/trigger"),
                        yaml::Property(&ReadoutSetup::numAsicsPerFeb, "numAsicsPerFeb", "Number of ASICs per FEB"),
                        yaml::Property(&ReadoutSetup::components, "components", "Components", {}, YAML::Flow),
                        yaml::Property(&ReadoutSetup::febsMapping, "febsMapping",
                                       "FEBs mapping per detector", {}, YAML::Flow),
                        yaml::Property(&ReadoutSetup::padsConfigGemA, "padsConfigGemA",
                                       "Mapping of channel to PAD for GEM A", {}, YAML::Flow),
                        yaml::Property(&ReadoutSetup::padsConfigGemB, "padsConfigGemB",
                                       "Mapping of channel to PAD for GEM B", {}, YAML::Flow),
                        yaml::Property(&ReadoutSetup::padsConfigRpc, "padsConfigRpc",
                                       "Mapping of channel to PAD for RPC", {}, YAML::Flow));
  };
 
  class ReadoutConfig {
 
   public:
    ReadoutConfig();

    ReadoutConfig(const ReadoutSetup&);

    virtual ~ReadoutConfig();

    int32_t GetSystemTimeOffset() const { return fTimeOffset; }

    std::vector<uint16_t> GetEquipmentIds();

    size_t GetNumElinks(uint16_t equipmentId);

    std::vector<uint32_t> Map(uint16_t equipId, uint16_t elink);

    std::vector<bool> MaskMap(uint16_t equipId, uint16_t elink);

    std::map<uint16_t, std::vector<std::vector<uint32_t>>> GetFullMap() { return fReadoutMap; }
 
   private:
    // --- MUCH system time offset
    int32_t fTimeOffset = 0;
 
    // --- MUCH readout map
    // --- Map index: (equipment, elink, channel), map value: (MUCH address)
    std::map<uint16_t, std::vector<std::vector<uint32_t>>> fReadoutMap = {};
 
    // --- MUCH channel mask  map
    // --- Map index: (equipment, elink), map value: (vector of mask flags for channels per asic)
    std::map<uint16_t, std::map<size_t, std::vector<bool>>> fMaskMap = {};  

    void Init();

    void Init(const ReadoutSetup&);

    void InitHardcoded();

    uint32_t CreateMuchAddress(uint32_t dpbidx, int32_t iFebId, uint32_t usChan);

    static const uint16_t numCrobPerComp   = 1;    
    static const uint16_t numElinksPerCrob = 42;   
    static const uint16_t numFebsPerCrob   = 9;    
    static const uint16_t numAsicsPerFeb   = 1;    
    const uint16_t numChanPerAsic          = 128;  
 
    // Mapping of eLink to FEB number within CROB. If -1, elink not used.
    // This mapping is the same for each component.
    // => Valid only starting from 2024 data, so incoherent results with 2022 data (even though not crashing)
    static constexpr int16_t elink2Feb[numElinksPerCrob] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
                                                            3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5,
                                                            6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8};

    uint16_t numFebsInGemA = 27;              
    uint16_t numFebsInGemB = 27;              
    uint16_t numFebsInRpc  = 9;               
    std::vector<int16_t> fnFebsIdsArrayGemA;  
    std::vector<int16_t> fnFebsIdsArrayGemB;  
    std::vector<int16_t> fnFebsIdsArrayRpc;   
    std::vector<int16_t>
      fChannelsToPadXA;  
    std::vector<int16_t>
      fChannelsToPadYA;  
    std::vector<int16_t>
      fChannelsToPadXB;  
    std::vector<int16_t>
      fChannelsToPadYB;  
    std::vector<int16_t> fChannelsToPadXRpc;  
    std::vector<int16_t> fChannelsToPadYRpc;  
 
    void InitChannelToPadMaps();  
 
    int32_t GetFebId(uint16_t);
    int8_t GetPadXA(uint8_t febid, uint8_t channelid);
    int8_t GetPadYA(uint8_t febid, uint8_t channelid);
    int8_t GetPadXB(uint8_t febid, uint8_t channelid);
    int8_t GetPadYB(uint8_t febid, uint8_t channelid);
 
    //RPC Module Related Functions
    int8_t GetPadXRpc(uint8_t febid, uint8_t channelid);
    int8_t GetPadYRpc(uint8_t febid, uint8_t channelid);
  };
 
}  // namespace cbm::algo::much
 
#endif  // ALGO_DETECTORS_MUCH_READOUTCONFIG_H