makett.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
 
    Generation of alignment test tasks based on real data
*/
 
// headers below are for IDE syntax to work and they will be
// turned off during execution in ROOT macro mode
#ifndef __CLING__
#include "BmnAlignModels.h"   // IWYU pragma: keep
#include "BmnAlignReport.h"
#include "BmnAlignTestTask.h"
#include "BmnAligner.h"
#endif
 
#include "fairlogger/Logger.h"
 
#include <TRandom3.h>
#include <fstream>
#include <string>
 
#define DEF_THREADS_COUNT 16
 
/**
 * @brief Build a synthetic alignment task with a known answer.
 *
 * Reads real tracks, fits straight lines to them, displaces the detector by a
 * randomly drawn solution and writes out hits lying exactly on the displaced
 * model, together with the solution that produced them. Feeding the result back
 * into align.C tests the solver against a truth instead of against itself.
 *
 * The truth is drawn from the truth sigmas and obeys the constraints (see
 * BmnAlignTestTask), so align.C must use the same constraints file on the task.
 * The solver's own presigmas play no part here: both aligners below take the
 * truth sigmas as their presigmas, the generator to draw the truth from them,
 * the viewer only to display the task.
 *
 * @param fileListPath    text file listing the source .root files, one per line
 * @param testTaskPath    .root file to write the synthetic hits into
 * @param testSolPath     .json file to write the truth solution into
 * @param constraintsPath .json constraints, the same align.C will use on the task
 * @param truthSigmaPath  .json truth sigmas in the presigma format; every composite parameter not
 *                        fixed by a constraint needs one, see BmnAlignPriors::Check()
 * @param sigmaScale      truth StdDev = truth sigma * sigmaScale, 0 for the nominal geometry
 * @param showTask        kTRUE to reload the generated task and draw it afterwards
 * @param seed            PRNG seed for the truth and the noise, 0 for a new one each run (it is logged)
 *
 * @return 0 on success, -1 if any stage failed
 */
int makett(const char* fileListPath = "/home/igor/bmnroot/align_new/cfg/run9/9555.noa_rlerr.list",
           const char* testTaskPath = "/home/igor/data.cache/tt9555.r9_lin3.00.root",
           const char* testSolPath = "/home/igor/data.cache/tt9555.r9_lin3.00.solution.json",
           const char* constraintsPath = "/home/igor/bmnroot/align_new/cfg/constraints/cnstr_r9_lin3.json",
           const char* truthSigmaPath = "/home/igor/bmnroot/align_new/cfg/presigmas/psg_r9_lin3-testTruth.json",
           Double_t sigmaScale = 0.25,
           Bool_t showTask = kTRUE,
           UInt_t seed = 137)
{
    // the collision target installed in the run, as a FairRoot ASCII geometry file
    constexpr const char* TARGET_GEO{"/home/igor/bmnroot/align_new/cfg/target_Sn.geo"};
 
    fair::Logger::SetConsoleColor(true);
    fair::Logger::SetConsoleSeverity("info");
 
    LOG(state) << " > makett : test task generation script started";
    if (!truthSigmaPath) {
        LOG(error) << " <!> makett: truthSigmaPath is required, the truth is drawn from it";
        return -1;
    }
 
    // SetSeed(0) fills the whole TRandom3 state from a TUUID, and no single
    // number reproduces that state. So a fresh seed is drawn here and set
    // explicitly: the logged value rebuilds the same task.
    if (!seed)
        seed = TRandom3(0).Integer(kMaxUInt) + 1;
    gRandom->SetSeed(seed);
    LOG(info) << "    random seed " << seed;
 
    BmnMeasureLin3 measureModel;
    BmnRun9DM detModel(kTRUE);
    if (!detModel.Init(TARGET_GEO))
        return -1;
 
    std::string outListPath;
    {
        // Scoped on purpose: this aligner holds the source data in RAM, and it
        // is released here, before the one below loads the generated task.
        BmnAligner aligner(&measureModel, &detModel, fileListPath, constraintsPath, truthSigmaPath, DEF_THREADS_COUNT);
        if (!aligner.Initialized())
            return -1;
        if (!aligner.PrepareData())
            return -1;
        if (!BmnAlignTestTask::Make(aligner, testTaskPath, testSolPath, sigmaScale, BmnAlignTestTask::kHitErrors))
            return -1;
 
        // make .list file for the task
        std::string taskPath(testTaskPath);
        auto dot = taskPath.find_last_of('.');
        auto slash = taskPath.find_last_of('/');
        Bool_t dotInName = (dot != std::string::npos) && (slash == std::string::npos || dot > slash);
        outListPath = (dotInName ? taskPath.substr(0, dot) : taskPath) + ".list";
 
        std::ofstream listOut(outListPath);
        if (!listOut) {
            LOG(error) << "Failed to write list file: " << outListPath;
            return -1;
        }
        listOut << testTaskPath << '\n';
    }
    LOG(state) << " < makett : test task generation completed";
 
    if (!showTask)
        return 0;
 
    LOG(state) << " > makett : test task visual representation";
    BmnAligner viewer(&measureModel, &detModel, outListPath.c_str(), constraintsPath, truthSigmaPath,
                      DEF_THREADS_COUNT);
    if (!viewer.Initialized())
        return -1;
    if (!viewer.PrepareData())
        return -1;
    if (!viewer.LoadSolution(""))
        return -1;
    if (!viewer.LoadSolution(testSolPath))
        return -1;
    BmnAlignReport::Results(viewer);
    BmnAlignReport::Draw(viewer);
    LOG(state) << " > makett : test task visual representation completed";
 
    return 0;
}