BmnATestDetectorPlane.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.ru
 
    BmnATestDetectorPlane class header-only implementation
    Minimalistic representation of detector for alignment algorithm test only
*/
 
#ifndef BMNATESTDETECTORPLANE_H
#define BMNATESTDETECTORPLANE_H
 
#include "BmnAlignDefines.h"
#include "Math/Functions.h"
#include "TMath.h"
#include "TPolyLine3D.h"
 
#include <stdexcept>
 
#define BMN_PLANE_SIZE 400.0
#define BMN_PLANE_COLOR kBlue
#define BMN_NORMAL_COLOR kRed
 
class BmnATestDetectorPlane
{
  public:
    BmnATestDetectorPlane() = default;   // required for BMN project to be compilable
    BmnATestDetectorPlane(Double_t Zposition, const SVectGL& Misalignments, Int_t DetectorID);
 
    Double_t GetPosition() const noexcept { return fZposition; };
    Int_t GetDetectorID() const noexcept { return fDetectorID; };
 
    Double_t GetConst() const noexcept { return fConst; };
    const SVect3& GetNormal() const noexcept { return fNormal; };
    const SMatr3x3& GetCrdRotation() const noexcept { return fCoordRotation; };
    const SMatr3x3& GetCrdInvRotation() const noexcept { return fCoordInvRotation; };
    const SVect3& GetCrdShift() const noexcept { return fCoordShift; };
 
    const SVect3& GetAlignShift() const noexcept { return fAlignShift; };
    const SVect3& GetAlignRot() const noexcept { return fAlignRot; };
 
    void Draw(Bool_t showNormal = kFALSE) const;   // for ROOT macro mode only
  protected:
    Double_t fZposition;   // nominal position of detector plane
    SVect3 fAlignShift,    // detector position shift in x,y,z axis
        fAlignRot;         // detector position rotation around x,y,z axis
                           // attention: rotations are applied in reverse order (z, y, x)
    // equation is defined in form ax + by + cz + d = 0
    SVect3 fNormal;    // (a,b,c)
    Double_t fConst;   // d
    // transition to detector local coordinates
    SMatr3x3 fCoordRotation, fCoordInvRotation;
    SVect3 fCoordShift;
    Int_t fDetectorID;
};
 
// it is up to compiler to keep this function inlined
 
inline BmnATestDetectorPlane::BmnATestDetectorPlane(Double_t Zposition, const SVectGL& Misalignmets, Int_t DetectorID)
    : fZposition(Zposition)
    , fDetectorID(DetectorID)
{
    for (Int_t i = iX; i <= iZ; i++) {
        if (i >= BMN_GLOBAL_PARAMS_PD)
            break;
        fAlignShift(i) = Misalignmets(i);
    }
    for (Int_t i = iX, j = iZ + 1; i <= iZ; i++, j++) {
        if (j >= BMN_GLOBAL_PARAMS_PD)
            break;
        fAlignRot(i) = Misalignmets(j);
    }
    fCoordShift = fAlignShift;
    fCoordShift(iZ) += fZposition;
 
    Double_t sinAlpha{TMath::Sin(fAlignRot(iX))},                                  // rotation over x
        cosAlpha{TMath::Cos(fAlignRot(iX))}, sinBeta{TMath::Sin(fAlignRot(iY))},   // rotation over y
        cosBeta{TMath::Cos(fAlignRot(iY))}, sinGamma{TMath::Sin(fAlignRot(iZ))},   // rotation over z
        cosGamma{TMath::Cos(fAlignRot(iZ))};
 
    // rotation matrix in the following order: over z, over y, over x
    fCoordRotation(iX, iX) = cosBeta * cosGamma;
    fCoordRotation(iX, iY) = -cosBeta * sinGamma;
    fCoordRotation(iX, iZ) = sinBeta;
    fCoordRotation(iY, iX) = sinAlpha * sinBeta * cosGamma + cosAlpha * sinGamma;
    fCoordRotation(iY, iY) = -sinAlpha * sinBeta * sinGamma + cosAlpha * cosGamma;
    fCoordRotation(iY, iZ) = -sinAlpha * cosBeta;
    fCoordRotation(iZ, iX) = sinAlpha * sinGamma - cosAlpha * sinBeta * cosGamma;
    fCoordRotation(iZ, iY) = sinAlpha * cosGamma + cosAlpha * sinBeta * sinGamma;
    fCoordRotation(iZ, iZ) = cosAlpha * cosBeta;
 
    // normal vector calculated by rotation of (0,0,1)
    // on misalignment rotation angles:
    // it is exactly the 3rd column of rotation matrix
    fNormal = fCoordRotation.Col(iZ);
    // constant d of equation ax + by + cz + d = 0
    // calculated from point on detector plane X
    // to satisfy equation:
    // d = - Normal dot X
    fConst = -ROOT::Math::Dot(fNormal, fCoordShift);
 
    Int_t inverse_failure;
    fCoordInvRotation = fCoordRotation.Inverse(inverse_failure);
    // here inverse can't fail normally
    if (inverse_failure)
        throw std::runtime_error("BmnATestDetectorPlane: rotation matrix inverse failed");
}
 
// visualization works in ROOT macro mode only
inline void BmnATestDetectorPlane::Draw(Bool_t showNormal) const
{
    const Double_t halfSize{BMN_PLANE_SIZE / 2.0};
 
    // square outline in local (detector) coordinates
    SVect3 points[5];
    points[0](iX) = -halfSize;
    points[0](iY) = -halfSize;
    points[1](iX) = -halfSize;
    points[1](iY) = halfSize;
    points[2](iX) = halfSize;
    points[2](iY) = halfSize;
    points[3](iX) = halfSize;
    points[3](iY) = -halfSize;
    points[4] = points[0];
 
    // transformation into global (lab) coordinates
    Double_t x[5], y[5], z[5];
    for (int i = 0; i < 5; i++) {
        points[i] = fCoordRotation * points[i] + fCoordShift;
        x[i] = points[i](iX);
        y[i] = points[i](iY);
        z[i] = points[i](iZ);
    }
 
    // visualization using polyline
    // note: x and z axis are swapped
    auto* outline = new TPolyLine3D(5, z, y, x);
    outline->SetLineColor(BMN_PLANE_COLOR);
    outline->Draw();
 
    if (!showNormal)
        return;
 
    // draw normal to the plane
    SVect3 normal[2];
    normal[1](iZ) = BMN_PLANE_SIZE;
    for (int i = 0; i < 2; i++) {
        normal[i] = fCoordRotation * normal[i] + fCoordShift;
        x[i] = normal[i](iX);
        y[i] = normal[i](iY);
        z[i] = normal[i](iZ);
    }
    auto* normalLine = new TPolyLine3D(2, z, y, x);
    normalLine->SetLineColor(BMN_NORMAL_COLOR);
    normalLine->Draw();
 
    // in macro mode we don't clean RAM, sorry
}
 
#endif   // BMNATESTDETECTORPLANE_H