expandS.C

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
 
    Solution expansion macro
    Re-encodes an alignment solution from a coarse detector model into a finer one
    that distinguishes more detector elements. Every fine element inherits the
    correction of the coarse element it belongs to.
*/
 
// headers below are for IDE syntax to work and they will be
// turned off during execution in ROOT macro mode
#ifndef __CLING__
#include "BmnAlignConfig.h"
#include "BmnAlignDefines.h"
#include "BmnAlignModels.h"   // IWYU pragma: keep
#endif
 
#include "fairlogger/Logger.h"
 
#include <fstream>
#include <iomanip>
#include <nlohmann/json.hpp>
#include <vector>
 
// ---- expansion configuration ------------------------------------------------
using inDetModel = BmnRun8cgDM;   // source (coarse) model
using outDetModel = BmnRun8DM;    // output (fine) model
// -----------------------------------------------------------------------------
 
/**
 * @brief Re-encode a solution from a coarse detector model into a finer one.
 *
 * Every element of the fine model inherits the correction of the coarse element
 * it belongs to, so a solution obtained on half-stations can seed a run that
 * aligns individual modules. The two models are named by the inDetModel and
 * outDetModel aliases at the top of the file.
 *
 * @param inSolutionPath  .json solution written for the coarse model
 * @param outSolutionPath .json file to write the expanded solution into
 *
 * @return 0 on success, -1 if the solution could not be read or written
 */
int expandS(const char* inSolutionPath = "/home/igor/bmnroot/align_new/cfg/run8/slALL.e11.00.json",
            const char* outSolutionPath = "/home/igor/bmnroot/align_new/cfg/run8/slALL.e76.00.json")
{
    fair::Logger::SetConsoleColor(true);
    fair::Logger::SetConsoleSeverity("info");
    LOG(state) << " > expandS.C : solution expansion started";
 
    // Read the input solution through the file-format layer alone: expanding a
    // solution needs neither the solver nor a reconstruction task. The flat
    // parametrization is all that is required to address the file, since the
    // per-element values it lists are the *effective* corrections - whatever
    // hierarchy produced them, its levels are already summed into these.
    inDetModel inputModel;
    inputModel.Init();
    BmnAlignHierarchy inputLayout;
    if (!inputLayout.BuildFlat(inputModel)) {
        LOG(error) << " <!> failed to build the input model layout";
        return -1;
    }
    BmnAlignConfig::Solution solution;
    if (!BmnAlignConfig::ReadSolution(inSolutionPath, inputLayout, solution)) {
        LOG(error) << " <!> failed to load solution " << inSolutionPath;
        return -1;
    }
    // corrections by coarse element index, so the loop below can look one up
    VecSVectGL_t corrections(inputModel.Alignables());
    for (const BmnAlignConfig::NodeValues& leaf : solution.leaves)
        corrections[leaf.node] = leaf.values;
    if (solution.leaves.empty()) {
        LOG(error) << " <!> " << inSolutionPath << " holds no detector elements";
        return -1;
    }
 
    outDetModel outputModel;
    outputModel.Init();
    const Int_t outputCount{outputModel.Alignables()};
 
    // --- build the expanded solution -----------------------------------------
    using nlohmann::json;
    json js;
    js["CorrectionValues"] = BmnParamLayout::ParamNames();
    js["DetectorElements"] = outputCount;
    js["CorrectionsPerDetector"] = json::array();
 
    Int_t outputCnt{0};
    for (Int_t i = 0; i < outputCount; i++) {
        const Int_t outputID{outputModel.EncodedID(i)};
        json element;
        element["detector_id"] = outputID;
        element["values"] = json::array();
        element["errors"] = json::array();
 
        // coarse element this fine element belongs to (per the old model)
        const Int_t hitID{inputModel.IDfromHit(outputID)};
        if (inputModel.UnknownID(hitID)) {
            LOG(error) << " <!> element " << outputID << " maps to unknown id " << hitID << " in input model, aborting";
            return -1;
        }
 
        const SVectGL& A{corrections[inputModel.Idx(hitID)]};
        for (Int_t j = 0; j < BMN_GLOBAL_PARAMS_PD; j++) {
            element["values"].push_back(A(j));
            element["errors"].push_back(0.0);   // errors are discarded on load
        }
        js["CorrectionsPerDetector"].push_back(element);
        outputCnt++;
    }
 
    // --- write the expanded solution -----------------------------------------
    std::ofstream ofs(outSolutionPath);
    if (!ofs.good()) {
        LOG(error) << " <!> failed to open output file " << outSolutionPath;
        return -1;
    }
    try {
        ofs << std::setw(4) << js << std::endl;
    } catch (std::exception& e) {
        LOG(error) << " <!> failed to write JSON data\n" << e.what();
        return -1;
    }
 
    LOG(info) << "    " << outputCnt << " elements written to " << outSolutionPath;
    LOG(state) << " < expandS.C : solution expansion completed";
    return 0;
}