BmnRun8DM.h

Go to the documentation of this file.

/*
    BM@N alignment routine
    BM@N experiment at NICA complex, JINR, 2025
 
    Department: Math & Soft Group of HEP lab
    Author:     Igor Polev, polev@jinr.int
 
    BmnRun8DM class declaration
    Run8 representation of detector elements via encoding
*/
 
#ifndef BMNRUN8DM_H
#define BMNRUN8DM_H
 
#include "BmnDetectorList.h"
#include "BmnDetectorModel.h"
 
#include <TString.h>
 
/*
 *  Detector elements enumeration scheme
 *
 *  SystemID  - fixed constatns defined in BmnDetectorList.h
 *  StationID - sequence across all systems starting from 0 or 1 (currently 1)
 *  ModuleID  - separate sequence for each station starting from 0 or 1 (currently 1)
 *
 *  CbmStsHit DetectorID layout:
 *
 *  27:24 ( 4 bit) System ID
 *  23:16 ( 8 bit) Station number
 *  15:4  (12 bit) Sector (module) number
 *   3:1  ( 3 bit) Sensor number (not used, allways 0b001)
 *   0:0  ( 1 bit) Unknown (not used, allways 0b0)
 *  --------------
 *  28 bit in total
 *
 *  See CbmStsHit.h and BmnToCbmHitConverter::Exec()
 */
 
class BmnRun8DM : public BmnDetectorModel
{
  protected:
    Int_t fSystem{-1}, fStation{-1}, fModule{-1};
 
    enum
    {
        kFirst,
        kLast
    };
    // Run8 configuration definition
    constexpr static const Int_t SIL_SYSTEM_ID{DetectorId::kSILICON}, GEM_SYSTEM_ID{DetectorId::kGEM},
        SIL_STATION_CNT{4}, GEM_STATION_CNT{7}, STA_NUM_START{1},   // first station number (0 or 1)
        MOD_NUM_START{1},                                           // first module number for each station  (0 or 1)
        // stations have one common index range, silicons first, then GEMs
        SIL_STATION_IDX[2]{STA_NUM_START, STA_NUM_START + SIL_STATION_CNT - 1},
        GEM_STATION_IDX[2]{SIL_STATION_IDX[kLast] + 1, SIL_STATION_IDX[kLast] + GEM_STATION_CNT},
        SIL_MODULES[SIL_STATION_CNT]{6, 10, 14, 18}, GEM_MODULES[GEM_STATION_CNT]{8, 8, 8, 8, 8, 8, 8};
    // In GEM stations each second module is a "hot zone".
    // Hot zones should not be aligned independently.
 
    // module count of the station at the given 0-based station index
    inline Int_t StationModules(Int_t station) const noexcept
    {
        return station < SIL_STATION_CNT ? SIL_MODULES[station] : GEM_MODULES[station - SIL_STATION_CNT];
    }
    // of those, the ones aligned independently. This is the single per-station
    // primitive Alignables() and MaxModulesInStation() are built from, so a
    // model keeping fewer elements per station restates it here alone.
    virtual Int_t StationAlignables(Int_t station) const noexcept
    {
        return station < SIL_STATION_CNT ? StationModules(station) : StationModules(station) / 2;   // skip hot zones
    }
    // module number the station's alignable sequence starts at
    virtual Int_t FirstModule(Int_t /*station*/) const noexcept { return MOD_NUM_START; }
    // 0-based, inclusive index range of stations this model enumerates. A
    // subsystem-restricted model narrows it (e.g. GEM-only starts past silicon),
    // and Reset()/NextID()/Alignables()/Composites() all honour it.
    virtual Int_t FirstStation() const noexcept { return 0; }
    virtual Int_t LastStation() const noexcept { return SIL_STATION_CNT + GEM_STATION_CNT - 1; }
 
    // detector modules enumeration: see base class
    virtual void Reset() noexcept override
    {
        // must set iterator BEFORE the first module according to base class
        // definition, stepping back over one full stride of the starting system
        const Int_t station{FirstStation()};
        fSystem = station < SIL_STATION_CNT ? SIL_SYSTEM_ID : GEM_SYSTEM_ID;
        fStation = station + STA_NUM_START;
        fModule = FirstModule(station) - (fSystem == GEM_SYSTEM_ID ? 2 : 1);
    }
 
    virtual Int_t NextID() noexcept override
    {
        // out of range check
        if (-1 == fSystem)
            return -1;   // EOF marker must be negative
 
        // next module
        const Int_t stride{fSystem == GEM_SYSTEM_ID ? 2 : 1};   // skip hot zones in GEM stations
        fModule += stride;
 
        // Next station check. Alignable elements times the stride is the span of
        // module numbers the station's own sequence covers, and it is counted off
        // that sequence's first module - so the test holds for a model keeping
        // only a part of the station just as well as for the full one.
        const Int_t station{fStation - STA_NUM_START};
        if ((fModule - FirstModule(station)) / (StationAlignables(station) * stride)) {
            fStation++;
            // remember: stations has common enumeration across all systems
            // currently only two systems are considered - silicon, then GEM
 
            // EOF check
            if (fStation - STA_NUM_START > LastStation())
                return fSystem = -1;
 
            // next system check
            if (fStation > SIL_STATION_IDX[kLast])
                fSystem = GEM_SYSTEM_ID;
 
            // recomputed, not the snapshot above: FirstModule() depends on the
            // station, and fStation has just advanced
            fModule = FirstModule(fStation - STA_NUM_START);
        }
 
        return (fSystem << 24) | (fStation << 16) | (fModule << 4) | 0b0010;
        // constant term 0b0010 is used to match CbmStsHit DetectorID encoding
    }
 
  public:
    virtual Int_t MaxModulesInStation() const noexcept override
    {
        Int_t cnt{0};
        for (Int_t i = FirstStation(); i <= LastStation(); i++)
            if (StationAlignables(i) > cnt)
                cnt = StationAlignables(i);
        return cnt;
    }
 
    virtual Int_t Alignables() const noexcept override
    {
        Int_t al{0};
        for (Int_t i = FirstStation(); i <= LastStation(); i++)
            al += StationAlignables(i);
        return al;
    }
 
    // convertion from CbmStsHit DetectorID, see the layout above
    virtual Int_t IDfromHit(Int_t CbmDetectorID) const noexcept override
    {
        constexpr static const Int_t MOD_NUM_START4{MOD_NUM_START << 4}, ZERO_BIT4{0xFFFFFEF};
 
        if (GEM_SYSTEM_ID == (CbmDetectorID >> 24))
            // to skip GEM hot zone modules we need to erase the first bit
            // of module number if modules are enumerated from zero
            return ((CbmDetectorID - MOD_NUM_START4) & ZERO_BIT4) + MOD_NUM_START4;
        else
            return CbmDetectorID;
    }
 
    virtual std::string DecodeID(Int_t id) const override
    {
        TString system;
        BmnDetectorList::GetSystemNameCaps(id >> 24, system);
        return Form("%-7s st %2d mod %2d", system.Data(), (id >> 16) & 0xFF, (id >> 4) & 0xFFF);
    }
 
    BmnRun8DM() { fDescription = "Run8 GEM and FSD all independent parts: 76 elements"; }
    virtual ~BmnRun8DM() override;   // out-of-line vtable anchor
};
 
#endif   // BMNRUN8DM_H