BmnATestTrack.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
 
    BmnATestTrack class header-only implementation
    Minimalistic representation of random linear track
    (for alignment algorithm test only)
*/
 
/*
    === DEPRECATION NOTICE =========================================
    Due to complex changes in BmnAligner, this class requires rework
    ================================================================
*/
 
#ifndef BMNATESTTRACK_H
#define BMNATESTTRACK_H
 
#include "BmnATestHit.h"
#include "BmnAlignDefines.h"
#include "BmnAlignResult.h"
#include "BmnAligner.h"
#include "TPolyLine3D.h"
 
#include <stdexcept>
 
#define BMN_TEST_TRACK_SOLID_COLOR kBlack
#define BMN_TEST_TRACK_NONSOLID_COLOR kMagenta
#define BMN_TEST_TRACK_DEF_MAX_Z 500.0
 
class BmnATestTrack
{
  private:
    // according to _VBCK_ line is defined as:
    // x = AlphaX1 + AlphaX2 * z
    // y = AlphaY1 + AlphaY2 * z
    // see readme.md for details
    SVectLC fAlpha;
    SVect3 fVertex, fDirection;
    Int_t fMaxHits, fHitsCnt{0};
    BmnATestHit** fpHits;
 
  protected:
    typedef BmnAligner<BmnATestHit> BmnAlignerClass;
 
  public:
    BmnATestTrack() = delete;
    BmnATestTrack(SVectLC Alpha, Int_t nHits);
    BmnATestTrack(Double_t Alpha1Sigma, Double_t Alpha2Min, Double_t Alpha2Max, Int_t nHits);
    ~BmnATestTrack() { delete[] fpHits; }
 
    const SVectLC& GetAlpha() const noexcept { return fAlpha; }
    const SVect3& GetVertex() const noexcept { return fVertex; }
    const SVect3& GetDirection() const noexcept { return fDirection; }
 
    void AddHit(BmnATestHit& hit);
    void AddMSE(BmnAlignerClass* pAligner, Bool_t withResiduals = kFALSE) const;
 
    Double_t X(Double_t z) const noexcept { return fAlpha(iX0) + fAlpha(iX1) * z; }
    Double_t Y(Double_t z) const noexcept { return fAlpha(iY0) + fAlpha(iY1) * z; }
 
    // for ROOT macro mode only
    void Draw(Bool_t solid = kTRUE, Double_t maxZ = BMN_TEST_TRACK_DEF_MAX_Z) const;
};
 
inline BmnATestTrack::BmnATestTrack(SVectLC Alpha, Int_t nHits)
    : fAlpha(Alpha)
    , fMaxHits(nHits)
{
    fVertex = SVect3({fAlpha(iX0), fAlpha(iY0), 0.0});
    fDirection = SVect3({fAlpha(iX1), fAlpha(iY1), 1.0});
 
    fpHits = new BmnATestHit*[fMaxHits];
    for (Int_t i = 0; i < fMaxHits; i++)
        fpHits[i] = nullptr;
}
 
inline BmnATestTrack::BmnATestTrack(Double_t Alpha1Sigma, Double_t Alpha2Min, Double_t Alpha2Max, Int_t nHits)
    : fMaxHits(nHits)
{
    fAlpha(iX0) = BMN_RND.Gaus(0.0, Alpha1Sigma);
    fAlpha(iY0) = BMN_RND.Gaus(0.0, Alpha1Sigma);
    fAlpha(iX1) = BMN_RND.Uniform(Alpha2Min, Alpha2Max);
    fAlpha(iY1) = BMN_RND.Uniform(Alpha2Min, Alpha2Max);
    fVertex = SVect3({fAlpha(iX0), fAlpha(iY0), 0.0});
    fDirection = SVect3({fAlpha(iX1), fAlpha(iY1), 1.0});
 
    fpHits = new BmnATestHit*[fMaxHits];
    for (Int_t i = 0; i < fMaxHits; i++)
        fpHits[i] = nullptr;
}
 
inline void BmnATestTrack::AddHit(BmnATestHit& hit)
{
    if (fHitsCnt >= fMaxHits)
        throw std::runtime_error("BmnATestTrack::AddHit: too many hits");
    fpHits[fHitsCnt++] = &hit;
}
 
inline void BmnATestTrack::AddMSE(BmnAlignerClass* pAligner, Bool_t withResiduals) const
{
    if (!fpHits)
        throw std::runtime_error("BmnATestTrack::AddResiduals: hits not registered");
    Double_t z, delta, omega;
    BmnAlignResult& result{*pAligner->GetCurrentResult()};
 
    for (Int_t i = 0; i < fHitsCnt; i++) {
        Int_t detectorIdx{static_cast<Int_t>(fpHits[i]->GetDetectorID())};
        const SVectGL& A = result.A(detectorIdx);
        z = fpHits[i]->GetZ() + A(iZ);
 
        omega = pAligner->OmegaScaleFactor() * fpHits[i]->GetWx();
        delta = fpHits[i]->GetX() + A(iX) - X(z);
        result.AddValueMSE(detectorIdx, omega * delta * delta);
        if (withResiduals)
            result.ResidualsX().Fill(delta);
 
        omega = pAligner->OmegaScaleFactor() * fpHits[i]->GetWy();
        delta = fpHits[i]->GetY() + A(iY) - Y(z);
        result.AddValueMSE(detectorIdx, omega * delta * delta);
        if (withResiduals)
            result.ResidualsY().Fill(delta);
    }
}
 
// visualization works in ROOT macro mode only
inline void BmnATestTrack::Draw(Bool_t solid, Double_t maxZ) const
{
    Double_t x[2]{X(0.0), X(maxZ)}, y[2]{Y(0.0), Y(maxZ)}, z[2]{0.0, maxZ};
    // note: x and z axis are swapped
    auto* line = new TPolyLine3D(2, z, y, x);
    if (solid)
        line->SetLineColor(BMN_TEST_TRACK_SOLID_COLOR);
    else {
        line->SetLineColor(BMN_TEST_TRACK_NONSOLID_COLOR);
        line->SetLineStyle(2);
    }
    line->Draw();
    // draw hits if known
    if (fpHits)
        for (Int_t i = 0; i < fHitsCnt; i++)
            if (fpHits[i])
                fpHits[i]->Draw();
 
    // in macro mode we don't clean RAM, sorry
}
 
#endif   // BMNATESTTRACK_H