ConcreteVariablesToNtuplePersistenceManager Class Reference

A PersistenceManager that writes variables to a ROOT TTree. More...

#include <ConcreteVariablesToNtuplePersistenceManager.h>

Inheritance diagram for ConcreteVariablesToNtuplePersistenceManager:

Public Member Functions
	ConcreteVariablesToNtuplePersistenceManager ()
	Default constructor.
void	initialize (const std::string &fileName, const std::string &treeName, Variables &variables) override
	Initializes the manager by opening a ROOT file and preparing a TTree.
void	addEntry (const EvaluatedVariables &evaluatedVariables) override
	Adds a single event's worth of variable data to the TTree.
void	store () override
	Writes the current buffered data to disk.

Private Member Functions
void	openFileWithGuards ()
	Safely opens the ROOT file specified by m_fileName.
void	registerBranches ()
	Registers TTree branches for each variable in m_variables.
void	updateBranch (const std::string &variableName, const VariableType &value)
	Updates the branch buffer for a given variable with a new value.

Private Attributes
std::string	m_fileName
	Name of the ROOT file where TTree data is stored.
std::string	m_treeName
	Name of the TTree that will be created and filled.
Variables	m_variables
	The list of variables that will be written to the TTree.
int	m_basketSize {1600}
	Basket size for the TTree branches.
std::shared_ptr< TFile >	m_file {nullptr}
	Pointer to the ROOT file object.
StoreObjPtr< RootMergeable< TTree > >	m_tree
	A store pointer to the RootMergeable wrapper for the TTree.
std::map< std::string, double >	m_branchesDouble
	Maps of variable names to storage for double, int, and bool TTree branches.
std::map< std::string, int >	m_branchesInt
	Storage for int branches.
std::map< std::string, bool >	m_branchesBool
	Storage for bool branches.

Detailed Description

A PersistenceManager that writes variables to a ROOT TTree.

This class manages the creation and population of a ROOT TTree for a given set of variables. It handles opening a ROOT file, booking TTree branches, and filling them with user-supplied data each event. The TTree can then be merged in a multi-process environment through the RootMergeable mechanism.

Definition at line 41 of file ConcreteVariablesToNtuplePersistenceManager.h.

Constructor & Destructor Documentation

ConcreteVariablesToNtuplePersistenceManager()

ConcreteVariablesToNtuplePersistenceManager

(

)

Default constructor.

Definition at line 33 of file ConcreteVariablesToNtuplePersistenceManager.cc.

    : m_tree{"", DataStore::c_Persistent}
  {
 
  }

Member Function Documentation

addEntry()

void addEntry ( const EvaluatedVariables & evaluatedVariables )

overridevirtual

Adds a single event's worth of variable data to the TTree.

Parameters

evaluatedVariables

Map of variable names to their values, which will be written to the TTree branches.

Each call updates the branch buffers for the registered variables. The actual storage of these buffers occurs when store() is called.

Implements PersistenceManager.

Definition at line 51 of file ConcreteVariablesToNtuplePersistenceManager.cc.

  {
    for (const auto& [variableName, value] : evaluatedVariables) {
      std::string branchName = Belle2::MakeROOTCompatible::makeROOTCompatible(variableName.c_str());
      updateBranch(branchName, value);
    }
    m_tree->get().Fill();
  }

initialize()

void initialize ( const std::string & fileName, const std::string & treeName, Variables & variables )

overridevirtual

Initializes the manager by opening a ROOT file and preparing a TTree.

Parameters

fileName	Name of the ROOT file to create or update.
treeName	Name of the TTree to create.
variables	List of variables that will be stored in the TTree.

This method configures the persistence manager with file and tree names, and sets up the necessary memory structures. It does not actually write data; that is handled by addEntry().

Implements PersistenceManager.

Definition at line 39 of file ConcreteVariablesToNtuplePersistenceManager.cc.

  {
    m_fileName = fileName;
    m_treeName = treeName;
    m_variables = variables;
 
    openFileWithGuards();
    registerBranches();
  }

openFileWithGuards()

void openFileWithGuards ( )

private

Safely opens the ROOT file specified by m_fileName.

This function takes care of ensuring the file can be written to or created if it does not exist. Throws an exception on error.

Definition at line 75 of file ConcreteVariablesToNtuplePersistenceManager.cc.

  {
    if (m_fileName.empty()) {
      B2FATAL("Output root file name is not set.");
    }
    m_file = RootFileCreationManager::getInstance().getFile(m_fileName);
 
    if (not m_file) {
      B2FATAL("Could not create file: " << m_fileName << ".");
    }
 
    TDirectory::TContext directoryGuard{m_file.get()};
 
    if (m_file->Get(m_treeName.c_str())) {
      B2FATAL("A tree with the name: " << m_treeName << "already exists in the file: " << m_fileName << ".");
    }
 
    m_tree.registerInDataStore(m_fileName + m_treeName, DataStore::c_DontWriteOut);
    m_tree.construct(m_treeName.c_str(), "");
    m_tree->get().SetCacheSize(100000);
  }

registerBranches()

void registerBranches ( )

private

Registers TTree branches for each variable in m_variables.

Initializes branch addresses for each variable type (double, int, bool). Also sets the basket size using m_basketSize.

Definition at line 97 of file ConcreteVariablesToNtuplePersistenceManager.cc.

  {
    for (const auto& variable : m_variables) {
      std::visit([&](const auto & typedVariable) {
        using T = std::decay_t<decltype(typedVariable)>;
        if constexpr(std::is_same_v<T, TypedVariable>) {
          std::string branchName = Belle2::MakeROOTCompatible::makeROOTCompatible(typedVariable.getName().c_str());
          std::string leafName = typedVariableToLeafName(typedVariable);
 
          switch (typedVariable.getDataType()) {
            case VariableDataType::c_double:
              m_branchesDouble[branchName] = double{};
              m_tree->get().Branch(branchName.c_str(), &m_branchesDouble[branchName], leafName.c_str());
              break;
            case VariableDataType::c_int:
              m_branchesInt[branchName] = int{};
              m_tree->get().Branch(branchName.c_str(), &m_branchesInt[branchName], leafName.c_str());
              break;
            case VariableDataType::c_bool:
              m_branchesBool[branchName] = bool{};
              m_tree->get().Branch(branchName.c_str(), &m_branchesBool[branchName], leafName.c_str());
              break;
            default:
              break;
          }
        } else {
          B2WARNING("Incompatible variable type. Skipping branch registration.");
        }
      }, variable);
    }
    m_tree->get().SetBasketSize("*", m_basketSize);
  }

store()

void store ( )

overridevirtual

Writes the current buffered data to disk.

After populating branch buffers through addEntry(), this function commits them to the ROOT file, ensuring data is safely stored.

Implements PersistenceManager.

Definition at line 60 of file ConcreteVariablesToNtuplePersistenceManager.cc.

  {
    if (not ProcHandler::parallelProcessingUsed() or ProcHandler::isOutputProcess()) {
      B2INFO("Writing Ntuple: " << m_treeName);
      TDirectory::TContext directoryGuard{m_file.get()};
      m_tree->write(m_file.get());
 
      const bool writeError = m_file->TestBit(TFile::kWriteError);
      m_file.reset();
      if (writeError) {
        B2FATAL("A write error occurred while saving '" << m_fileName << "', please check if enough disk space is available.");
      }
    }
  }

updateBranch()

void updateBranch ( const std::string & variableName, const VariableType & value )

private

Updates the branch buffer for a given variable with a new value.

Parameters

variableName	The name of the variable (branch).
value	The new value to be stored in the branch buffer.

Depending on the type of the variant, the appropriate map (m_branchesDouble, m_branchesInt, or m_branchesBool) is updated.

Definition at line 130 of file ConcreteVariablesToNtuplePersistenceManager.cc.

  {
    std::visit([&](auto&& value) {
      using T = std::decay_t<decltype(value)>;
 
      if constexpr(std::is_same_v<T, double>) {
        m_branchesDouble[branchName] = value;
      } else if constexpr(std::is_same_v<T, int>) {
        m_branchesInt[branchName] = value;
      } else if constexpr(std::is_same_v<T, bool>) {
        m_branchesBool[branchName] = value;
      }
    }, evaluatedValue);
  }

Member Data Documentation

m_basketSize

int m_basketSize {1600}

private

Basket size for the TTree branches.

Affects I/O efficiency.

Definition at line 99 of file ConcreteVariablesToNtuplePersistenceManager.h.

{1600};

m_branchesBool

std::map<std::string, bool> m_branchesBool

private

Storage for bool branches.

Definition at line 116 of file ConcreteVariablesToNtuplePersistenceManager.h.

m_branchesDouble

std::map<std::string, double> m_branchesDouble

private

Maps of variable names to storage for double, int, and bool TTree branches.

Storage for double branches.

Definition at line 114 of file ConcreteVariablesToNtuplePersistenceManager.h.

m_branchesInt

std::map<std::string, int> m_branchesInt

private

Storage for int branches.

Definition at line 115 of file ConcreteVariablesToNtuplePersistenceManager.h.

m_file

std::shared_ptr<TFile> m_file {nullptr}

private

Pointer to the ROOT file object.

Definition at line 104 of file ConcreteVariablesToNtuplePersistenceManager.h.

{nullptr};

m_fileName

std::string m_fileName

private

Name of the ROOT file where TTree data is stored.

Definition at line 84 of file ConcreteVariablesToNtuplePersistenceManager.h.

m_tree

StoreObjPtr<RootMergeable<TTree> > m_tree

private

A store pointer to the RootMergeable wrapper for the TTree.

Definition at line 109 of file ConcreteVariablesToNtuplePersistenceManager.h.

m_treeName

std::string m_treeName

private

Name of the TTree that will be created and filled.

Definition at line 89 of file ConcreteVariablesToNtuplePersistenceManager.h.

m_variables

Variables m_variables

private

The list of variables that will be written to the TTree.

Definition at line 94 of file ConcreteVariablesToNtuplePersistenceManager.h.

---

The documentation for this class was generated from the following files:

• reconstruction/persistenceManager/include/ConcreteVariablesToNtuplePersistenceManager.h
• reconstruction/persistenceManager/src/ConcreteVariablesToNtuplePersistenceManager.cc