BmnParamLayout.cxx

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
 
    BmnParamLayout::Rebuild implementation
 
    Out of line because the layout and the hierarchy each need the other: the
    hierarchy owns a layout, and rebuilding a layout reads the hierarchy.
*/
 
#include "BmnParamLayout.h"
 
#include "BmnAlignDefines.h"
#include "BmnAlignHierarchy.h"
 
#include <utility>
 
const std::vector<std::string>& BmnParamLayout::ParamNames()
{
    static const std::vector<std::string> names{"dX", "dY", "dZ", "phi", "theta", "psi"};
    return names;
}
 
const char* BmnParamLayout::ParamName(Int_t p)
{
    return (p >= 0 && p < BMN_GLOBAL_PARAMS_PD) ? ParamNames()[p].c_str() : "";
}
 
Int_t BmnParamLayout::ParamIndex(const std::string& name)
{
    const std::vector<std::string>& names{ParamNames()};
    for (Int_t p = 0; p < BMN_GLOBAL_PARAMS_PD; p++)
        if (name == names[p])
            return p;
    return -1;
}
 
void BmnParamLayout::Rebuild(const BmnAlignHierarchy& hierarchy)
{
    fAll.clear();
    fLeaves.clear();
    fComposites.clear();
    fByNode.clear();
    if (!hierarchy.Ready())
        return;
 
    // Filled by index rather than by push_back: the node order is an
    // implementation detail of the hierarchy, while the full layout is defined
    // by the parameter base of each node, and the config files depend on it.
    fAll.resize(hierarchy.AllParams());
    for (const BmnAlignHierarchy::Node_t& node : hierarchy.Nodes()) {
        const Int_t base{node.leaf >= 0 ? node.leaf * BMN_GLOBAL_PARAMS_PD
                                        : hierarchy.CompositeParamBase() + node.composite * BMN_GLOBAL_PARAMS_PD};
        for (Int_t p = 0; p < BMN_GLOBAL_PARAMS_PD; p++) {
            ParamRef& ref{fAll[base + p]};
            ref.full = base + p;
            ref.leaf = node.leaf;
            ref.comp = node.composite < 0 ? -1 : node.composite * BMN_GLOBAL_PARAMS_PD + p;
            ref.node = base / BMN_GLOBAL_PARAMS_PD;
            ref.prm = p;
            ref.level = node.level;
            ref.nodeName = node.name.c_str();
            ref.prmName = ParamName(p);
        }
    }
 
    fLeaves.reserve(hierarchy.LeafParams());
    fComposites.reserve(hierarchy.CompositeParams());
    for (const ParamRef& ref : fAll) {
        if (ref.IsComposite())
            fComposites.push_back(ref);
        else
            fLeaves.push_back(ref);
    }
 
    // full-layout order puts the six corrections of one object side by side,
    // so the groups are just consecutive slices of fAll
    fByNode.reserve(fAll.size() / BMN_GLOBAL_PARAMS_PD);
    for (std::size_t i = 0; i < fAll.size(); i += BMN_GLOBAL_PARAMS_PD) {
        NodeRef node;
        node.name = fAll[i].nodeName;
        node.level = fAll[i].level;
        node.leaf = fAll[i].leaf;
        node.params.assign(fAll.begin() + i, fAll.begin() + i + BMN_GLOBAL_PARAMS_PD);
        fByNode.push_back(std::move(node));
    }
}