podio::ROOTFrameWriter Class Reference

#include <ROOTFrameWriter.h>

Public Member Functions
	ROOTFrameWriter (const std::string &filename)
	~ROOTFrameWriter ()=default
	ROOTFrameWriter (const ROOTFrameWriter &)=delete
ROOTFrameWriter &	operator= (const ROOTFrameWriter &)=delete
void	writeFrame (const podio::Frame &frame, const std::string &category)
void	writeFrame (const podio::Frame &frame, const std::string &category, const std::vector< std::string > &collsToWrite)
void	finish ()

Detailed Description

Definition at line 24 of file ROOTFrameWriter.h.

Constructor & Destructor Documentation

ROOTFrameWriter() [1/2]

podio::ROOTFrameWriter::ROOTFrameWriter

(

const std::string &

filename

)

Definition at line 13 of file ROOTFrameWriter.cc.

                                                          {
  m_file = std::make_unique<TFile>(filename.c_str(), "recreate");
}

~ROOTFrameWriter()

podio::ROOTFrameWriter::~ROOTFrameWriter ( )

default

ROOTFrameWriter() [2/2]

podio::ROOTFrameWriter::ROOTFrameWriter ( const ROOTFrameWriter &  )

delete

Member Function Documentation

finish()

void podio::ROOTFrameWriter::finish

(

)

Write the current file, including all the necessary metadata to read it again.

Definition at line 120 of file ROOTFrameWriter.cc.

                             {
  auto* metaTree = new TTree(root_utils::metaTreeName, "metadata tree for podio I/O functionality");
  metaTree->SetDirectory(m_file.get());
 
  // Store the collection id table and collection info for reading in the meta tree
  for (/*const*/ auto& [category, info] : m_categories) {
    metaTree->Branch(root_utils::idTableName(category).c_str(), &info.idTable);
    metaTree->Branch(root_utils::collInfoName(category).c_str(), &info.collInfo);
  }
 
  // Store the current podio build version into the meta data tree
  auto podioVersion = podio::version::build_version;
  metaTree->Branch(root_utils::versionBranchName, &podioVersion);
 
  auto edmDefinitions = m_datamodelCollector.getDatamodelDefinitionsToWrite();
  metaTree->Branch(root_utils::edmDefBranchName, &edmDefinitions);
 
  metaTree->Fill();
 
  m_file->Write();
  m_file->Close();
}

operator=()

ROOTFrameWriter & podio::ROOTFrameWriter::operator= ( const ROOTFrameWriter &  )

delete

writeFrame() [1/2]

void podio::ROOTFrameWriter::writeFrame	(	const podio::Frame &	frame,
		const std::string &	category
	)

Store the given frame with the given category. Store all available collections from the Frame.

NOTE: The contents of the first Frame that is written in this way determines the contents that will be written for all subsequent Frames.

Definition at line 17 of file ROOTFrameWriter.cc.

                                                                                   {
  writeFrame(frame, category, frame.getAvailableCollections());
}

Referenced by writeFrame().

writeFrame() [2/2]

void podio::ROOTFrameWriter::writeFrame	(	const podio::Frame &	frame,
		const std::string &	category,
		const std::vector< std::string > &	collsToWrite
	)

Store the given Frame with the given category. Store only the collections that are passed.

NOTE: The contents of the first Frame that is written in this way determines the contents that will be written for all subsequent Frames.

Definition at line 21 of file ROOTFrameWriter.cc.

                                                                           {
  auto& catInfo = getCategoryInfo(category);
  // Use the TTree as proxy here to decide whether this category has already
  // been initialized
  if (catInfo.tree == nullptr) {
    catInfo.idTable = frame.getCollectionIDTableForWrite();
    catInfo.collsToWrite = collsToWrite;
    catInfo.tree = new TTree(category.c_str(), (category + " data tree").c_str());
    catInfo.tree->SetDirectory(m_file.get());
  }
 
  std::vector<StoreCollection> collections;
  collections.reserve(catInfo.collsToWrite.size());
  for (const auto& name : catInfo.collsToWrite) {
    auto* coll = frame.getCollectionForWrite(name);
    collections.emplace_back(name, const_cast<podio::CollectionBase*>(coll));
 
    m_datamodelCollector.registerDatamodelDefinition(coll, name);
  }
 
  // We will at least have a parameters branch, even if there are no
  // collections
  if (catInfo.branches.empty()) {
    initBranches(catInfo, collections, const_cast<podio::GenericParameters&>(frame.getParameters()));
 
  } else {
    resetBranches(catInfo.branches, collections, &const_cast<podio::GenericParameters&>(frame.getParameters()));
  }
 
  catInfo.tree->Fill();
}

---

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

• ROOTFrameWriter.h
• ROOTFrameWriter.cc