dump_object.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)
    Supervisor: Igor Polev, polev@jinr.int
 
    Object dump macro: prints every data member of an object stored in a .root
    file, as the class dictionary describes it
*/
 
// headers below are for IDE syntax to work and they will be
// turned off during execution in ROOT macro mode
#ifndef __CLING__
#include "TBranch.h"
#include "TClass.h"
#include "TClonesArray.h"
#include "TFile.h"
#include "TKey.h"
#include "TTree.h"
 
#include <iostream>
#endif
 
/**
 * @brief Print all data members of an object read from a .root file.
 *
 * The name is looked up as a key of the file first - run-level objects such as
 * DstRunHeader - and then as a top-level class branch of the tree, read at the
 * given entry - per-event objects such as DstEventHeader. or StsHit. A
 * TClonesArray is dumped element by element.
 *
 * @param filePath   .root file to read
 * @param objectName key or top-level branch name
 * @param entry      tree entry to read the branch at, ignored for a key
 * @param treeName   tree holding the branches
 *
 * @return 0 on success, -1 if the object is not found or cannot be read
 */
int dump_object(const char* filePath = "/home/igor/DATA/bmn/26.02.0/dst/rc_noa_rlerr.run_Top_9555_ev0_p0.root",
                const char* objectName = "DstRunHeader",
                Long64_t entry = 0,
                const char* treeName = "bmndata")
{
    TFile file{filePath, "READ"};
    if (file.IsZombie())
        return -1;
 
    TClass* cl{nullptr};
    void* obj{nullptr};
    if (TKey * key{file.GetKey(objectName)}) {
        cl = TClass::GetClass(key->GetClassName());
        obj = key->ReadObjectAny(cl);
    } else {
        TTree* tree{file.Get<TTree>(treeName)};
        TBranch* branch{tree ? tree->GetBranch(objectName) : nullptr};
        // SetAddress(&obj) is right for a top-level class branch only: a leaf
        // branch or a split sub-branch would write its data over the pointer
        if (branch && branch->GetMother() == branch && entry >= 0 && entry < tree->GetEntries())
            cl = TClass::GetClass(branch->GetClassName());
        if (cl) {
            branch->SetAddress(&obj);   // a pointer to null makes the branch allocate the object
            if (branch->GetEntry(entry) <= 0)
                obj = nullptr;
        }
    }
    if (!cl || !obj) {
        std::cout << "dump_object: no readable object '" << objectName << "' in " << filePath
                  << " - neither a key nor a top-level class branch of '" << treeName << "' at entry " << entry << '\n';
        return -1;
    }
 
    std::cout << objectName << " : " << cl->GetName() << '\n';
    if (!cl->InheritsFrom(TClonesArray::Class())) {
        cl->Dump(obj, kTRUE);
        return 0;
    }
    const TClonesArray* array{static_cast<TClonesArray*>(obj)};
    for (Int_t i{0}; i < array->GetEntriesFast(); i++) {
        const TObject* element{array->At(i)};
        std::cout << "\n--- [" << i << "] " << element->ClassName() << '\n';
        // TClass::Dump wants the start of the object, which is not the TObject
        // part when TObject is not the first base - the cast TObject::Dump does too
        element->IsA()->Dump(element->IsA()->DynamicCast(TObject::Class(), element, kFALSE), kTRUE);
    }
    return 0;
}