BmnRun9HalfDM.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
 
    BmnRun9HalfDM class declaration
    Run9 full-granularity representation, single half of each station only
*/
 
#ifndef BMNRUN9HALFDM_H
#define BMNRUN9HALFDM_H
 
#include "BmnRun9DM.h"
 
#include <TString.h>
#include <numeric>
 
/*
 *  Common base for the fine-grained half-assembly models: same every-module
 *  scheme as BmnRun9DM, but only one half of every station is alignable
 *  (55 elements, plus the target if the model has one). Top elements carry
 *  the first half of module numbers, bottom elements the second half. Derived
 *  classes pick the kept half via KeepBottomHalf().
 *
 *  The last GEM station, a single module crossing y = 0, has no halves.
 *  BmnRun9DM leaves it out (a zero in GEM_MODULES), so every station of this
 *  model has two halves.
 *
 *  Hierarchical parametrization
 *  ----------------------------
 *  The half of a station is a rigid mechanical unit, so the model declares one
 *  composite node per station half on top of the element-level nodes. The
 *  nodes carry the names BmnRun9DM gives the same station halves (STAnnU,
 *  STAnnL), so config files address them the same way in both models.
 *  Pivots are left to the default (centre of gravity of the owned elements,
 *  i.e. the beam axis at their mean z).
 */
 
class BmnRun9HalfDM : public BmnRun9DM
{
  protected:
    // selects which half of every station is alignable
    virtual Bool_t KeepBottomHalf() const noexcept = 0;
 
    // the bottom half starts where the station's own module count says it does
    virtual Int_t FirstModule(Int_t station) const noexcept override
    {
        return MOD_NUM_START + (KeepBottomHalf() ? StationModules(station) / 2 : 0);
    }
    virtual Int_t StationAlignables(Int_t station) const noexcept override
    {
        // method also works for the single-module station,
        // it is a safety feature for the future code changes
        if (!StationModules(station))
            return 0;
        return std::max(1, BmnRun9DM::StationAlignables(station) / 2);
    }
 
  public:
    using BmnRun9DM::BmnRun9DM;
 
    // CAUTION: the base check goes first. The halves test below knows nothing
    // of the stations left out, and keeps a single-module one in the bottom model.
    virtual Bool_t IgnoreHit(Int_t CbmDetectorID) const noexcept override
    {
        if (BmnRun9DM::IgnoreHit(CbmDetectorID))
            return kTRUE;
        const Int_t module{((CbmDetectorID >> 4) & 0xFFF) - MOD_NUM_START},
            station{((CbmDetectorID >> 16) & 0xFF) - STA_NUM_START}, half{StationModules(station) / 2};
        if (0 == half)       // single-module station kept whole by both halves
            return kFALSE;   // ignoring it is up to BmnRun9DM::IgnoreHit()
        return KeepBottomHalf() ? module < half : module >= half;
    }
    virtual Bool_t IgnoresSome() const noexcept override { return kTRUE; }
 
    virtual std::vector<Composite> Composites() const override
    {
        // NextID() walks the stations in order and never revisits one, so the
        // elements of a station half occupy a contiguous index range
        std::vector<Composite> nodes;
        nodes.reserve(LastStation() - FirstStation() + 1);
        for (Int_t station = FirstStation(), leaf = 0; station <= LastStation(); station++) {
            if (0 == StationAlignables(station))
                continue;   // ignore 'empty' stations
            Composite node;
            node.name = Form(KeepBottomHalf() ? "STA%02dL" : "STA%02dU", station + STA_NUM_START);
            node.leaves.resize(StationAlignables(station));
            std::iota(node.leaves.begin(), node.leaves.end(), leaf);
            leaf += node.leaves.size();
            nodes.push_back(std::move(node));
        }
        return nodes;
    }
};
 
#endif   // BMNRUN9HALFDM_H