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 (ldmx::RunHeader &runHeader)
	Write the run header into the run map.
void	writeRunTree ()
	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 ()

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::pair< bool, ldmx::RunHeader * > >	run_map_
	Map of run numbers to RunHeader objects.

Detailed Description

This class manages all ROOT file input/output operations.

Definition at line 26 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 13 of file EventFile.cxx.

    : file_name_(filename),
      is_output_file_(is_output_file),
      is_single_output_(isSingleOutput),
      is_loopable_(isLoopable),
      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>("compressionSetting", 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>("skipCorruptedInputFiles", 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 91 of file EventFile.cxx.

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

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 99 of file EventFile.cxx.

    : EventFile(params, filename, parent, true, isSingleOutput, 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 95 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 104 of file EventFile.cxx.

                      {
  // Before an output file, the Event tree needs to be written.
  if (is_output_file_) {
    // make sure we are in output file before writing
    file_->cd();
    tree_->Write();
  }
 
  // Close the file
  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 121 of file EventFile.cxx.

                                             {
  int offset;
  bool is_keep = false, is_drop = false, is_ignore = false;
  size_t i = rule.find("keep");
  if (i != std::string::npos) {
    offset = i + 4;
    is_keep = true;
  }
  i = rule.find("drop");
  if (i != std::string::npos) {
    offset = i + 4;
    is_drop = true;
  }
  i = rule.find("ignore");
  if (i != std::string::npos) {
    offset = i + 6;
    is_ignore = true;
  }
 
  // more than one 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);
  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
 
  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
    // root needs . removed otherwise it gets cranky
    srule.erase(std::remove(srule.begin(), srule.end(), '.'), srule.end());
    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());
    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(), 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 181 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 258 of file EventFile.h.

{ return file_name_; }

References file_name_.

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 391 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 384 of file EventFile.cxx.

                                                        {
  if (run_map_.find(run_number) != run_map_.end()) {
    return run_map_.at(run_number).second;
  }
  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!

Any RunHeaders read in from this function are owned by this instance of EventFile and are deleted in close().

Note

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

Definition at line 400 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");
    // 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) {
        // copy input run tree into run map
        // We should consider moving to a shared_ptr instead of 'new'
        run_map_[old_run_header_ptr->getRunNumber()] =
            std::make_pair(true, new ldmx::RunHeader(*old_run_header_ptr));
      }
    }
  }
 
  return;
}

References file_, is_output_file_, parent_, and run_map_.

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 116 of file EventFile.cxx.

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

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 180 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 262 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 290 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 296 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

(

ldmx::RunHeader &

runHeader

)

Write the run header into the run map.

Any RunHeader passed here is not owned or cleaned up by this EventFile instance.

Parameters

runHeader

The run header to write into the map

Exceptions

Exception

if run number is already in run map

Definition at line 371 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] = std::make_pair(false, &run_header);
 
  return;
}

References ldmx::RunHeader::getRunNumber(), and run_map_.

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

writeRunTree()

void framework::EventFile::writeRunTree

(

)

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

Deletes any RunHeaders that this instance of EventFile owns.

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 327 of file EventFile.cxx.

                             {
  if (not is_output_file_) {
    EXCEPTION_RAISE("MisCall",
                    "Cannot write the run tree on an input event file.");
  }
 
  // store the run map into the output tree
  // Check for the existence of the run tree in the file.
  // If it already exists, throw an exception.
  // TODO: Tree name shouldn't be hardcoded. Is this check really necessary?
  auto run_tree{static_cast<TTree *>(file_->Get("LDMX_Run"))};
  if (run_tree) {
    EXCEPTION_RAISE("RunTree",
                    "RunTree 'LDMX_Run' already exists in output file '" +
                        file_name_ + "'.");
  }
 
  file_->cd();
  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);
 
  // copy over the run headers into the tree
  for (auto &[num, header_pair] : run_map_) {
    the_handle = header_pair.second;
    run_tree->Fill();
    if (header_pair.first) delete header_pair.second;
  }
 
  run_tree->Write();
}

References file_, file_name_, is_output_file_, and run_map_.

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

Member Data Documentation

entries_

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

private

The number of entries in the tree.

Definition at line 281 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 308 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 299 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 287 of file EventFile.h.

Referenced by EventFile(), getFileName(), and writeRunTree().

ientry_

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

private

The current entry in the tree.

Definition at line 284 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 296 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 290 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 293 of file EventFile.h.

Referenced by nextEvent().

parent_

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

private

A parent file containing event data.

Definition at line 305 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 316 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 325 of file EventFile.h.

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

run_map_

std::map<int, std::pair<bool, ldmx::RunHeader *> > framework::EventFile::run_map_

private

Map of run numbers to RunHeader objects.

The value object is a pair that should remain internal.

1. True if EventFile owns the RunHeader (and needs to clean it up)
   • This happens when RunHeaders are imported from an input file
2. False if EventFile does not own the RunHeader
   • This happens when the RunHeader is created by Process::run during production

Definition at line 337 of file EventFile.h.

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

tree_

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

private

The tree with event data.

Definition at line 302 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