comment_ids.C

Go to the documentation of this file.

/*
    BM@N alignment routine
    BM@N experiment at NICA complex, JINR, 2026
 
    Department: Math & Soft Group of HEP lab
    Author:     Claude (Opus 5.5)
    Supervisor: Igor Polev, polev@jinr.int
 
    comment_ids macro
    Adds the text form of the detector IDs to every entry of a Run9
    constraints or presigmas file that names some, and rewrites the file in place.
 
    Usage:
        root -l -b -q 'comment_ids.C("/home/igor/bmnroot/align_new/cfg/constraints/cnstr_r9-flat_lin3.json")'
*/
 
// headers below are for IDE syntax to work and they will be
// turned off during execution in ROOT macro mode
#ifndef __CLING__
#include "BmnRun9DM.h"
 
#include <algorithm>
#include <fstream>
#include <functional>
#include <string>
#include <vector>
#endif
 
#include "fairlogger/Logger.h"
 
#include <nlohmann/json.hpp>   // not in the BmnAligner dictionary, so the interpreter needs it too
 
/*
 *  An entry names detector IDs in an "ID" array (typed NodeEqual constraint),
 *  in the DetectorID coefficients of a plain constraint, or in the DetectorID
 *  of a presigma. Each ID is listed once, in file order, as one string
 *  "<ID> = <BmnDetectorModel::DecodeID text>". DecodeID pads its fields to a
 *  fixed width, so the strings of an entry line up as a table.
 *
 *  The list goes into ID_KEY, an array of strings placed right after the key
 *  holding the IDs: ID, Coefficients or DetectorID. The loaders accept and
 *  ignore ID_KEY in every entry (see BmnAlignConfig::LoadConstraints). A
 *  rerun replaces the list, so an ID edited in the file gets its new text.
 *
 *  DecodeID reads only the bits of the ID, so BmnRun9DM decodes the IDs of
 *  every Run9 model, whatever elements the model keeps.
 *
 *  The file is written back in the layout of the cfg files: one key per
 *  line; Coefficients and ID_KEY one item per line; any other value on the
 *  line of its key. ordered_json keeps the keys in file order.
 */
namespace
{
const std::string ID_KEY{"IDComment"};
}
 
/**
 * @brief Add the text form of its detector IDs to every entry that names some.
 *
 * @param jsonPath constraints or presigmas file, rewritten in place
 *
 * @return 0 on success (also when the file names no ID and is left as it is),
 *         -1 if the file cannot be read, parsed or written
 */
int comment_ids(const char* jsonPath)
{
    using json = nlohmann::ordered_json;
 
    json entries;
    {
        std::ifstream ifs(jsonPath);
        if (!ifs.good()) {
            LOG(error) << " <!> comment_ids: cannot open " << jsonPath;
            return -1;
        }
        try {
            ifs >> entries;
        } catch (const std::exception& e) {
            LOG(error) << " <!> comment_ids: cannot parse " << jsonPath << ": " << e.what();
            return -1;
        }
    }
    if (!entries.is_array()
        || std::any_of(entries.begin(), entries.end(), [](const json& e) { return !e.is_object(); }))
    {
        LOG(error) << " <!> comment_ids: " << jsonPath << " is not an array of objects";
        return -1;
    }
 
    const BmnRun9DM model;   // DecodeID() needs no Init()
    Int_t annotated{0};
    for (json& entry : entries) {
        std::vector<Int_t> ids;
        auto take = [&ids](const json& id) {
            if (id.is_number_integer() && std::find(ids.begin(), ids.end(), id.get<Int_t>()) == ids.end())
                ids.push_back(id.get<Int_t>());
        };
        if (entry.contains("ID") && entry["ID"].is_array())
            for (const json& id : entry["ID"])
                take(id);
        if (entry.contains("DetectorID"))
            take(entry["DetectorID"]);
        if (entry.contains("Coefficients") && entry["Coefficients"].is_array())
            for (const json& coef : entry["Coefficients"])
                if (coef.is_object() && coef.contains("DetectorID"))
                    take(coef["DetectorID"]);
        if (ids.empty())
            continue;
 
        json lines = json::array();
        for (const Int_t id : ids)
            lines.push_back(std::string(Form("%9d = %s", id, model.DecodeID(id).c_str())));
        const std::string anchor{entry.contains("ID")             ? "ID"
                                 : entry.contains("Coefficients") ? "Coefficients"
                                                                  : "DetectorID"};
        // CAUTION: no braces here - "json x {y}" makes the array [y], not a copy of y
        json rebuilt = json::object();
        for (auto it = entry.begin(); it != entry.end(); ++it) {
            if (it.key() == ID_KEY)
                continue;   // left by an earlier run, replaced below
            rebuilt[it.key()] = it.value();
            if (it.key() == anchor)
                rebuilt[ID_KEY] = lines;
        }
        entry = rebuilt;
        annotated++;
    }
    if (!annotated) {
        LOG(info) << "    " << jsonPath << " names no detector ID, left as it is";
        return 0;
    }
 
    std::function<std::string(const json&)> inline_ = [&inline_](const json& v) -> std::string {
        if (!v.is_array() && !v.is_object())
            return v.dump();
        std::string items;
        for (auto it = v.begin(); it != v.end(); ++it)
            items += (items.empty() ? "" : ", ") + (v.is_object() ? json(it.key()).dump() + ": " : std::string())
                     + inline_(it.value());
        return v.is_array() ? "[" + items + "]" : "{" + items + "}";
    };
    std::string text{"[\n"};
    for (std::size_t e = 0; e < entries.size(); e++) {
        const json& entry{entries[e]};
        std::size_t key{0};
        text += "    {\n";
        for (auto it = entry.begin(); it != entry.end(); ++it, ++key) {
            std::string value;
            if ((it.key() == "Coefficients" || it.key() == ID_KEY) && it.value().is_array()) {
                value = "[\n";
                for (std::size_t c = 0; c < it.value().size(); c++)
                    value += "            " + inline_(it.value()[c]) + (c + 1 < it.value().size() ? ",\n" : "\n");
                value += "        ]";
            } else
                value = inline_(it.value());
            text += "        " + json(it.key()).dump() + ": " + value + (key + 1 < entry.size() ? ",\n" : "\n");
        }
        text += e + 1 < entries.size() ? "    },\n" : "    }\n";
    }
    text += "]\n";
 
    std::ofstream ofs(jsonPath);
    if (!ofs.good() || !(ofs << text)) {
        LOG(error) << " <!> comment_ids: cannot write " << jsonPath;
        return -1;
    }
    LOG(info) << "    " << jsonPath << " : " << annotated << " entrie(s) got their detector IDs in " << ID_KEY;
    return 0;
}