gRootTree.cc

Go to the documentation of this file.

#include "gRootTree.h"
#include "gstreamerConventions.h"
 
using std::vector;
 
// Implementation summary:
// Build ROOT TTrees lazily from sample headers or hits, then clear and refill
// vector branches on each fill call.
 
GRootTree::GRootTree([[maybe_unused]] const std::unique_ptr<GEventHeader>& gevent_header,
                     std::shared_ptr<GLogger>&                             logger) : log(logger) {
    log->debug(CONSTRUCTOR, "GRootTree", "ROOT tree header");
 
    root_tree = std::make_unique<TTree>(EVENTHEADERTREENAME, EVENTHEADERTREENAMEDESC);
 
    // AutoFlush controls when buffered basket data are pushed to disk.
    root_tree->SetAutoFlush(20 * 1024 * 1024);
 
    // AutoSave periodically writes tree metadata snapshots for recoverability.
    root_tree->SetAutoSave(50 * 1024 * 1024);
 
    registerVariable("g4localEventNumber", gevent_header->getG4LocalEvn());
    registerVariable("threadID", gevent_header->getThreadID());
    registerVariable("timeStamp", gevent_header->getTimeStamp());
}
 
// fill the GEventHeader tree
bool GRootTree::fillTree(const std::unique_ptr<GEventHeader>& gevent_header) {
    log->info(2, "Filling header tree for local event n. ", gevent_header->getG4LocalEvn(), " threadID ",
              gevent_header->getThreadID());
 
    // Clear the vectors backing the branches before writing the next entry.
    intVarsMap["g4localEventNumber"].clear();
    intVarsMap["threadID"].clear();
    stringVarsMap["timeStamp"].clear();
 
    intVarsMap["g4localEventNumber"].emplace_back(gevent_header->getG4LocalEvn());
    intVarsMap["threadID"].emplace_back(gevent_header->getThreadID());
    stringVarsMap["timeStamp"].emplace_back(gevent_header->getTimeStamp());
 
    root_tree->Fill();
 
    return true;
}
 
// fill the GRunHeader tree
bool GRootTree::fillTree(const std::unique_ptr<GRunHeader>& grun_header) {
    log->info(2, "Filling header tree for run n. ", grun_header->getRunID());
 
    // Clear and refill the vectors backing the run-header branches.
    intVarsMap["runID"].clear();
    intVarsMap["runID"].emplace_back(grun_header->getRunID());
 
    root_tree->Fill();
 
    return true;
}
 
GRootTree::GRootTree([[maybe_unused]] const std::unique_ptr<GRunHeader>& grun_header,
                     std::shared_ptr<GLogger>&                           logger) : log(logger) {
    log->debug(CONSTRUCTOR, "GRootTree", "ROOT tree header");
 
    root_tree = std::make_unique<TTree>(RUNHEADERTREENAME, RUNHEADERTREENAMEDESC);
    root_tree->SetAutoFlush(20 * 1024 * 1024);
    root_tree->SetAutoSave(50 * 1024 * 1024);
 
    registerVariable("runID", grun_header->getRunID());
}
 
 
// Implementation summary:
// Create a true-information detector tree whose branch schema is inferred
// from the first observed hit.
GRootTree::GRootTree(const std::string&        detectorName,
                     const GTrueInfoData*      gdata,
                     std::shared_ptr<GLogger>& logger) : log(logger) {
    log->debug(CONSTRUCTOR, "GRootTree", "ROOT tree True Info");
 
    root_tree = std::make_unique<TTree>(detectorName.c_str(), TRUEINFOTREENAMEDESC);
    root_tree->SetAutoFlush(20 * 1024 * 1024);
    root_tree->SetAutoSave(50 * 1024 * 1024);
 
    // add identity vars
    auto identityMap = getIdentityMap(gdata->getIdentity());
    for (auto& [varname, value] : identityMap) { registerVariable(varname, value); }
 
    for (auto& [varname, value] : gdata->getDoubleVariablesMap()) { registerVariable(varname, value); }
    for (auto& [varname, value] : gdata->getStringVariablesMap()) { registerVariable(varname, value); }
}
 
GRootTree::GRootTree(const std::string& treeName,
                     [[maybe_unused]] const GGeneratedParticleBank& particles,
                     std::shared_ptr<GLogger>& logger) : log(logger) {
    log->debug(CONSTRUCTOR, "GRootTree", "ROOT tree Generated Particles");
 
    root_tree = std::make_unique<TTree>(treeName.c_str(), GENERATEDTREENAMEDESC);
    root_tree->SetAutoFlush(20 * 1024 * 1024);
    root_tree->SetAutoSave(50 * 1024 * 1024);
 
    registerVariable("pid", 0);
    registerVariable("type", 0);
    registerVariable("multiplicity", 0);
    registerVariable("p", 0.0);
    registerVariable("theta", 0.0);
    registerVariable("phi", 0.0);
    registerVariable("vx", 0.0);
    registerVariable("vy", 0.0);
    registerVariable("vz", 0.0);
    registerVariable("name", std::string());
}
 
GRootTree::GRootTree([[maybe_unused]] const GAncestorBank& ancestors,
                     std::shared_ptr<GLogger>& logger) : log(logger) {
    log->debug(CONSTRUCTOR, "GRootTree", "ROOT tree Ancestors");
    root_tree = std::make_unique<TTree>(ANCESTORTREENAME, ANCESTORTREENAMEDESC);
    root_tree->SetAutoFlush(20 * 1024 * 1024);
    root_tree->SetAutoSave(50 * 1024 * 1024);
 
    registerVariable("pid", 0);
    registerVariable("tid", 0);
    registerVariable("mtid", 0);
    registerVariable("trackE", 0.0);
    registerVariable("px", 0.0);
    registerVariable("py", 0.0);
    registerVariable("pz", 0.0);
    registerVariable("vx", 0.0);
    registerVariable("vy", 0.0);
    registerVariable("vz", 0.0);
}
 
 
// Implementation summary:
// Create a digitized detector tree whose branch schema is inferred
// from the first observed hit.
GRootTree::GRootTree(const std::string&        detectorName,
                     const GDigitizedData*     gdata,
                     std::shared_ptr<GLogger>& logger) : log(logger) {
    log->debug(CONSTRUCTOR, "GRootTree", "ROOT tree Digitized Data");
 
    root_tree = std::make_unique<TTree>(detectorName.c_str(), DIGITIZEDTREENAMEDESC);
    root_tree->SetAutoFlush(20 * 1024 * 1024);
    root_tree->SetAutoSave(50 * 1024 * 1024);
 
    // add identity vars
    auto identityMap = getIdentityMap(gdata->getIdentity());
    for (auto& [varname, value] : identityMap) { registerVariable(varname, value, true); }
 
    for (auto& [varname, value] : gdata->getIntObservablesMap(0)) {
        registerVariable(varname, value);
    }
    for (auto& [varname, value] : gdata->getDblObservablesMap(0)) { registerVariable(varname, value); }
}
 
 
// fill the True Info Tree
bool GRootTree::fillTree(const vector<const GTrueInfoData*>& trueInfoData) {
    // Reset all branch vectors before repopulating them for this detector collection.
    for (auto& [varname, values] : intVarsMap) { values.clear(); }
    for (auto& [varname, values] : doubleVarsMap) { values.clear(); }
    for (auto& [varname, values] : stringVarsMap) { values.clear(); }
 
 
    for (auto& dataHits : trueInfoData) {
        // fill identity vars
        auto identityMap = getIdentityMap(dataHits->getIdentity());
        for (auto& [varname, value] : identityMap) {
            intVarsMap[varname].push_back(value);
        }
 
        for (auto& [varname, value] : dataHits->getDoubleVariablesMap()) { doubleVarsMap[varname].push_back(value); }
        for (auto& [varname, value] : dataHits->getStringVariablesMap()) { stringVarsMap[varname].push_back(value); }
    }
 
    root_tree->Fill();
 
    return true;
}
 
// fill the Digitized Data Tree
bool GRootTree::fillTree(const vector<const GDigitizedData*>& digitizedData) {
    // Reset all branch vectors before repopulating them for this detector collection.
    for (auto& [varname, values] : intVarsMap) { values.clear(); }
    for (auto& [varname, values] : doubleVarsMap) { values.clear(); }
    for (auto& [varname, values] : stringVarsMap) { values.clear(); }
 
 
    for (auto& dataHits : digitizedData) {
        // fill identity vars
        auto identityMap = getIdentityMap(dataHits->getIdentity());
        for (auto& [varname, value] : identityMap) {
            intVarsMap[varname].push_back(value);
        }
 
 
        for (auto& [varname, value] : dataHits->getIntObservablesMap(0)) { intVarsMap[varname].push_back(value); }
        for (auto& [varname, value] : dataHits->getDblObservablesMap(0)) { doubleVarsMap[varname].push_back(value); }
    }
    root_tree->Fill();
 
    return true;
}
 
bool GRootTree::fillTree(const GGeneratedParticleBank& particles) {
    for (auto& [varname, values] : intVarsMap) { values.clear(); }
    for (auto& [varname, values] : doubleVarsMap) { values.clear(); }
    for (auto& [varname, values] : stringVarsMap) { values.clear(); }
 
    for (const auto& particle : particles) {
        intVarsMap["pid"].push_back(particle.pid);
        intVarsMap["type"].push_back(particle.type);
        intVarsMap["multiplicity"].push_back(particle.multiplicity);
        doubleVarsMap["p"].push_back(particle.p);
        doubleVarsMap["theta"].push_back(particle.theta);
        doubleVarsMap["phi"].push_back(particle.phi);
        doubleVarsMap["vx"].push_back(particle.vx);
        doubleVarsMap["vy"].push_back(particle.vy);
        doubleVarsMap["vz"].push_back(particle.vz);
        stringVarsMap["name"].push_back(particle.name);
    }
 
    root_tree->Fill();
    return true;
}
 
bool GRootTree::fillTree(const GAncestorBank& ancestors) {
    for (auto& [varname, values] : intVarsMap) { values.clear(); }
    for (auto& [varname, values] : doubleVarsMap) { values.clear(); }
 
    for (const auto& ancestor : ancestors) {
        intVarsMap["pid"].push_back(ancestor.pid);
        intVarsMap["tid"].push_back(ancestor.tid);
        intVarsMap["mtid"].push_back(ancestor.mtid);
        doubleVarsMap["trackE"].push_back(ancestor.trackE);
        doubleVarsMap["px"].push_back(ancestor.px);
        doubleVarsMap["py"].push_back(ancestor.py);
        doubleVarsMap["pz"].push_back(ancestor.pz);
        doubleVarsMap["vx"].push_back(ancestor.vx);
        doubleVarsMap["vy"].push_back(ancestor.vy);
        doubleVarsMap["vz"].push_back(ancestor.vz);
    }
 
    root_tree->Fill();
    return true;
}
 
 
// Implementation summary:
// Register one branch and bind it to the appropriate backing vector map.
// The second parameter is used only to select the correct overload.
 
void GRootTree::registerVariable(const std::string& varname, [[maybe_unused]] int value, bool can_ignore_duplicates) {
    if (can_ignore_duplicates) {
        root_tree->Branch(varname.c_str(), &intVarsMap[varname]);
    }
    else {
        if (intVarsMap.find(varname) == intVarsMap.end()) { root_tree->Branch(varname.c_str(), &intVarsMap[varname]); }
        else {
            log->error(ERR_GSTREAMERVARIABLEEXISTS, "variable <", varname,
                       "> already registered in the int variable map of tree ", root_tree->GetName());
        }
    }
}
 
void GRootTree::registerVariable(const std::string& varname, [[maybe_unused]] double value) {
    if (doubleVarsMap.find(varname) == doubleVarsMap.end()) {
        root_tree->Branch(varname.c_str(), &doubleVarsMap[varname]);
    }
    else {
        log->error(ERR_GSTREAMERVARIABLEEXISTS, "variable <", varname,
                   "> already registered in the double variable map of tree ", root_tree->GetName());
    }
}
 
void GRootTree::registerVariable(const std::string& varname, [[maybe_unused]] const std::string& value) {
    if (stringVarsMap.find(varname) == stringVarsMap.end()) {
        root_tree->Branch(varname.c_str(), &stringVarsMap[varname]);
    }
    else {
        log->error(ERR_GSTREAMERVARIABLEEXISTS, "variable <", varname,
                   "> already registered in the string variable map of tree ", root_tree->GetName());
    }
}