BmnAlignConfig.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:     Claude (Opus 5)
    Supervisor: Igor Polev, polev@jinr.int
 
    BmnAlignConfig class declaration
    JSON configuration and solution files of the alignment task
*/
 
#ifndef BMNALIGNCONFIG_H
#define BMNALIGNCONFIG_H
 
#include "BmnAlignDefines.h"
#include "BmnAlignHierarchy.h"
#include "BmnAlignPriors.h"
#include "BmnAlignResult.h"
 
#include <vector>
 
/*
 *  The file format layer of the alignment: it turns the JSON config files into
 *  the data structures the rest of the code works with, and back.
 *
 *  It knows about the parametrization (BmnAlignHierarchy) because that is what
 *  the files address, and about nothing else - no data, no solver, no iteration
 *  state. Everything here is static: there is nothing to hold between calls.
 *
 *  Reading a solution deliberately stops at producing values. Applying them -
 *  adding a result, recomputing the local parameters - is the aligner's
 *  business, and a consumer that only needs the corrections (BmnAlignerApply)
 *  can read a file without dragging the solver in.
 *
 *  The target in a solution file. BmnAligner::PrepareData may move the target
 *  of the detector model by s = BmnDetectorModel::TargetShift(), and the solver
 *  then measures the target dZ from the moved target. The measurement models
 *  read a hit at z as the line at z - dZ, so a target at true z_t has
 *  dZ = z_c - z_t, and moving the centre z_c by s adds s to it. A file always
 *  holds the dZ of the geometry file: WriteSolution subtracts s, ReadSolution
 *  adds it back. So a file means the same in every run, and BmnAlignerApply,
 *  whose model is never moved, reads it as it is.
 */
 
class BmnAlignConfig
{
  public:
    BmnAlignConfig() = delete;
 
    // one alignable object as a solution file states it
    struct NodeValues
    {
        Int_t node{-1};     // index in BmnParamLayout::ByNode()
        SVectGL values{};   // its six corrections
    };
    // what a solution file holds, in the order the file listed it
    struct Solution
    {
        std::vector<NodeValues> leaves;       // by detector element
        std::vector<NodeValues> composites;   // by composite node
        // kTRUE if the hierarchy has composites, so that loading must zero the
        // ones the file does not mention rather than leave them where they were
        Bool_t zeroComposites{kFALSE};
    };
 
    // constraints file -> priors.constraints, priors.inhomogeneous
    static Bool_t LoadConstraints(const char* jsonPath, const BmnAlignHierarchy& hierarchy, BmnAlignPriors& priors);
 
    // presigmas file -> priors.sigma, priors.ref, priors.presigmaCount
    static Bool_t LoadPresigmas(const char* jsonPath, const BmnAlignHierarchy& hierarchy, BmnAlignPriors& priors);
 
    // solution file -> plain values, see the note above
    static Bool_t ReadSolution(const char* jsonPath, const BmnAlignHierarchy& hierarchy, Solution& solution);
 
    // solution + optionally the track approximations -> solution file
    static Bool_t WriteSolution(const char* jsonPath,
                                const BmnAlignHierarchy& hierarchy,
                                const BmnAlignResult& result,
                                Int_t totalTracks,
                                Bool_t withAlpha);
};
 
#endif   // BMNALIGNCONFIG_H