Production notes for RootParameterTracker: More...

#include <RootParameterTracker.h>

Public Member Functions
	RootParameterTracker ()
	constructor setting standard values

void	initialize (std::string fileName, std::string fileTreatment)
	creates rootFile, first parameter is fileName, second one specifies how the file shall be treated.

void	addParameters4DoubleAlgorithms (std::string tcTypeName, std::string algorithmName)
	relevant for all algorithms storing one double per TC:

void	addParameters4IntAlgorithms (std::string tcTypeName, std::string algorithmName)
	relevant for all algorithms storing one int per TC:

void	addParameters4VecDoubleAlgorithms (std::string tcTypeName, std::string algorithmName)
	relevant for all algorithms storing one vector of double per TC:

void	collectData (const std::vector< AnalizerTCInfo > &tcVector)
	take vector and fill for each tcType stored in rootParameterTracker

void	fillRoot ()
	fills tree/branches with their stuff, clear intermediate results afterwards

void	terminate ()
	final cleanup and closing rootFile

Protected Types
template<class ValueType >
using	StringKeyBox = KeyValBox< std::string, ValueType >
	short-cut since strings are always used as keys here:

template<class DataType >
using	AnalyzingAlgorithm = AnalyzingAlgorithmBase< DataType, AnalizerTCInfo, ROOT::Math::XYZVector >
	short-cut for typical algorithm-types used

template<class DataType >
using	AlgoDataBox = StringKeyBox< StringKeyBox< std::pair< AnalyzingAlgorithm< DataType > , std::vector< DataType > > > >
	contains algorithms and its raw data to be streamed into ttrees.

Protected Member Functions
TTree *	prepareTTree (std::string tcTypeName)
	checks if ttree for given tcTypeName exists and creates it if not.

void	collectData4DoubleAlgorithms (std::string tcTypeName, const AnalizerTCInfo &aTC)
	takes aTC with tcTypeName and applies the algorithms for it

void	collectData4IntAlgorithms (std::string tcTypeName, const AnalizerTCInfo &aTC)
	takes aTC with tcTypeName and applies the algorithms for it

void	collectData4VecDoubleAlgorithms (std::string tcTypeName, const AnalizerTCInfo &aTC)
	takes aTC with tcTypeName and applies the algorithms for it

Protected Attributes
StringKeyBox< TTree * >	m_treeBox
	contains all the trees for rootFile-filling later-on.

AlgoDataBox< double >	m_algoDataDouble
	contains all algorithms and its data storing one double per TC

AlgoDataBox< int >	m_algoDataInt
	contains all algorithms and its data storing one int per TC

AlgoDataBox< std::vector< double > >	m_algoDataVecDouble
	contains all algorithms and its data storing one vector of double per TC

TFile *	m_file
	stores pointer to file

Detailed Description

Production notes for RootParameterTracker:

internalTreeContainer, internalAlgorithmContainer, internalLinkContainer are all a vector< pair < key, value> >. .find returns a link to the entry (.second only) searched for and takes a key and compares only with the key (like a map) .push_back simply push_back a pair .clearAll() for each entry.second .clear();

shall be a simple class just containing this vector and a find function doing what one wants to do

reread pseudo code down below to be sure that the container does what it shall do. takes care of collecting data of track candidates and storing it to root branches.

Definition at line 49 of file RootParameterTracker.h.

Member Typedef Documentation

◆ AlgoDataBox

using AlgoDataBox = StringKeyBox<StringKeyBox<std::pair<AnalyzingAlgorithm<DataType>*, std::vector<DataType>*> >>

protected

contains algorithms and its raw data to be streamed into ttrees.

key of AlgoDataBox is tcType, val is another box with: key is algorithmType val is pair: .first is the algorithm to be applied onto the AnalizerTCInfo-instances. .second is the data collected for .first to be streamed into ttrees.

Definition at line 68 of file RootParameterTracker.h.

◆ AnalyzingAlgorithm

using AnalyzingAlgorithm = AnalyzingAlgorithmBase<DataType, AnalizerTCInfo, ROOT::Math::XYZVector>

protected

short-cut for typical algorithm-types used

Definition at line 57 of file RootParameterTracker.h.

◆ StringKeyBox

using StringKeyBox = KeyValBox<std::string, ValueType>

protected

short-cut since strings are always used as keys here:

Definition at line 53 of file RootParameterTracker.h.

Constructor & Destructor Documentation

◆ RootParameterTracker()

RootParameterTracker ( )

inline

constructor setting standard values

Definition at line 140 of file RootParameterTracker.h.

140: m_file(nullptr) {}

Belle2::RootParameterTracker::m_file

TFile * m_file

stores pointer to file

Definition: RootParameterTracker.h:93

Member Function Documentation

◆ addParameters4DoubleAlgorithms()

void addParameters4DoubleAlgorithms	(	std::string	tcTypeName,
		std::string	algorithmName
	)

relevant for all algorithms storing one double per TC:

for given tcTypename <-> algorithmName-combination, this tracker will be prepared for tracking them in a root-file.

Production notes - pseudo code:

want to have one ttree for each tcType.

if TCType.convertToString (tcTypeName) not in internalTreeContainer: internalTreeContainer.push_back(tcTypeName, new TTree(tcTypeName, ("collects data collected to tcType" + tcTypeName).c_str());

if TCType.convertToString (tcTypeName) not in internalAlgorithmContainer: internalAlgorithmContainer.push_back(tcTypeName, {} ); // .second contains all the algorithms in the end

if algorithmName already in internalAlgorithmContainer: B2WARNING return;

internalAlgorithmContainer.find(tcTypeName).push_back(newAlgorithm); internalLinkContainer.find(tcTypeName).push_back( { algorithmName, {} ); // .second (empty curly braces) contains the collected data in the end

auto linkToData = internalLinkContainer.find(tcTypeName).find(algorithmName);

internalTreeContainer.find(tcTypeName)->Branch("algorithmName", &linkToData);

make sure that container for algorithms of given tcType exists:

make sure that algorithm and its dataStuff exists:

make sure that there is a branch linked to the raw data stored for this tcType <-> algorithm combination:

Definition at line 155 of file RootParameterTracker.cc.

{
  B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), given parameters are tcTypeName/algorithmName: " << tcTypeName
          << "/" <<
          algorithmName);
 
  TTree* tree4tcType = prepareTTree(tcTypeName);
 
  auto* algorithms4tcType = m_algoDataDouble.find(tcTypeName);
  if (algorithms4tcType == nullptr) {
    B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), tcType " << tcTypeName <<
            " not yet added to m_algoDataDouble, doing it now...");
    m_algoDataDouble.push_back({
      tcTypeName,
      StringKeyBox<std::pair<AnalyzingAlgorithm<double>*, std::vector<double>*> >()
    });
    algorithms4tcType = m_algoDataDouble.find(tcTypeName);
  }
  B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), m_algoDataDouble has " << m_algoDataDouble.size() <<
          " tcTypes stored");
 
  auto* data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
  if (data4AlgorithmOftcType == nullptr) {
    B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), algorithm " << algorithmName <<
            " not yet added to m_algoDataDouble[tcType], doing it now...");
    AnalyzingAlgorithm<double>* newAlgorithm = AnalyzingAlgorithmFactoryDouble<double, AnalizerTCInfo, ROOT::Math::XYZVector>
                                               (AlgoritmType::getTypeEnum(algorithmName));
    algorithms4tcType->push_back({
      algorithmName,
      {
        newAlgorithm,
        new std::vector<double>()
      }
    });
    data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
 
    auto* newBranch = tree4tcType->Branch(algorithmName.c_str(), data4AlgorithmOftcType->second);
    if (newBranch == nullptr) B2ERROR("Could not create Branch " << algorithmName); // mainly to suppress compiler warning
    // newBranch->Print();
  } else {
    B2WARNING("RootParameterTracker::addParameters4DoubleAlgorithms() given tcTypeName/algorithmName: " << tcTypeName <<
              "/" << algorithmName <<
              " was already added and will not be added again. This is a sign for unintended behavior - nothing will be added!");
  }
  B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), m_algoDataDouble[tcType] has " << algorithms4tcType->size() <<
          " algorithms stored");
}

◆ addParameters4IntAlgorithms()

void addParameters4IntAlgorithms	(	std::string	tcTypeName,
		std::string	algorithmName
	)

relevant for all algorithms storing one int per TC:

for given tcTypename <-> algorithmName-combination, this tracker will be prepared for tracking them in a root-file.

make sure that container for algorithms of given tcType exists:

make sure that algorithm and its dataStuff exists:

make sure that there is a branch linked to the raw data stored for this tcType <-> algorithm combination:

Definition at line 234 of file RootParameterTracker.cc.

{
  B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), given parameters are tcTypeName/algorithmName: " << tcTypeName <<
          "/" <<
          algorithmName);
 
  TTree* tree4tcType = prepareTTree(tcTypeName);
 
  auto* algorithms4tcType = m_algoDataInt.find(tcTypeName);
  if (algorithms4tcType == nullptr) {
    B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), tcType " << tcTypeName <<
            " not yet added to m_algoDataInt, doing it now...");
    m_algoDataInt.push_back({
      tcTypeName,
      StringKeyBox<std::pair<AnalyzingAlgorithm<int>*, std::vector<int>*> >()
    });
    algorithms4tcType = m_algoDataInt.find(tcTypeName);
  }
  B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), m_algoDataInt has " << m_algoDataInt.size() << " tcTypes stored");
 
  auto* data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
  if (data4AlgorithmOftcType == nullptr) {
    B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), algorithm " << algorithmName <<
            " not yet added to m_algoDataInt[tcType], doing it now...");
    AnalyzingAlgorithm<int>* newAlgorithm =
      AnalyzingAlgorithmFactoryInt<int, AnalizerTCInfo, ROOT::Math::XYZVector>(AlgoritmType::getTypeEnum(algorithmName));
 
    algorithms4tcType->push_back({
      algorithmName,
      {
        newAlgorithm,
        new std::vector<int>()
      }
    });
    data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
 
    auto* newBranch = tree4tcType->Branch(algorithmName.c_str(), data4AlgorithmOftcType->second);
    if (newBranch == nullptr) B2ERROR("Could not create Branch " << algorithmName); // mainly to suppress compiler warning
    // newBranch->Print();
  } else {
    B2WARNING("RootParameterTracker::addParameters4DoubleAlgorithms() given tcTypeName/algorithmName: " << tcTypeName <<
              "/" << algorithmName <<
              " was already added and will not be added again. This is a sign for unintended behavior - nothing will be added!");
  }
  B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), m_algoDataInt[tcType] has " << algorithms4tcType->size() <<
          " algorithms stored");
}

◆ addParameters4VecDoubleAlgorithms()

void addParameters4VecDoubleAlgorithms	(	std::string	tcTypeName,
		std::string	algorithmName
	)

relevant for all algorithms storing one vector of double per TC:

for given tcTypename <-> algorithmName-combination, this tracker will be prepared for tracking them in a root-file.

make sure that container for algorithms of given tcType exists:

make sure that algorithm and its dataStuff exists:

make sure that there is a branch linked to the raw data stored for this tcType <-> algorithm combination:

Definition at line 292 of file RootParameterTracker.cc.

{
  B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), given parameters are tcTypeName/algorithmName: " <<
          tcTypeName << "/" <<
          algorithmName);
 
  TTree* tree4tcType = prepareTTree(tcTypeName);
 
  auto* algorithms4tcType = m_algoDataVecDouble.find(tcTypeName);
  if (algorithms4tcType == nullptr) {
    B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), tcType " << tcTypeName <<
            " not yet added to m_algoDataVecDouble, doing it now...");
    m_algoDataVecDouble.push_back({
      tcTypeName,
      StringKeyBox<std::pair<AnalyzingAlgorithm<std::vector<double>>*, std::vector<std::vector<double>>*> >()
    });
    algorithms4tcType = m_algoDataVecDouble.find(tcTypeName);
  }
  B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), m_algoDataVecDouble has " << m_algoDataVecDouble.size() <<
          " tcTypes stored");
 
  auto* data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
  if (data4AlgorithmOftcType == nullptr) {
    B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), algorithm " << algorithmName <<
            " not yet added to m_algoDataVecDouble[tcType], doing it now...");
    AnalyzingAlgorithm<std::vector<double>>* newAlgorithm =
                                           AnalyzingAlgorithmFactoryVecDouble<std::vector<double>, AnalizerTCInfo, ROOT::Math::XYZVector>
                                           (AlgoritmType::getTypeEnum(algorithmName));
    algorithms4tcType->push_back({
      algorithmName,
      {
        newAlgorithm,
        new std::vector<std::vector<double>>()
      }
    });
    data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
 
    auto* newBranch = tree4tcType->Branch(algorithmName.c_str(), data4AlgorithmOftcType->second);
    if (newBranch == nullptr) B2ERROR("Could not create Branch " << algorithmName); // mainly to suppress compiler warning
    // newBranch->Print();
  } else {
    B2WARNING("RootParameterTracker::addParameters4VecDoubleAlgorithms() given tcTypeName/algorithmName: " << tcTypeName <<
              "/" << algorithmName <<
              " was already added and will not be added again. This is a sign for unintended behavior - nothing will be added!");
  }
  B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), m_algoDataVecDouble[tcType] has " <<
          algorithms4tcType->size() << " algorithms stored");
}

◆ collectData()

void collectData ( const std::vector< AnalizerTCInfo > & tcVector )

inline

take vector and fill for each tcType stored in rootParameterTracker

Production notes: take internal container where all the requested parameters are tracked: for currenttcType in internalAlgorithmContainer: for tc in tcVector if tc.tctype == currenttcType fill internalLinkContainer with result of applied algorithm

Definition at line 183 of file RootParameterTracker.h.

    {
      B2DEBUG(21, "RootParameterTracker::collectData(), size of given tcVector is: " << tcVector.size());
 
      for (const AnalizerTCInfo& tc : tcVector) {
        std::string tcTypeName = TCType::getTypeName(tc.getType());
        B2DEBUG(22, "RootParameterTracker::collectData(), executing TC of type: " << tcTypeName);
 
        collectData4DoubleAlgorithms(tcTypeName, tc);
        collectData4IntAlgorithms(tcTypeName, tc);
        collectData4VecDoubleAlgorithms(tcTypeName, tc);
      } // looping over TCs
    }

◆ collectData4DoubleAlgorithms()

void collectData4DoubleAlgorithms	(	std::string	tcTypeName,
		const AnalizerTCInfo &	aTC
	)

protected

takes aTC with tcTypeName and applies the algorithms for it

Definition at line 14 of file RootParameterTracker.cc.

{
  auto* foundTCTypeData = m_algoDataDouble.find(tcTypeName); // a KeyValBox with all algorithms and data collected to given tcTypeName
 
  // skip if there is nothing stored for this tcType:
  if (foundTCTypeData == nullptr) { return; }
 
  // looping over algorithms:
  for (auto& entry : *foundTCTypeData) {
    // increase readability:
    auto* anAlgorithm = entry.second.first;
    auto* dataVector = entry.second.second;
    // sanity check: key has to be compatible with stored algorithm:
    std::string algoName = anAlgorithm->getIDName();
    if (entry.first != algoName) {
      B2ERROR("RootParameterTracker::collectData4DoubleAlgorithms() key (" << entry.first <<
              ") of container does not match to its content (" << algoName <<
              ") - skipping entry! ");
      continue;
    }
    B2DEBUG(21, "RootParameterTracker::collectData4DoubleAlgorithms(), executing algorithm of type: " << algoName <<
            " with collected data-entries of " << dataVector->size());
 
    try {
      double calcVal = anAlgorithm->calcData(aTC);
      dataVector->push_back(calcVal);
      B2DEBUG(20, "RootParameterTracker::collectData4DoubleAlgorithms(), tc with type " << tcTypeName <<
              " and applied algorithm " << algoName <<
              " and got " << calcVal << " as a result!");
    }  catch (AnalyzingAlgorithm<double>::No_refTC_Attached& anException) {
      B2WARNING("RootParameterTracker::collectData4DoubleAlgorithms(), Exception caught for tc with type " << tcTypeName <<
                " and applied algorithm " << algoName <<
                ". Failed with exception: " << anException.what() <<
                " -> skipping tc!");
    }
  }// looping over algorithms
}

◆ collectData4IntAlgorithms()

void collectData4IntAlgorithms	(	std::string	tcTypeName,
		const AnalizerTCInfo &	aTC
	)

protected

takes aTC with tcTypeName and applies the algorithms for it

Definition at line 57 of file RootParameterTracker.cc.

{
  auto* foundTCTypeData = m_algoDataInt.find(tcTypeName); // a KeyValBox with all algorithms and data collected to given tcTypeName
 
  // skip if there is nothing stored for this tcType:
  if (foundTCTypeData == nullptr) { return; }
 
  // looping over algorithms:
  for (auto& entry : *foundTCTypeData) {
    // increase readability:
    auto* anAlgorithm = entry.second.first;
    auto* dataVector = entry.second.second;
    // sanity check: key has to be compatible with stored algorithm:
    std::string algoName = anAlgorithm->getIDName();
    if (entry.first != algoName) {
      B2ERROR("RootParameterTracker::collectData4DoubleAlgorithms() key (" << entry.first <<
              ") of container does not match to its content (" << algoName <<
              ") - skipping entry! ");
      continue;
    }
    B2DEBUG(50, "RootParameterTracker::collectData4DoubleAlgorithms(), executing algorithm of type: " << algoName <<
            " with collected data-entries of " << dataVector->size());
 
    try {
      int calcVal = anAlgorithm->calcData(aTC);
      dataVector->push_back(calcVal);
      B2DEBUG(20, "RootParameterTracker::collectData4DoubleAlgorithms(), tc with type " << tcTypeName <<
              " and applied algorithm " << algoName <<
              " and got " << calcVal << " as a result!");
    } catch (AnalyzingAlgorithm<int>::No_refTC_Attached& anException) {
      B2WARNING("RootParameterTracker::collectData4DoubleAlgorithms(), Exception caught for tc with type " << tcTypeName <<
                " and applied algorithm " << algoName <<
                ". Failed with exception: " << anException.what() <<
                " -> skipping tc!");
    }
  }// looping over algorithms
}

◆ collectData4VecDoubleAlgorithms()

void collectData4VecDoubleAlgorithms	(	std::string	tcTypeName,
		const AnalizerTCInfo &	aTC
	)

protected

takes aTC with tcTypeName and applies the algorithms for it

Definition at line 100 of file RootParameterTracker.cc.

{
  auto* foundTCTypeData = m_algoDataVecDouble.find(
                            tcTypeName); // a KeyValBox with all algorithms and data collected to given tcTypeName
 
  // skip if there is nothing stored for this tcType:
  if (foundTCTypeData == nullptr) { return; }
 
  // looping over algorithms:
  for (auto& entry : *foundTCTypeData) {
    // increase readability:
    auto* anAlgorithm = entry.second.first;
    auto* dataVector = entry.second.second; // std::vector< vector < double>>
    // sanity check: key has to be compatible with stored algorithm:
    std::string algoName = anAlgorithm->getIDName();
    if (entry.first != algoName) {
      B2ERROR("RootParameterTracker::collectData4VecDoubleAlgorithms() key (" << entry.first <<
              ") of container does not match to its content (" << algoName <<
              ") - skipping entry! ");
      continue;
    }
    B2DEBUG(50, "RootParameterTracker::collectData4VecDoubleAlgorithms(), executing algorithm of type: " << algoName <<
            " with collected data-entries of " << dataVector->size());
 
    try {
      std::vector<double> calcVal = anAlgorithm->calcData(aTC);
      dataVector->push_back(calcVal);
      auto printVec = [&]() -> std::string {
        std::string out;
        for (double val : calcVal)
        {
          out += (" " + std::to_string(val));
        }
        return (out += "\n");
      };
      B2DEBUG(20, "RootParameterTracker::collectData4VecDoubleAlgorithms(), tc with type " << tcTypeName <<
              " and applied algorithm " << algoName <<
              " and got: " << printVec() <<
              " as a result!");
    }  catch (AnalyzingAlgorithm<std::vector<double>>::No_refTC_Attached& anException) {
      B2WARNING("RootParameterTracker::collectData4VecDoubleAlgorithms(), Exception caught for tc with type " << tcTypeName <<
                " and applied algorithm " << algoName <<
                ". Failed with exception: " << anException.what() <<
                " -> skipping tc!");
    }
  }// looping over algorithms
}

◆ fillRoot()

void fillRoot ( )

inline

fills tree/branches with their stuff, clear intermediate results afterwards

Definition at line 206 of file RootParameterTracker.h.

    {
      B2DEBUG(21, "RootParameterTracker::fillRoot(), Executing " << m_treeBox.size() << " ttrees.");
 
      m_file->cd(); //important! without this the famework root I/O (SimpleOutput etc) could mix with the root I/O of this module
//       m_file->ls();
 
      for (auto& boxEntry : m_treeBox) {
        int nBytesWritten = boxEntry.second->Fill();
        B2DEBUG(20, "RootParameterTracker::fillRoot() ttree " << boxEntry.first << " got " << nBytesWritten << " Bytes written");
        // boxEntry.second->Print();
      }
 
      for (auto& algoData2tcType : m_algoDataDouble) {
        for (auto& algoPack : algoData2tcType.second) {
          algoPack.second.second->clear();
        }
      }
 
      for (auto& algoData2tcType : m_algoDataInt) {
        for (auto& algoPack : algoData2tcType.second) {
          algoPack.second.second->clear();
        }
      }
 
      for (auto& algoData2tcType : m_algoDataVecDouble) {
        for (auto& algoPack : algoData2tcType.second) {
          algoPack.second.second->clear();
        }
      }
    }

◆ initialize()

void initialize	(	std::string	fileName,
		std::string	fileTreatment
	)

inline

creates rootFile, first parameter is fileName, second one specifies how the file shall be treated.

Valid values for fileTreatment: 'RECREATE' or 'UPDATE'.

calling it more than once will result in a B2FATAL-message.

Definition at line 147 of file RootParameterTracker.h.

    {
      if (fileTreatment != std::string("RECREATE") and fileTreatment != std::string("UPDATE")) {
        B2FATAL("RootParameterTracker::initialize(), specified fileTreatment is " << fileTreatment <<
                ", which is invalid, please read the documentation!");
      }
 
      if (m_file != nullptr) {
        B2FATAL("RootParameterTracker::initialize(), there was a file already linked to this ParameterTracker, which is invalid, please read the documentation!");
      }
      B2DEBUG(20, "RootParameterTracker::initialize(), given parameters are fileName/fileTreatment: " << fileName << "/" <<
              fileTreatment);
      m_file = new TFile(fileName.c_str(), fileTreatment.c_str()); // alternative: UPDATE
      m_file->ls();
    }

◆ prepareTTree()

TTree * prepareTTree ( std::string tcTypeName )

inlineprotected

checks if ttree for given tcTypeName exists and creates it if not.

returns ttree for given tcType

make sure that tree exists:

Definition at line 97 of file RootParameterTracker.h.

    {
      if (m_file == nullptr) {
        B2FATAL("RootParameterTracker::prepareTTree(), Root file not initialized yet! Please call RootParameterTracker::initialize(...) first!");
      }
      m_file->cd();
      //   m_file->ls();
 
      TTree** tree4tcType = m_treeBox.find(tcTypeName);
      if (tree4tcType == nullptr) {
        m_treeBox.push_back({
          tcTypeName,
          new TTree(tcTypeName.c_str(), (std::string("collects data collected to tcType ") + tcTypeName).c_str())
        }
                           );
        tree4tcType = m_treeBox.find(tcTypeName);
        B2WARNING("RootParameterTracker::prepareTTree: new tree for tcType " << tcTypeName << " created, m_treeBox has now " <<
                  m_treeBox.size() << " entries");
        return *tree4tcType;
      }
 
      B2WARNING("RootParameterTracker::prepareTTree: ttree for tcType " << tcTypeName << " is reused, m_treeBox has " << m_treeBox.size()
                << " entries");
      return *tree4tcType;
    }

◆ terminate()

void terminate ( )

inline

final cleanup and closing rootFile

Definition at line 240 of file RootParameterTracker.h.

    {
      B2DEBUG(20, "RootParameterTracker::terminate(), Writing results to root-file and clean up heap.");
      if (m_file == nullptr) {
        B2WARNING("RootParameterTracker::terminate(): no rootFile found! skipping writing data into root file!");
        return;
      }
 
      m_file->cd(); //important! without this the famework root I/O (SimpleOutput etc) could mix with the root I/O of this module
      m_file->ls();
 
      for (auto& boxEntry : m_treeBox) {
        boxEntry.second->Write();
 
        if (LogSystem::Instance().isLevelEnabled(LogConfig::c_Debug, 5, PACKAGENAME()) == true) {
          B2DEBUG(20, "RootParameterTracker::terminate(), TTree " << boxEntry.first << " was written:");
          // boxEntry.second->Print();
        }
      }
      m_file->Close();
 
      for (auto& algoData2tcType : m_algoDataDouble) {
        for (auto& algoPack : algoData2tcType.second) {
          delete algoPack.second.first; // algorithm
          delete algoPack.second.second; // vector(data) to algorithm
        }
      }
 
      for (auto& algoData2tcType : m_algoDataInt) {
        for (auto& algoPack : algoData2tcType.second) {
          delete algoPack.second.first; // algorithm
          delete algoPack.second.second; // vector(data) to algorithm
        }
      }
 
      for (auto& algoData2tcType : m_algoDataVecDouble) {
        for (auto& algoPack : algoData2tcType.second) {
          delete algoPack.second.first; // algorithm
          delete algoPack.second.second; // vector(data) to algorithm
        }
      }
    }

Member Data Documentation

◆ m_algoDataDouble

AlgoDataBox<double> m_algoDataDouble

protected

contains all algorithms and its data storing one double per TC

Definition at line 81 of file RootParameterTracker.h.

◆ m_algoDataInt

AlgoDataBox<int> m_algoDataInt

protected

contains all algorithms and its data storing one int per TC

Definition at line 85 of file RootParameterTracker.h.

◆ m_algoDataVecDouble

AlgoDataBox<std::vector<double> > m_algoDataVecDouble

protected

contains all algorithms and its data storing one vector of double per TC

Definition at line 89 of file RootParameterTracker.h.

◆ m_file

TFile* m_file

protected

stores pointer to file

Definition at line 93 of file RootParameterTracker.h.

◆ m_treeBox

StringKeyBox<TTree*> m_treeBox

protected

contains all the trees for rootFile-filling later-on.

Key is tcTypeName as a string Value are TTrees, one tree for each tcType

Definition at line 77 of file RootParameterTracker.h.

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

tracking/trackFindingVXD/analyzingTools/include/RootParameterTracker.h
tracking/trackFindingVXD/analyzingTools/src/RootParameterTracker.cc

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ AlgoDataBox

◆ AnalyzingAlgorithm

◆ StringKeyBox

Constructor & Destructor Documentation

◆ RootParameterTracker()

Member Function Documentation

◆ addParameters4DoubleAlgorithms()

◆ addParameters4IntAlgorithms()

◆ addParameters4VecDoubleAlgorithms()

◆ collectData()

◆ collectData4DoubleAlgorithms()

◆ collectData4IntAlgorithms()

◆ collectData4VecDoubleAlgorithms()

◆ fillRoot()

◆ initialize()

◆ prepareTTree()

◆ terminate()

Member Data Documentation

◆ m_algoDataDouble

◆ m_algoDataInt

◆ m_algoDataVecDouble

◆ m_file

◆ m_treeBox