trd2d/ReadoutConfig.h

Go to the documentation of this file.

/* Copyright (C) 2023-2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese, Dominik Smith [committer], Alex Bercuci */
 
#pragma once
 
#include "CbmYaml.h"
#include "algo/detectors/trd2d/UnpackMS.h"
 
#include <map>
#include <sstream>
#include <utility>
#include <vector>
 
namespace cbm::algo::trd2d
{
 

 
  class ReadoutSetup {
 
   public:
    struct CompMapping {
      uint16_t moduleId;
      uint8_t fiberId;
 
      CBM_YAML_FORMAT(YAML::Flow);
      CBM_YAML_PROPERTIES(yaml::Property(&CompMapping::moduleId, "moduleId", "Module ID"),
                     yaml::Property(&CompMapping::fiberId, "fiberId", "Optical Fibre ID"));
    };
 
    struct ChanMapping {
      int32_t padAddress;   
      bool maskFlag;        
      int8_t tOffset;       
      uint16_t lThreshold;  
 
      CBM_YAML_FORMAT(YAML::Flow);
      CBM_YAML_PROPERTIES(
        yaml::Property(&ChanMapping::padAddress, "address", "Pad address"),
        yaml::Property(&ChanMapping::maskFlag, "mask", "Channel masking flag"),
        yaml::Property(&ChanMapping::tOffset, "toff", "Channel wise time offset"),
        yaml::Property(&ChanMapping::lThreshold, "thres", "SW masking by threshold"));
    };

    ReadoutSetup();
 

    ~ReadoutSetup();
 

    std::vector<uint16_t> GetEquipmentIds();
 

    size_t GetNumAsics(uint16_t equipmentId);
 

    std::vector<uint8_t> GetAsicList(uint16_t equipmentId);
 

    size_t GetNumChans(uint16_t equipmentId, uint16_t asicId);


    CompMapping CompMap(uint16_t equipId);
 

    ChanMapping ChanMap(uint16_t equipId, uint16_t asic, uint16_t chan);
 

    std::string PrintReadoutMap();

    void InitComponentMap(const std::map<uint32_t, std::vector<uint16_t>>& map);

    void InitChannelMap(
      const std::map<size_t, std::map<size_t, std::map<size_t, std::tuple<int32_t, bool, int16_t, uint16_t>>>>&
        channelMap);

    int64_t GetSystemTimeOffset() { return fSystemTimeOffset; };

    void SetSystemTimeOffset(int64_t offsetNs) { fSystemTimeOffset = offsetNs; };
 
   private:
    // --- System time offset
    int64_t fSystemTimeOffset = 0;
 
    // --- TRD2D readout map
    // --- Map index: (equipment), map value: (module id, crob id)
    std::map<uint16_t, CompMapping> fReadoutMap = {};  
 
    // --- TRD2D channel map
    // --- Map index: (equipment, asic, chan), map value: (pad address, mask flag, daq offset)
    std::map<uint16_t, std::map<uint8_t, std::vector<ChanMapping>>> fChannelMap = {};  
 
    CBM_YAML_PROPERTIES(
      yaml::Property(&ReadoutSetup::fSystemTimeOffset, "timeOffset", "System time offset for TRD2D"),
      yaml::Property(&ReadoutSetup::fReadoutMap, "readoutMap", "Maps equipment to module and Optical fibre Id", YAML::Hex),
      yaml::Property(&ReadoutSetup::fChannelMap, "channelMap",
                                    "Maps equipment, ASIC and channel to pad address, mask flag and DAQ offset",
                                    YAML::Hex));
  };  // end struct cbm::algo::trd2d::ReadoutSetup
 
  class ReadoutCalib {
 
   public:
    struct ChanNoise {
      uint16_t tDelay;   
      uint16_t tWindow;  
      uint16_t lDThres;  
      uint16_t lSThres;  
 
      CBM_YAML_PROPERTIES(
        yaml::Property(&ChanNoise::tDelay, "delay", "time delay wrt the causing signal"),
        yaml::Property(&ChanNoise::tWindow, "window", "time window for noise signal search"),
        yaml::Property(&ChanNoise::lDThres, "dnoise", "Max signal value for cutting dynamic noise signals"),
        yaml::Property(&ChanNoise::lSThres, "snoise", "Max signal value for cutting static noise signals"));
    };
    struct ChanDescriptor {
      bool maskFlag;    
      int8_t tOffset;   
      float baseline;   
      float gainfee;    
      ChanNoise noise;  
 
      CBM_YAML_FORMAT(YAML::Flow);
      CBM_YAML_PROPERTIES(
        yaml::Property(&ChanDescriptor::maskFlag, "mask", "Channel masking flag"),
        yaml::Property(&ChanDescriptor::tOffset, "toff", "Channel wise time offset"),
        yaml::Property(&ChanDescriptor::baseline, "bline", "Baseline correction"),
        yaml::Property(&ChanDescriptor::gainfee, "gainfee", "Gain correction for FEE channel"),
        yaml::Property(&ChanDescriptor::noise,  "noise", "Dynamic noise descriptor"));
    };

    ReadoutCalib();
 

    ~ReadoutCalib();

    ChanDescriptor GetChannelFeeCalib(uint16_t modId, uint16_t padId);

    float GetSystemCalibSignal() { return fSystemCalibSignal; };

    std::string PrintCalibMap();
 
   private:
    float fSystemCalibSignal = 900.;  
 
    // --- TRD2D-FEE calibration map
    // --- Map index: (module_id), map value: (array of channel calibration parameters)
    std::map<uint16_t, std::array<ChanDescriptor, NFASPMOD* NFASPCH>> fCalibMap = {};  
 
    CBM_YAML_PROPERTIES(
      yaml::Property(&ReadoutCalib::fSystemCalibSignal, "sCalib", "System wide calibrating signal for TRD2D"),
      yaml::Property(&ReadoutCalib::fCalibMap, "calibMap",
                                    "Maps of FEE calibration: mask, DAQ time offset, etc.",
                                    YAML::Hex));
  };  // end struct cbm::algo::trd2d::ReadoutCalib
 
}  // namespace cbm::algo::trd2d
 
CBM_YAML_EXTERN_DECL(cbm::algo::trd2d::ReadoutSetup);
CBM_YAML_EXTERN_DECL(cbm::algo::trd2d::ReadoutCalib);