File ROOTWriter.h

namespace podio

class ROOTWriter

#include <podio/ROOTWriter.h>

The ROOTWriter writes podio files into ROOT files using TTrees.

Each category gets its own TTree. Additionally, there is a podio_metadata TTree that contains metadata that is necessary for interpreting the files for reading.

Files written with the ROOTWriter can be read with the ROOTReader.

Public Functions

ROOTWriter(const std::string &filename)

Create a ROOTWriter to write to a file.

Note

Existing files will be overwritten without warning.

Parameters:

filename – The path to the file that will be created.

~ROOTWriter()

ROOTWriter destructor.

This also takes care of writing all the necessary metadata to read files back again.

ROOTWriter(const ROOTWriter&) = delete

The ROOTWriter is not copy-able.

ROOTWriter &operator=(const ROOTWriter&) = delete

The ROOTWriter is not copy-able.

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

Store the given frame with the given category.

This stores 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.

Parameters:

• frame – The Frame to store

• category – The category name under which this Frame should be stored

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

Store the given Frame with the given category.

This stores only the desired collections and not the complete 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.

Parameters:

• frame – The Frame to store

• category – The category name under which this Frame should be stored

• collsToWrite – The collection names that should be written

void finish()

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

Note

The destructor will also call this, so letting a ROOTWriter go out of scope is also a viable way to write a readable file

std::tuple<std::vector<std::string>, std::vector<std::string>> checkConsistency(const std::vector<std::string> &collsToWrite, const std::string &category) const

Check whether the collsToWrite are consistent with the state of the passed category.

Note

This will only be a meaningful check if the first Frame of the passed category has already been written. Also, this check is rather expensive as it has to effectively do two set differences.

Parameters:

• collsToWrite – The collection names that should be checked for consistency

• category – The category name for which consistency should be checked

Returns:

two vectors of collection names. The first one contains all the names that were missing from the collsToWrite but were present in the category. The second one contains the names that are present in the collsToWrite only. If both vectors are empty the category and the passed collsToWrite are consistent.

Private Functions

void initBranches(CategoryInfo &catInfo, const std::vector<root_utils::StoreCollection> &collections, podio::GenericParameters &parameters)

Initialize the branches for this category.

CategoryInfo &getCategoryInfo(const std::string &category)

Get the (potentially uninitialized category information for this category)

Private Members

std::unique_ptr<TFile> m_file = {nullptr}

The storage file.

std::unordered_map<std::string, CategoryInfo> m_categories = {}

All categories.

DatamodelDefinitionCollector m_datamodelCollector = {}

bool m_finished = {false}

Whether writing has been actually done.

Private Static Functions

static void resetBranches(CategoryInfo &categoryInfo, const std::vector<root_utils::StoreCollection> &collections)

static void fillParams(CategoryInfo &catInfo, const GenericParameters &params)

Fill the parameter keys and values into the CategoryInfo storage.

struct CategoryInfo

Helper struct to group together all necessary state to write / process a given category.

Created during the first writing of a category

Public Members

TTree *tree = {nullptr}

The TTree to which this category is written.

std::vector<root_utils::CollectionBranches> branches = {}

The branches for this category.

std::vector<root_utils::CollectionWriteInfoT> collInfo = {}

Collection info for this category.

podio::CollectionIDTable idTable = {}

The collection id table for this category.

std::vector<std::string> collsToWrite = {}

The collections to write for this category.

root_utils::ParamStorage<int> intParams = {}

root_utils::ParamStorage<float> floatParams = {}

root_utils::ParamStorage<double> doubleParams = {}

root_utils::ParamStorage<std::string> stringParams = {}