framework::EventFile Class Reference

This class manages all ROOT file input/output operations. More...

#include <EventFile.h>

Public Member Functions
	EventFile (const framework::config::Parameters &params, const std::string &filename, EventFile *parent, bool isOutputFile, bool isSingleOutput, bool isLoopable)
	Constructor to make a general file.
	EventFile (const framework::config::Parameters &param, const std::string &fileName, bool isLoopable)
	Constructor to make a pileup overlay file.
	EventFile (const framework::config::Parameters &param, const std::string &fileName, EventFile *parent, bool isSingleOutput=false)
	Class constructor for cloning data from a "parent" file.
	EventFile (const framework::config::Parameters &params, const std::string &fileName)
	Class constructor to make a file to read in an event root file.
	~EventFile ()
	Destructor.
bool	isCorrupted () const
	Check if the file we have is corrupted.
void	addDrop (const std::string &rule)
	Add a rule for dropping collections from the output.
void	setupEvent (Event *evt)
	Set an Event object containing the event data to work with this file.
void	updateParent (EventFile *parent)
	Change pointer to different parent file.
Event *	getEvent ()
	Get the Event object containing the event data.
bool	nextEvent (bool storeCurrentEvent=true)
	Prepare the next event.
int	skipToEvent (int offset)
	Skip events using an offset.
void	writeRunHeader (std::shared_ptr< ldmx::RunHeader > runHeader)
	Write the run header into the run map.
void	writeRunTree (bool completed=false)
	Write the map of run headers to the file as a TTree of RunHeader.
ldmx::RunHeader *	getRunHeaderPtr (int runNumber)
	Update the RunHeader for a given run, if it exists in the input file.
ldmx::RunHeader &	getRunHeader (int runNumber)
	Get the RunHeader for a given run, if it exists in the input file.
const std::string &	getFileName ()
std::vector< int >	getIncompleteRuns () const
	The runs in this file whose writer did not close cleanly.

Private Member Functions
void	importRunHeaders ()
	Fill the internal map of run numbers to RunHeader objects from the input file.

Private Attributes
Long64_t	entries_ {-1}
	The number of entries in the tree.
Long64_t	ientry_ {-1}
	The current entry in the tree.
std::string	file_name_
	The file name.
bool	is_output_file_
	True if file is an output file being written to disk.
bool	is_single_output_
	True if there is only one output file.
bool	is_loopable_ {false}
	True if this is an input file with pileup overlay events *‍/.
TFile *	file_ {nullptr}
	The backing TFile for this EventFile.
TTree *	tree_ {nullptr}
	The tree with event data.
EventFile *	parent_ {nullptr}
	A parent file containing event data.
Event *	event_ {nullptr}
	The object containing the actual event data (trees and branches).
std::vector< std::pair< std::string, bool > >	pre_clone_rules_
	Pre-clone rules.
std::vector< std::string >	reactivate_rules_
	Vector of drop rules that have been parsed and need to be used to reactivate these branches on the input tree.
std::map< int, std::shared_ptr< ldmx::RunHeader > >	run_map_
	Map of run numbers to RunHeader objects (owned via shared_ptr)
TTree *	run_tree_ {nullptr}
	The run tree, owned by file_ once written.
bool	run_headers_have_completeness_ {false}
	True when the run headers we read were written with a completion flag.

Detailed Description

This class manages all ROOT file input/output operations.

Definition at line 28 of file EventFile.h.

Constructor & Destructor Documentation

EventFile() [1/4]

framework::EventFile::EventFile	(	const framework::config::Parameters &	params,
		const std::string &	filename,
		EventFile *	parent,
		bool	isOutputFile,
		bool	isSingleOutput,
		bool	isLoopable )

Constructor to make a general file.

This is not used directly, but it is called in the more specialised constructors. This method is mainly focused on reducing code copying.

Parameters

[in]	params	The parameters used to configure this EventFile.
[in]	filename	the name of the file to read/write
[in]	parent	a pointer to the parent file to copy
[in]	isOutputFile	true if this file is written out
[in]	isSingleOutput	true if only one output file is being written to
[in]	isLoopable	true for an input file where events can be reused

Definition at line 30 of file EventFile.cxx.

    : file_name_(filename),
      is_output_file_(is_output_file),
      is_single_output_(is_single_output),
      is_loopable_(is_loopable),
      parent_(parent) {
  if (is_output_file_) {
    // we are writting out so open the file and make sure it is writable
    file_ = new TFile(file_name_.c_str(), "RECREATE");
    if (!file_->IsOpen() or !file_->IsWritable()) {
      EXCEPTION_RAISE("FileError",
                      "Output file '" + file_name_ + "' is not writable.");
    }
 
    // set compression settings
    //  Check out the TFile constructor for explanation of how this integer is
    //  built Short Reference: setting = 100*algorithem + level algorithm = 0
    //  ==> use global default
    file_->SetCompressionSettings(params.get<int>("compression_setting", 9));
 
    if (parent_) {
      // output file when there are input files
      //  might be drop/keep rules, so we should have these rules to make sure
      //  it works
 
      // turn everything on
      //  hypothetically could turn everything off? Doesn't work for some
      //  reason?
      pre_clone_rules_.emplace_back("*", true);
 
      // except EventHeader (copies over to output)
      pre_clone_rules_.emplace_back("EventHeader*", true);
 
      // reactivate all branches so default behavior is drop
      reactivate_rules_.push_back("*");
    }
  } else {
    // open file with only reading enabled
    file_ = new TFile(file_name_.c_str());
    // double check that file is open
    if (!file_->IsOpen()) {
      EXCEPTION_RAISE("FileError", "Input file '" + file_name_ +
                                       "' is not readable or does not exist.");
    }
 
    bool skip_corrupted = params.get<bool>("skip_corrupted_input_files", false);
 
    // make sure file is not a zombie file
    // (i.e. process ended without closing or the file was corrupted some other
    // way)
    if (file_->IsZombie()) {
      if (not skip_corrupted) {
        EXCEPTION_RAISE("FileError", "Input file '" + file_name_ +
                                         "' is corrupted. Framework will not "
                                         "attempt to recover this file.");
      }
      return;
    }
 
    // Get the tree name from the configuration
    auto tree_name{params.get<std::string>("tree_name")};
    tree_ = static_cast<TTree*>(file_->Get(tree_name.c_str()));
    if (!tree_) {
      if (not skip_corrupted) {
        EXCEPTION_RAISE("FileError", "File '" + file_name_ +
                                         "' does not have a TTree named '" +
                                         tree_name + "' in it.");
      }
      return;
    }
    entries_ = tree_->GetEntriesFast();
  }
 
  importRunHeaders();
}

References entries_, file_, file_name_, framework::config::Parameters::get(), importRunHeaders(), is_output_file_, parent_, pre_clone_rules_, reactivate_rules_, and tree_.

EventFile() [2/4]

framework::EventFile::EventFile	(	const framework::config::Parameters &	param,
		const std::string &	fileName,
		bool	isLoopable )

Constructor to make a pileup overlay file.

This is an additional input file from which collections are pulled to be overlaid with simulated hit collections.

Parameters

[in]	params	The parameters used to configure this EventFile.
	fileName	The file name.
	isLoopable	true if we want to reset the event counter and keep processing from the start when we hit the end of the event tree in this input file (set in the call in the producer)

Definition at line 109 of file EventFile.cxx.

    : EventFile(params, filename, nullptr, false, false, is_loopable) {}

EventFile() [3/4]

framework::EventFile::EventFile	(	const framework::config::Parameters &	param,
		const std::string &	fileName,
		EventFile *	parent,
		bool	isSingleOutput = false )

Class constructor for cloning data from a "parent" file.

This is used for output files when there is an input file. (OR for files with a parent EventFile to clone)

Parameters

[in]	params	The parameters used to configure this EventFile.
[in]	fileName	The file name.
[in]	parent	Parent file for cloning data tree.
[in]	isSingleOutput	boolean check if only one output file is being written to

Definition at line 117 of file EventFile.cxx.

    : EventFile(params, filename, parent, true, is_single_output, false) {}

EventFile() [4/4]

framework::EventFile::EventFile	(	const framework::config::Parameters &	params,
		const std::string &	fileName )

Class constructor to make a file to read in an event root file.

This constructor just wraps the constructor above and sets the parent to null and the parameters isOutputFile/isSingleOutput to false.

This is used for all input files.

Parameters

[in]	params	The parameters used to configure this EventFile.
[in]	fileName	The file name.

Definition at line 113 of file EventFile.cxx.

    : EventFile(params, filename, nullptr, false, false, false) {}

~EventFile()

framework::EventFile::~EventFile

(

)

Destructor.

Make sure to close the file when we destruct

Definition at line 122 of file EventFile.cxx.

                      {
  // Before an output file, the Event tree needs to be written.
  if (tree_ && is_output_file_) {
    // make sure we are in output file before writing
    file_->cd();
    tree_->Write();
    file_->Close();
  }
}

References file_, is_output_file_, and tree_.

Member Function Documentation

addDrop()

void framework::EventFile::addDrop

(

const std::string &

rule

)

Add a rule for dropping collections from the output.

This needs to be called after setupEvent. This method uses the event to help drop collections.

The rules should be of the following form: <drop,keep, or ignore> exp where exp is an expression that matches the collectionName. ignore ==> any branch with name matching exp is not even read in from the input file (if it exists) keep ==> any branch with name matching exp is read in from the input (if exists) and written to output (if exists) drop ==> any branch with name matching exp is read in from the input (if exists) and NOT written to output

The default behavior for all branches is keep.

ROOT uses the internal TRegexp to match branch names to the passed expression and set the status of the branch (whether it will be read or not). This internal object has different rules than real regular expressions, so it is best to keep it safe and only use asterisks or full names. Additionally, the rules you pass are analyzed in succession, so you can go from something more general to something more specific.

For example to drop all EcalSimHits.* drop EcalSimHits.*

or drop scoring plane collections drop .*ScoringPlane.*

or drop scoring plane collections but keep EcalScoringPlane collection drop .*ScoringPlane.* keep EcalScoringPlane.*

Note

The Event::getImpl overrides any ignore rules for the input file in order to avoid any seg faults. The items accessed will still be dropped.

Parameters

rule	The rule for dropping collections.

Definition at line 137 of file EventFile.cxx.

                                             {
  int offset;
  bool is_keep = false, is_drop = false, is_ignore = false;
  // keywords must appear at the start of the rule string
  if (rule.find("keep") == 0) {
    offset = 4;
    is_keep = true;
  } else if (rule.find("drop") == 0) {
    offset = 4;
    is_drop = true;
  } else if (rule.find("ignore") == 0) {
    offset = 6;
    is_ignore = true;
  }
 
  // none of (keep,drop,ignore) was provided => not valid rule
  if (int(is_keep) + int(is_drop) + int(is_ignore) != 1) return;
 
  std::string srule = rule.substr(offset);
  size_t i;
  for (i = srule.find_first_of(" \t\n\r"); i != std::string::npos;
       i = srule.find_first_of(" \t\n\r"))
    srule.erase(i, 1);
 
  // name of branch is not given
  if (srule.length() == 0) return;
 
  // add wild card at end for matching purposes
  if (srule.back() != '*') srule += ".*";  // add wildcard to back
 
  // Guard: EventHeader must never be dropped or ignored
  if (is_drop or is_ignore) {
    regex_t guard_reg;
    if (regcomp(&guard_reg, srule.c_str(),
                REG_EXTENDED | REG_ICASE | REG_NOSUB) == 0) {
      bool matches_event_header =
          (regexec(&guard_reg, ldmx::EventHeader::BRANCH.c_str(), 0, 0, 0) ==
           0);
      regfree(&guard_reg);
      if (matches_event_header) {
        EXCEPTION_RAISE("BadRule",
                        "Drop/ignore rule '" + rule +
                            "' would affect EventHeader which is required by "
                            "the framework and cannot be removed.");
      }
    }
  }
 
  if (is_keep) {
    // turn both the input and output tree's on
    // root needs . removed otherwise it gets cranky
    srule.erase(std::remove(srule.begin(), srule.end(), '.'), srule.end());
    pre_clone_rules_.emplace_back(srule, true);
    // this branch will then be copied over into output tree and be active
  } else if (is_ignore) {
    // don't even read it from the input file
    // pass regex (with dots) to event bus so setInputTree skips these branches
    event_->addIgnore(srule);  // requires event_ to be set
    // root needs . removed otherwise it gets cranky
    srule.erase(std::remove(srule.begin(), srule.end(), '.'), srule.end());
    // warn if this rule drops all collections
    if (srule == "*")
      ldmx_log(fatal) << "Ignore rule '" << rule
                      << "' will hide all input collections from processors.";
    pre_clone_rules_.emplace_back(srule, false);
    // these branches won't be copied over into output tree
  } else if (is_drop) {
    // drop means allowing it on reading but not writing
    // pass these regex to event bus so Event::add knows
    event_->addDrop(srule);  // requires event_ to be set
 
    // root needs . removed otherwise it gets cranky
    srule.erase(std::remove(srule.begin(), srule.end(), '.'), srule.end());
    // warn if this rule drops all collections
    if (srule == "*")
      ldmx_log(fatal) << "Drop rule '" << rule
                      << "' will drop all collections from the output file.";
    pre_clone_rules_.emplace_back(srule, false);
    // these branches won't be copied over into output tree
    // reactivate input branch after clone
    reactivate_rules_.push_back(srule);
  }
}

References framework::Event::addDrop(), framework::Event::addIgnore(), ldmx::EventHeader::BRANCH, event_, pre_clone_rules_, and reactivate_rules_.

Referenced by framework::Process::run().

getEvent()

Event * framework::EventFile::getEvent ( )

inline

Get the Event object containing the event data.

Returns

The Event object containing event data.

Definition at line 183 of file EventFile.h.

{ return event_; };

References event_.

getFileName()

const std::string & framework::EventFile::getFileName ( )

inline

Returns

the name of the ROOT file being managed.

Definition at line 261 of file EventFile.h.

{ return file_name_; }

References file_name_.

Referenced by framework::Process::run().

getIncompleteRuns()

std::vector< int > framework::EventFile::getIncompleteRuns

(

)

const

The runs in this file whose writer did not close cleanly.

Events are missing from the end of any such run, so processing it silently would produce a biased sample.

A file written before ldmx::RunHeader::VERSION_WITH_COMPLETED carries no completion flag. We cannot say anything about those runs, so they are left out rather than reported as incomplete.

Returns

run numbers of the incomplete runs, empty if the file is whole

Definition at line 441 of file EventFile.cxx.

                                                  {
  std::vector<int> incomplete;
  // without the flag on disk we have nothing to judge by
  if (not run_headers_have_completeness_) return incomplete;
  for (const auto& [num, run_header] : run_map_) {
    if (not run_header->isCompleted()) incomplete.push_back(num);
  }
  return incomplete;
}

References run_headers_have_completeness_, and run_map_.

Referenced by framework::Process::run().

getRunHeader()

ldmx::RunHeader & framework::EventFile::getRunHeader

(

int

runNumber

)

Get the RunHeader for a given run, if it exists in the input file.

Parameters

runNumber

The run number.

Returns

The RunHeader from the input file.

Exceptions

Exception

if there is no RunHeader in the map with the given run number.

Definition at line 432 of file EventFile.cxx.

                                                     {
  ldmx::RunHeader* rh{this->getRunHeaderPtr(run_number)};
  if (rh != nullptr) {
    return *rh;
  }
  EXCEPTION_RAISE("RunHeader", "Unable to find header for run " +
                                   std::to_string(run_number));
}

References getRunHeaderPtr().

getRunHeaderPtr()

ldmx::RunHeader * framework::EventFile::getRunHeaderPtr

(

int

runNumber

)

Update the RunHeader for a given run, if it exists in the input file.

Parameters

[in]

runNumber

The run number.

Returns

pointer to the header corresponding to the run number

Note

the returned pointer will be nullptr if the run was not found

Definition at line 425 of file EventFile.cxx.

                                                        {
  if (run_map_.find(run_number) != run_map_.end()) {
    return run_map_.at(run_number).get();
  }
  return nullptr;
}

References run_map_.

Referenced by getRunHeader(), and framework::Process::run().

importRunHeaders()

void framework::EventFile::importRunHeaders ( )

private

Fill the internal map of run numbers to RunHeader objects from the input file.

If this file is an output file and parent_ and parent_->file_ are valid pointers, then the run headers are imported from parent_->file_.

Otherwise, we try to import run headers from file_.

Does not check if any run headers are getting overwritten!

RunHeaders read in from this function are stored as shared_ptr.

Note

This function does nothing if parent_->file_ and file_ are nullptrs.

Definition at line 451 of file EventFile.cxx.

                                 {
  // choose which file to import from
  auto the_import_file{file_};  // if this is an input file
  if (is_output_file_ and parent_ and parent_->file_)
    the_import_file = parent_->file_;  // output file with input parent
  else if (is_output_file_)
    return;  // output file, no input parent to read from
 
  if (the_import_file) {
    // the file exist
    TTreeReader old_run_tree("LDMX_Run", the_import_file);
    TTreeReaderValue<ldmx::RunHeader> old_run_header(old_run_tree, "RunHeader");
    // older headers stream into a default false, which means nothing
    run_headers_have_completeness_ =
        onDiskRunHeaderVersion(old_run_tree.GetTree()) >=
        ldmx::RunHeader::VERSION_WITH_COMPLETED;
    // TODO check that setup went correctly
    while (old_run_tree.Next()) {
      auto* old_run_header_ptr = old_run_header.Get();
      if (old_run_header_ptr != nullptr) {
        int run_number = old_run_header_ptr->getRunNumber();
        run_map_[run_number] =
            std::make_shared<ldmx::RunHeader>(*old_run_header_ptr);
      }
    }
  }
 
  return;
}

References file_, is_output_file_, parent_, run_headers_have_completeness_, run_map_, and ldmx::RunHeader::VERSION_WITH_COMPLETED.

Referenced by EventFile(), and updateParent().

isCorrupted()

bool framework::EventFile::isCorrupted

(

)

const

Check if the file we have is corrupted.

The check on if the file is corrupted is only helpful for input files, but we attempt to have a resonable definition for output files as well.

Input Files

There are two ways a file can be corrupted and these may not be mutually exclusive.

1. The LDMX_Events tree does not exist within it.
2. The IsZombie flag of the TFile is set

Output Files

For output files, we just check the IsZombie flag of the TFile. Again, since we are actively writing to this file, a corruption check is not very stable.

Definition at line 132 of file EventFile.cxx.

                                  {
  if (is_output_file_) return file_->IsZombie();
  return (!tree_ or file_->IsZombie() or file_->GetNkeys() == 0);
}

References file_, is_output_file_, and tree_.

Referenced by framework::Process::run().

nextEvent()

bool framework::EventFile::nextEvent

(

bool

storeCurrentEvent = true

)

Prepare the next event.

We do the necessary set-up if ientry_ < 0. This means if we are an output file with a parent file, we clone our parent tree to our tree so we have the same branches.

After the first entry (when ientry_ >= 0), we "close up" the last event, filling our tree if we storeCurrentEvent is true and telling the event bus to clear.

Going to the next event depends on the configuration of the event file. THere are three cases.

1. We have a parent file - Just follow the parent's lead by calling the parent's nextEvent.
2. We are an output file (and we don't have a parent file). Just increment the number of entries and the entry index_.
3. We are an input file. Now we need to load the next entry of the our tree into the event bus objects. If we are configured to be "loopable", then we will reset ientry_ to -1 when we reach the last event. Otherwise, we will return false as a stopping condition.

Parameters

[in]

storeCurrentEvent

Should we save the current event to the output (if we are an output file)?

Returns

If event was prepared/read successfully.

Definition at line 221 of file EventFile.cxx.

                                                {
  if (ientry_ < 0) {
    // first entry of this file
    if (parent_) {
      // we have a parent file
      if (!parent_->tree_) {
        // this should _never_ happen
        EXCEPTION_RAISE("EventFile", "No event tree in the file");
      }
      // Only clone parent tree if either
      //  1) There is no tree setup yet (first input file)
      //  2) This is not single output (new input file --> new output file)
      if (!tree_ or !is_single_output_) {
        // clones parent_->tree_ to our tree_ keeping drop/keep rules in mind
        // clone tree (only copies over branches that are active on input tree)
 
        file_->cd();  // go into output file
 
        for (auto const& rule_pair : pre_clone_rules_)
          parent_->tree_->SetBranchStatus(rule_pair.first.c_str(),
                                          rule_pair.second);
 
        tree_ = parent_->tree_->CloneTree(0);
 
        // reactivate any drop branches (drop) on input tree
        for (auto const& rule : reactivate_rules_)
          parent_->tree_->SetBranchStatus(rule.c_str(), 1);
      }
      event_->setInputTree(parent_->tree_);
      event_->setOutputTree(tree_);
    }  // we have a parent file
  } else {
    // later than first entry of file
    if (is_output_file_) {
      event_->beforeFill();
      if (storeCurrentEvent)  // we should store before moving on
        tree_->Fill();        // fill the clones...
    }  // we are an output file
 
    // the event bus may not be defined
    //  for this file if we are input file and
    //  there is an output file during this run
    if (event_) {
      event_->clear();
      event_->onEndOfEvent();
    }  // event bus defined
  }  // first or not first entry in this file
 
  if (parent_) {
    // we have a parent, follow their lead
    if (!parent_->nextEvent()) {
      return false;
    }
    ientry_ = parent_->ientry_;
    entries_++;
  } else if (is_output_file_) {
    // we don't have a parent and we
    //  are an output file
    // Just increment the number of entries
    //  and the index_ of the current entry
    ientry_++;
    entries_++;
  } else {
    // we don't have a parent and
    //  we aren't an output file
    // try to load another entry from our tree
    if (ientry_ + 1 >= entries_) {
      if (is_loopable_) {
        // reset the event counter: reuse events from start of pileup tree
        ientry_ = -1;
      } else
        return false;
    }
    ientry_++;
    tree_->GetEntry(ientry_);
  }
 
  // if we have an event_
  //  make sure it is iterated as well
  return event_ ? event_->nextEvent() : true;
}

References framework::Event::beforeFill(), framework::Event::clear(), entries_, event_, file_, ientry_, is_loopable_, is_output_file_, is_single_output_, framework::Event::nextEvent(), nextEvent(), framework::Event::onEndOfEvent(), parent_, pre_clone_rules_, reactivate_rules_, framework::Event::setInputTree(), framework::Event::setOutputTree(), and tree_.

Referenced by nextEvent(), and framework::Process::run().

setupEvent()

void framework::EventFile::setupEvent

(

Event *

evt

)

Set an Event object containing the event data to work with this file.

Parameters

evt	The Event object with event data.

Definition at line 303 of file EventFile.cxx.

                                     {
  event_ = evt;
  if (is_output_file_) {
    // we are an output file
    if (!tree_ && !parent_) {
      // we don't have a tree and we don't have a parent
      //  ==> *Production Mode* create a new tree
      tree_ = event_->createTree();
      ientry_ = 0;
      entries_ = 0;
    }
 
    if (parent_) {
      // we have a parent file so give
      //  the parent's tree to the event bus
      //  as the input tree
      event_->setInputTree(parent_->tree_);
    }
 
    // give our tree to the event as the output tree
    event_->setOutputTree(tree_);
  } else {
    // we are an input file
    //  so give our tree to the event as input tree
    event_->setInputTree(tree_);
  }  // output or input file
}

References framework::Event::createTree(), entries_, event_, ientry_, is_output_file_, parent_, framework::Event::setInputTree(), framework::Event::setOutputTree(), and tree_.

Referenced by framework::Process::run().

skipToEvent()

int framework::EventFile::skipToEvent

(

int

offset

)

Skip events using an offset.

Used in pileup overlay.

Returns

New event number if read successfully, else -1.

Definition at line 331 of file EventFile.cxx.

                                     {
  // make sure the event number exists
  ientry_ = offset % entries_ - 1;
  return ientry_;
}

References entries_, and ientry_.

updateParent()

void framework::EventFile::updateParent

(

EventFile *

parent

)

Change pointer to different parent file.

We assume that the parent file is an EventFile configured to be an input file. This allows us to assume that the tree_ member variable of parent is valid.

Parameters

parent

pointer to new parent file

Definition at line 337 of file EventFile.cxx.

                                              {
  parent_ = parent;
 
  // we can assume parent_->tree_ is valid
  //  because (for input files) the tree_ is imported
  //  from the file and then checked if its valid in the
  //  EventFile constructor
 
  // Enter output file
  file_->cd();
 
  // need to turn on/off the same branches as in the initial setup...
  for (auto const& rule_pair : pre_clone_rules_)
    parent_->tree_->SetBranchStatus(rule_pair.first.c_str(), rule_pair.second);
 
  // Copy over addresses from the new parent
  parent_->tree_->CopyAddresses(tree_);
 
  // and reactivate any dropping rules
  for (auto const& rule : reactivate_rules_)
    parent_->tree_->SetBranchStatus(rule.c_str(), 1);
 
  // Reset the entry index_ with the new parent index_
  ientry_ = parent_->ientry_;
 
  // import run headers from new input file
  importRunHeaders();
 
  return;
}

References file_, ientry_, importRunHeaders(), parent_, pre_clone_rules_, reactivate_rules_, and tree_.

Referenced by framework::Process::run().

writeRunHeader()

void framework::EventFile::writeRunHeader

(

std::shared_ptr< ldmx::RunHeader >

runHeader

)

Write the run header into the run map.

Parameters

runHeader

shared pointer to the run header to store

Exceptions

Exception

if run number is already in run map

Definition at line 414 of file EventFile.cxx.

                                                                      {
  int run_number = run_header->getRunNumber();
 
  if (run_map_.find(run_number) != run_map_.end()) {
    EXCEPTION_RAISE("RunMap", "Run map already contains a run with number '" +
                                  std::to_string(run_number) + "'.");
  }
 
  run_map_[run_number] = run_header;
}

References run_map_.

Referenced by framework::Process::run().

writeRunTree()

void framework::EventFile::writeRunTree

(

bool

completed = false

)

Write the map of run headers to the file as a TTree of RunHeader.

Safe to call more than once; any run tree already in the file is overwritten. Process calls it once the producers have filled the headers and again on close, so a killed job still leaves a usable file.

Parameters

[in]

completed

true when closing cleanly. Only the final call should pass true.

Exceptions

Exception

if call this function on a non-output file.

ROOT requires us to be in the correct directory when we create the output TTree for us to have it written into the correct location.

In order to allow downstream processors to getHistoDirectory() and enter that directory for this histograms we need to enter the output event file again here so that our run tree ends up in the correct location.

Definition at line 368 of file EventFile.cxx.

                                           {
  if (not is_output_file_) {
    EXCEPTION_RAISE("MisCall",
                    "Cannot write the run tree on an input event file.");
  }
 
  // TODO: Tree name shouldn't be hardcoded.
 
  // stamp completion onto the headers before they go out
  for (auto& [num, run_header] : run_map_) run_header->setCompleted(completed);
 
  file_->cd();
 
  // rebuild so the branch address stays valid across calls
  delete run_tree_;
  run_tree_ = nullptr;
  file_->Delete("LDMX_Run;*");  // drop any earlier cycle
  run_tree_ = new TTree("LDMX_Run", "LDMX run header");
 
  // create the branch on this tree
  ldmx::RunHeader* the_handle = nullptr;
  run_tree_->Branch("RunHeader", "ldmx::RunHeader", &the_handle, 32000, 3);
  // ROOT allocates a RunHeader when given a null pointer and leaves
  // ownership with the caller, so take it to avoid leaking it
  std::unique_ptr<ldmx::RunHeader> root_allocated(the_handle);
 
  // copy over the run headers into the tree
  for (auto& [num, run_header] : run_map_) {
    the_handle = run_header.get();
    run_tree_->Fill();
  }
 
  run_tree_->Write("", TObject::kOverwrite);
  file_->Flush();  // get the key on disk before any kill
}

References file_, is_output_file_, run_map_, and run_tree_.

Referenced by framework::Process::newRun(), and framework::Process::run().

Member Data Documentation

entries_

Long64_t framework::EventFile::entries_ {-1}

private

The number of entries in the tree.

Definition at line 297 of file EventFile.h.

{-1};

Referenced by EventFile(), nextEvent(), setupEvent(), and skipToEvent().

event_

Event* framework::EventFile::event_ {nullptr}

private

The object containing the actual event data (trees and branches).

Definition at line 324 of file EventFile.h.

{nullptr};

Referenced by addDrop(), getEvent(), nextEvent(), and setupEvent().

file_

TFile* framework::EventFile::file_ {nullptr}

private

The backing TFile for this EventFile.

Definition at line 315 of file EventFile.h.

{nullptr};

Referenced by EventFile(), importRunHeaders(), isCorrupted(), nextEvent(), updateParent(), writeRunTree(), and ~EventFile().

file_name_

std::string framework::EventFile::file_name_

private

The file name.

Definition at line 303 of file EventFile.h.

Referenced by EventFile(), and getFileName().

ientry_

Long64_t framework::EventFile::ientry_ {-1}

private

The current entry in the tree.

Definition at line 300 of file EventFile.h.

{-1};

Referenced by nextEvent(), setupEvent(), skipToEvent(), and updateParent().

is_loopable_

bool framework::EventFile::is_loopable_ {false}

private

True if this is an input file with pileup overlay events *‍/.

Definition at line 312 of file EventFile.h.

{false};

Referenced by nextEvent().

is_output_file_

bool framework::EventFile::is_output_file_

private

True if file is an output file being written to disk.

Definition at line 306 of file EventFile.h.

Referenced by EventFile(), importRunHeaders(), isCorrupted(), nextEvent(), setupEvent(), writeRunTree(), and ~EventFile().

is_single_output_

bool framework::EventFile::is_single_output_

private

True if there is only one output file.

Definition at line 309 of file EventFile.h.

Referenced by nextEvent().

parent_

EventFile* framework::EventFile::parent_ {nullptr}

private

A parent file containing event data.

Definition at line 321 of file EventFile.h.

{nullptr};

Referenced by EventFile(), importRunHeaders(), nextEvent(), setupEvent(), and updateParent().

pre_clone_rules_

std::vector<std::pair<std::string, bool> > framework::EventFile::pre_clone_rules_

private

Pre-clone rules.

The series of rules to call before cloning/copying the parent tree.

Definition at line 332 of file EventFile.h.

Referenced by addDrop(), EventFile(), nextEvent(), and updateParent().

reactivate_rules_

std::vector<std::string> framework::EventFile::reactivate_rules_

private

Vector of drop rules that have been parsed and need to be used to reactivate these branches on the input tree.

The branches were initial deactivated so they don't get cloned to output tree.

Definition at line 341 of file EventFile.h.

Referenced by addDrop(), EventFile(), nextEvent(), and updateParent().

run_headers_have_completeness_

bool framework::EventFile::run_headers_have_completeness_ {false}

private

True when the run headers we read were written with a completion flag.

Definition at line 350 of file EventFile.h.

{false};

Referenced by getIncompleteRuns(), and importRunHeaders().

run_map_

std::map<int, std::shared_ptr<ldmx::RunHeader> > framework::EventFile::run_map_

private

Map of run numbers to RunHeader objects (owned via shared_ptr)

Definition at line 344 of file EventFile.h.

Referenced by getIncompleteRuns(), getRunHeaderPtr(), importRunHeaders(), writeRunHeader(), and writeRunTree().

run_tree_

TTree* framework::EventFile::run_tree_ {nullptr}

private

The run tree, owned by file_ once written.

Definition at line 347 of file EventFile.h.

{nullptr};

Referenced by writeRunTree().

tree_

TTree* framework::EventFile::tree_ {nullptr}

private

The tree with event data.

Definition at line 318 of file EventFile.h.

{nullptr};

Referenced by EventFile(), isCorrupted(), nextEvent(), setupEvent(), updateParent(), and ~EventFile().

---

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

• Framework/include/Framework/EventFile.h
• Framework/src/Framework/EventFile.cxx