framework::Event Class Reference

Implements an event buffer system for storing event data. More...

#include <Event.h>

Public Member Functions
	Event (const std::string &passName)
	Class constructor.
	~Event ()
	Class destructor.
ldmx::EventHeader &	getEventHeader ()
	Get the event header.
const ldmx::EventHeader &	getEventHeader () const
	Get the event header.
const ldmx::EventHeader *	getEventHeaderPtr ()
	Get the event header as a pointer.
int	getEventNumber () const
	Get the event number.
double	getEventWeight () const
	Get the event weight.
void	print () const
	Print event bus.
std::vector< ProductTag >	searchProducts (const std::string &namematch, const std::string &passmatch, const std::string &typematch, bool full_string_match=false) const
	Get a list of products which match the given POSIX-Extended, case-insenstive regular-expressions.
bool	exists (const std::string &name, const std::string &passName, bool unique=true) const
	Check for the existence of an object or collection with the given name and pass name in the event.
void	addDrop (const std::string &exp)
	Add a drop rule to the list of regex expressions to drop.
void	addIgnore (const std::string &exp)
	Add an ignore rule to the list of regex expressions to ignore on input.
template<typename T >
void	add (const std::string &collectionName, T &obj)
	Adds an object to the event bus.
template<typename T >
const T &	getObject (const std::string &collectionName, const std::string &passName) const
	Get an general object from the event bus.
template<typename ContentType >
const std::vector< ContentType > &	getCollection (const std::string &collectionName, const std::string &passName) const
	Get a collection (std::vector) of objects from the event bus.
template<typename KeyType , typename ValType >
const std::map< KeyType, ValType > &	getMap (const std::string &collectionName, const std::string &passName) const
	Get a map (std::map) of objects from the event bus.
void	setInputTree (TTree *tree)
	Set the input data tree.
void	setOutputTree (TTree *tree)
	Set the output data tree.
TTree *	createTree ()
	Create the output data tree.
const std::vector< ProductTag > &	getProducts () const
	Get a list of the data products in the event.
bool	nextEvent ()
	Go to the next event by retrieving the event header.
void	beforeFill ()
	Action to be executed before the tree is filled.
void	clear ()
	Clear this object's data (including passengers).
void	onEndOfEvent ()
	Perform end of event action (doesn't do anything right now).
void	onEndOfFile ()
	Perform end of file action.
std::string	getPassName ()
	Get the current/default pass name.
int	getElectronCount () const
void	setElectronCount (const int &electronCount)
	Set the beam electron count.

Private Member Functions
bool	shouldDrop (const std::string &collName) const
	Check if collection should be dropped.
bool	shouldIgnore (const std::string &branchName) const
	Check if a branch from the input tree should be ignored.
std::string	makeBranchName (const std::string &collectionName, const std::string &passName) const
	Make a branch name from a collection and pass name.
std::string	makeBranchName (const std::string &collectionName) const
	Make a branch name from a collection and the default(current) pass name.

Private Attributes
ldmx::EventHeader	event_header_
	The event header object.
std::string	pass_name_
	The default pass name.
TTree *	output_tree_ {nullptr}
	The output tree for writing a new file.
TTree *	input_tree_ {nullptr}
	The input tree for reading existing data.
int	electron_count_ {1}
	The total number of electrons in the event.
framework::Bus	bus_
	The Bus.
std::set< std::string >	branches_filled_
	Names of branches filled during this event.
std::vector< regex_t >	regex_drop_collections_
	Regex of collection names to not store in event.
std::vector< regex_t >	regex_ignore_collections_
	Regex of branch names to not even read from the input tree.
std::map< std::string, std::string >	known_lookups_
	Efficiency cache for empty pass name lookups.
std::vector< ProductTag >	products_
	List of all the event products.

Detailed Description

Implements an event buffer system for storing event data.

Event data is stored in ROOT trees and branches for persistency. For the buffering, we use a multi-layered inheritance tree that is wrapped inside of the Bus class.

See also

framework::Bus for this buffering tool

Definition at line 42 of file Event.h.

Constructor & Destructor Documentation

Event()

framework::Event::Event

(

const std::string &

passName

)

Class constructor.

Parameters

passName

The default pass name for adding event data.

Definition at line 7 of file Event.cxx.

: pass_name_(thePassName) {}

~Event()

framework::Event::~Event

(

)

Class destructor.

Definition at line 9 of file Event.cxx.

              {
  for (regex_t& reg : regex_drop_collections_) {
    regfree(&reg);
  }
  for (regex_t& reg : regex_ignore_collections_) {
    regfree(&reg);
  }
}

References regex_drop_collections_, and regex_ignore_collections_.

Member Function Documentation

add()

template<typename T >

void framework::Event::add ( const std::string & collectionName, T & obj )

inline

Adds an object to the event bus.

Exceptions

Exception	if there is an underscore in the collection name.
Exception	if there already has been a branch filled with the constructed name.
Exception	if the type we are putting in mis-matches the type in the bus under the input name.

See also

makeBranchName The branch name is constructed from the collection name using the current pass name.

Bus::board

Bus::attach If the branch is not on the bus yet, we board the bus and check if we need to attach the object to a tree.

Bus::update We always update the contents of the bus object with the input object.

Parameters

collectionName
obj	in ROOT dictionary to add

Definition at line 195 of file Event.h.

                                                    {
    if (collectionName.find('_') != std::string::npos) {
      EXCEPTION_RAISE("IllegalName",
                      "The product name '" + collectionName +
                          "' is illegal as it contains an underscore.");
    }
 
    // determine the branch name
    std::string branch_name;
    if (collectionName == ldmx::EventHeader::BRANCH)
      branch_name = collectionName;
    else
      branch_name = makeBranchName(collectionName);
 
    if (branches_filled_.find(branch_name) != branches_filled_.end()) {
      EXCEPTION_RAISE("ProductExists",
                      "A product named '" + collectionName +
                          "' already exists in the event (has been loaded by a "
                          "previous producer in this process).");
    }
    branches_filled_.insert(branch_name);
    // MEMORY add is leaking memory when given a vector (possible upon
    // destruction of Event?) MEMORY add is 'conditional jump or move depends on
    // uninitialised values' for all types of objects
    //  TTree::BranchImpRef or TTree::BronchExec
    if (not bus_.isOnBoard(branch_name)) {
      // create a new branch for this collection
 
      // have type T board bus under name 'branchName'
      bus_.board<T>(branch_name);
 
      // type name (want to use branch element if possible)
      std::string tname = typeid(obj).name();
 
      if (output_tree_ and not shouldDrop(branch_name)) {
        // we are writing this branch to an output file, so let's
        //  attach this passenger to the output tree
        TBranch *out_branch = bus_.attach(output_tree_, branch_name, true);
        // get type name from branch if possible,
        //  otherwise use compiler level type name (above)
        std::string class_name{out_branch->GetClassName()};
        if (not class_name.empty()) tname = class_name;
      }  // output tree exists or not
 
      // check for cache entry to remove
      auto it_known{known_lookups_.find(collectionName)};
      if (it_known != known_lookups_.end()) known_lookups_.erase(it_known);
 
      // add us to list of products
      products_.emplace_back(collectionName, pass_name_, tname);
    }
 
    // copy input contents into bus passenger
    try {
      bus_.update(branch_name, obj);
    } catch (const std::bad_cast &) {
      EXCEPTION_RAISE("TypeMismatch",
                      "Attempting to add an object whose type '" +
                          std::string(typeid(obj).name()) +
                          "' doesn't match the type stored in the collection.");
    }
 
    return;
  }

References framework::Bus::attach(), framework::Bus::board(), ldmx::EventHeader::BRANCH, branches_filled_, bus_, framework::Bus::isOnBoard(), known_lookups_, makeBranchName(), output_tree_, pass_name_, products_, shouldDrop(), and framework::Bus::update().

Referenced by beforeFill(), packing::rawdatafile::File::nextEvent(), and trigscint::ZCCMDecoder::produce().

addDrop()

void framework::Event::addDrop

(

const std::string &

exp

)

Add a drop rule to the list of regex expressions to drop.

If a collection name matches one of the stored regex expressions, it will be stored as a passenger but not added to output tree.

Parameters

exp	regex to match

Definition at line 24 of file Event.cxx.

                                        {
  regex_t reg;
  if (!regcomp(&reg, exp.c_str(), REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
    regex_drop_collections_.push_back(reg);
  } else {
    EXCEPTION_RAISE("InvalidRegex", "The passed drop rule regex '" + exp +
                                        "' is not a valid regex.");
  }
}

References regex_drop_collections_.

Referenced by framework::EventFile::addDrop().

addIgnore()

void framework::Event::addIgnore

(

const std::string &

exp

)

Add an ignore rule to the list of regex expressions to ignore on input.

If a branch name matches one of the stored regex expressions, it will not be added to the list of known products when reading the input tree. This prevents processors from accessing these collections at all.

Parameters

exp	regex to match

Definition at line 34 of file Event.cxx.

                                          {
  regex_t reg;
  if (!regcomp(&reg, exp.c_str(), REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
    regex_ignore_collections_.push_back(reg);
  } else {
    EXCEPTION_RAISE("InvalidRegex", "The passed ignore rule regex '" + exp +
                                        "' is not a valid regex.");
  }
}

References regex_ignore_collections_.

Referenced by framework::EventFile::addDrop().

beforeFill()

void framework::Event::beforeFill

(

)

Action to be executed before the tree is filled.

Definition at line 170 of file Event.cxx.

                       {
  if (input_tree_ == 0 && branches_filled_.find(ldmx::EventHeader::BRANCH) ==
                              branches_filled_.end()) {
    // Event Header not copied from input and hasn't been added yet, need to put
    // it in
    add(ldmx::EventHeader::BRANCH, event_header_);
  }
}

References add(), ldmx::EventHeader::BRANCH, branches_filled_, event_header_, and input_tree_.

Referenced by framework::EventFile::nextEvent().

clear()

void framework::Event::clear

(

)

Clear this object's data (including passengers).

Definition at line 179 of file Event.cxx.

                  {
  branches_filled_.clear();  // forget names of branches we filled
  bus_.clear();  // clear the event objects individually but leave them on bus
}

References branches_filled_, bus_, and framework::Bus::clear().

Referenced by framework::EventFile::nextEvent().

createTree()

TTree * framework::Event::createTree

(

)

Create the output data tree.

Returns

The output data tree.

Definition at line 115 of file Event.cxx.

                         {
  output_tree_ = new TTree("LDMX_Events", "LDMX Events");
 
  return output_tree_;
}

References output_tree_.

Referenced by framework::EventFile::setupEvent().

exists()

bool framework::Event::exists	(	const std::string &	name,
		const std::string &	passName,
		bool	unique = true ) const

Check for the existence of an object or collection with the given name and pass name in the event.

This function just uses the searchProducts function while requiring the input name and pass to match the full string.

See also

searchProducts for a more flexible method for existence checking. If you have any situation more complicated than simply checking if a collection with exactly the input name, it is recommended to use the searchProducts function directly. Within a processor, one can access and print the products from a search relatively easily.

auto matches{event.searchProducts("MyCollection","","")};
std::cout << matches.size() << " event objects match pattern" << std::endl;
for (const auto& match : matches) { std::cout << match << std::endl; }

searchProducts returns a list of ProductTag objects that store the name, pass, and type of the objects matching the search.

Parameters

name	Name (label, not class name) given to the object when it was put into the event.
passName	The process pass label which was in use when this object was put into the event, such as "sim" or "rerecov2".
unique	true if requiring one and only one matching object, false if allowing for one or more matching objects

Returns

True if the object or collection exists in the event.

Definition at line 105 of file Event.cxx.

                                      {
  static const bool require_full_string_match = true;
  auto matches = searchProducts(name, passName, "", require_full_string_match);
  if (unique)
    return (matches.size() == 1);
  else
    return (matches.size() > 0);
}

References searchProducts().

Referenced by dqm::EcalDigiVerifier::analyze(), dqm::TrigScintClusterDQM::analyze(), dqm::VisiblesCutflow::analyze(), dqm::VisiblesFeatureProducer::analyze(), tracking::dqm::StraightTracksDQM::analyze(), tracking::dqm::TrackerDigiDQM::analyze(), tracking::dqm::TrackingRecoDQM::analyze(), trigger::DumpFileWriter::analyze(), trigscint::TestBeamClusterAnalyzer::analyze(), packing::rawdatafile::File::nextEvent(), ecal::EcalPnetVetoProcessor::produce(), ecal::EcalRecProducer::produce(), ecal::EcalVetoProcessor::produce(), ecal::EcalWABRecProcessor::produce(), hcal::HcalRecProducer::produce(), hcal::VisiblesVetoProcessor::produce(), recon::BeamElectronLocator::produce(), recon::ElectronCounter::produce(), recon::MyProcessor::produce(), recon::ParticleFlow::produce(), recon::PFEcalClusterProducer::produce(), recon::PFHcalClusterProducer::produce(), recon::PFTrackProducer::produce(), recon::PFTruthProducer::produce(), recon::PileupFinder::produce(), recon::TrackDeDxMassEstimator::produce(), tracking::reco::CKFProcessor::produce(), tracking::reco::GreedyAmbiguitySolver::produce(), tracking::reco::GSFProcessor::produce(), tracking::reco::LinearSeedFinder::produce(), tracking::reco::SeedFinderProcessor::produce(), trigger::EcalTPSelector::produce(), trigger::HcalTPSelector::produce(), trigger::NtupleWriter::produce(), trigger::PropagationMapWriter::produce(), trigger::TrigEcalClusterProducer::produce(), trigger::TrigEcalEnergySum::produce(), trigger::TrigElectronProducer::produce(), trigger::TrigHcalEnergySum::produce(), trigger::TrigMipReco::produce(), trigscint::TrigScintTrackProducer::produce(), and trigscint::TruthHitProducer::produce().

getCollection()

template<typename ContentType >

const std::vector< ContentType > & framework::Event::getCollection ( const std::string & collectionName, const std::string & passName ) const

inline

Get a collection (std::vector) of objects from the event bus.

See also

getObject for actual implementation

Template Parameters

in,out] ContentType type of object stored in the vector

Parameters

[in]	collectionName	name of collection that we want
[in]	passName	name of specific pass we want, optional

Returns

const reference to collection of objects on the bus

Definition at line 411 of file Event.h.

                                                                        {
    return getObject<std::vector<ContentType> >(collectionName, passName);
  }

References getObject().

Referenced by dqm::SampleValidation::analyze(), packing::rawdatafile::File::nextEvent(), hcal::HcalRawDecoder::produce(), and recon::OverlayProducer::produce().

getElectronCount()

int framework::Event::getElectronCount ( ) const

inline

Returns

The beam electron count.

Definition at line 497 of file Event.h.

{ return electron_count_; }

References electron_count_.

getEventHeader() [1/2]

ldmx::EventHeader & framework::Event::getEventHeader ( )

inline

Get the event header.

Returns

A reference to the event header.

Definition at line 59 of file Event.h.

{ return event_header_; }

References event_header_.

Referenced by packing::rawdatafile::File::nextEvent(), recon::OverlayProducer::onNewRun(), dqm::DarkBremInteraction::produce(), simcore::Simulator::produce(), trigscint::QIEDecoder::produce(), and framework::Process::run().

getEventHeader() [2/2]

const ldmx::EventHeader & framework::Event::getEventHeader ( ) const

inline

Get the event header.

Returns

A constant reference to the event header.

Definition at line 65 of file Event.h.

{ return event_header_; }

References event_header_.

getEventHeaderPtr()

const ldmx::EventHeader * framework::Event::getEventHeaderPtr ( )

inline

Get the event header as a pointer.

Note

This is only helpful for the internal workings of the framework and should not be used by processors. Use getEventHeader instead.

Returns

A const pointer to the event header.

Definition at line 75 of file Event.h.

{ return &event_header_; }

References event_header_.

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

getEventNumber()

int framework::Event::getEventNumber ( ) const

inline

Get the event number.

Returns

the event index_/number

Definition at line 81 of file Event.h.

{ return event_header_.getEventNumber(); }

References event_header_, and ldmx::EventHeader::getEventNumber().

Referenced by Standalone::analyze(), packing::rawdatafile::File::nextEvent(), and framework::Process::run().

getEventWeight()

double framework::Event::getEventWeight ( ) const

inline

Get the event weight.

Returns

weight from the EventHeader

Definition at line 87 of file Event.h.

{ return event_header_.getWeight(); }

References event_header_, and ldmx::EventHeader::getWeight().

getMap()

template<typename KeyType , typename ValType >

const std::map< KeyType, ValType > & framework::Event::getMap ( const std::string & collectionName, const std::string & passName ) const

inline

Get a map (std::map) of objects from the event bus.

See also

getObject for actual implementation

Template Parameters

in,out] KeyType type of object used as the key in the map

Template Parameters

in,out] ValType type of object used as the value in the map

Parameters

[in]	collectionName	name of collection that we want
[in]	passName	name of specific pass we want, optional

Returns

const reference to collection of objects on the bus

Definition at line 428 of file Event.h.

                                                                            {
    return getObject<std::map<KeyType, ValType> >(collectionName, passName);
  }

References getObject().

Referenced by recon::OverlayProducer::produce().

getObject()

template<typename T >

const T & framework::Event::getObject ( const std::string & collectionName, const std::string & passName ) const

inline

Get an general object from the event bus.

First we determine the branch name. If the collection is the EventHeader or if the passName is given, this is easy. But if the pass name is empty, we try to find a matching collection under the list of branch names. We will throw an exception if we don't find a unique branch corresponding to the collection. We also employ a rudimentary caching system for mapping collection names to branches (if no pass name is given) so this looping only needs to happen once.

See also

EventHeader::BRANCH for the name of the event header branch

makeBranchName for how we make branch names from object/pass names

Exceptions

Exception

if unable to uniquely determine the branch name from the collection name alone.

If the object we are asking for is already on the bus, we simply make sure the branch corresponding to it is on the correct entry.

If the object we are asking for is not on the bus and there is an input tree, we look for a branch on the input tree corresponding to the branch name and then we load the current entry of that branch.

Exceptions

Exception	if can't find a corresponding branch name on the input tree or in the bus
Exception	if we are trying to load a new branch and the input tree has negative read entry (i.e. it is uninitialized)

See also

Bus::board

Bus::attach

Finally, we return a const reference to the object on the bus.

Exceptions

Exception

if mismatching type

See also

Bus::get

Template Parameters

T	type of object we should be getting

Parameters

collectionName	name of collection you want
passName	name of pass you want

Returns

const reference to requested object

Load in the current entry This is necessary because getObject is called after EventFile::nextEvent loads the current entry of the inputTree. Many branches are turned "off" (status == 0), so they aren't loaded when the entire TTree is updated to a specific entry.

We shouldn't end up here before inputTree's read entry is unset, but we check anyways because ROOT will just seg-fault like a chump.

Definition at line 299 of file Event.h.

                                                      {
    // get branch name
    std::string branch_name;
    if (collectionName == ldmx::EventHeader::BRANCH) {
      branch_name = collectionName;
    } else if (passName.empty()) {
      // if no passName, then find branchName by looking over known products
      if (known_lookups_.find(collectionName) == known_lookups_.end()) {
        // this collectionName hasn't been found before
        //   this collection name is the whole name and not a partial name
        //   so we search products with a full-string match required
        auto matches = searchProducts(collectionName, "", "", true);
        if (matches.empty()) {
          // no matches found
          EXCEPTION_RAISE("ProductNotFound",
                          "No product found for name '" + collectionName + "'");
        } else if (matches.size() > 1) {
          // more than one branch found
          std::stringstream names;
          for (auto strs : matches) {
            names << "\n" << strs;
          }
          EXCEPTION_RAISE("ProductAmbiguous",
                          "Multiple products found for name '" +
                              collectionName +
                              "' without specified pass name :" + names.str());
        } else {
          // exactly one branch found -> cache for later
          known_lookups_[collectionName] =
              makeBranchName(collectionName, matches.at(0).passname());
        }  // different options for number of possible branch matches
      }  // collection not in known lookups
      branch_name = known_lookups_.at(collectionName);
    } else {
      branch_name = makeBranchName(collectionName, passName);
    }
 
    // now we have determined the unique branch name to look for
    //  so we can start looking on the bus and the input tree
    //  (if it exists) for it
    bool already_on_board{bus_.isOnBoard(branch_name)};
    if (not already_on_board and input_tree_) {
      // branch is not on the bus but there is an input tree
      //  -> let's look for a new branch to load
 
      // default construct a new passenger
      bus_.board<T>(branch_name);
 
      // attempt to attach the new passenger to the input tree
      TBranch *branch = bus_.attach(input_tree_, branch_name, false);
      if (branch == 0) {
        // inputTree doesn't have that branch
        EXCEPTION_RAISE(
            "ProductNotFound",
            "No product found for branch '" + branch_name + "' on input tree.");
      }
      // ooh, new branch!
      branch->SetStatus(1);  // overrides any 'ignore' rules
      long long int ientry{input_tree_->GetReadEntry()};
      if (ientry < 0) {
        // reached getObject without initializing inputTree's read entry
        EXCEPTION_RAISE("InTreeInit",
                        "The input tree was un-initialized with read entry " +
                            std::to_string(ientry) +
                            " when attempting to get '" + branch_name + "'.");
      }
      branch->GetEntry(ientry);
    } else if (not already_on_board) {
      // not found in loaded branches and there is no inputTree,
      // so no hope of finding an unloaded object
      EXCEPTION_RAISE("ProductNotFound", "No product found for name '" +
                                             collectionName + "' and pass '" +
                                             pass_name_ + "'");
    }
 
    // we've made sure the passenger is on the bus
    //  and the branch we are reading from (if we are reading)
    //  has been updated
    // let's return the object that the passenger is carrying
    try {
      const T &obj = bus_.get<T>(branch_name);
      return obj;
    } catch (const std::bad_cast &) {
      EXCEPTION_RAISE("BadType",
                      "Trying to get product from '" + branch_name +
                          "' but asking for wrong type: " + typeid(T).name());
    }
  }  // getObject

References framework::Bus::attach(), framework::Bus::board(), ldmx::EventHeader::BRANCH, bus_, framework::Bus::get(), input_tree_, framework::Bus::isOnBoard(), known_lookups_, makeBranchName(), pass_name_, and searchProducts().

Referenced by eventdisplay::Display::draw(), getCollection(), getMap(), and nextEvent().

getPassName()

std::string framework::Event::getPassName ( )

inline

Get the current/default pass name.

Returns

The current/default pass name.

Definition at line 494 of file Event.h.

{ return pass_name_; }

References pass_name_.

getProducts()

const std::vector< ProductTag > & framework::Event::getProducts ( ) const

inline

Get a list of the data products in the event.

Definition at line 453 of file Event.h.

{ return products_; }

References products_.

Referenced by print(), and searchProducts().

makeBranchName() [1/2]

std::string framework::Event::makeBranchName ( const std::string & collectionName ) const

inlineprivate

Make a branch name from a collection and the default(current) pass name.

Parameters

collectionName

The collection name.

Definition at line 542 of file Event.h.

                                                                  {
    return makeBranchName(collectionName, pass_name_);
  }

References makeBranchName(), and pass_name_.

makeBranchName() [2/2]

std::string framework::Event::makeBranchName ( const std::string & collectionName, const std::string & passName ) const

inlineprivate

Make a branch name from a collection and pass name.

Parameters

collectionName	The collection name.
passName	The pass name.

Definition at line 533 of file Event.h.

                                                              {
    return collectionName + "_" + passName;
  }

Referenced by add(), getObject(), and makeBranchName().

nextEvent()

bool framework::Event::nextEvent

(

)

Go to the next event by retrieving the event header.

We deep-copy the event header into our own member object. This is so we can modify the event header during the processing of this event and then re-add the event header at the end of the event. This is a pretty lame way to handle the event header, but it works.

Returns

Hard-coded to return true.

Definition at line 165 of file Event.cxx.

                      {
  event_header_ = getObject<ldmx::EventHeader>(ldmx::EventHeader::BRANCH, "");
  return true;
}

References ldmx::EventHeader::BRANCH, event_header_, and getObject().

Referenced by framework::EventFile::nextEvent().

onEndOfEvent()

void framework::Event::onEndOfEvent

(

)

Perform end of event action (doesn't do anything right now).

Definition at line 184 of file Event.cxx.

{}

Referenced by framework::EventFile::nextEvent().

onEndOfFile()

void framework::Event::onEndOfFile

(

)

Perform end of file action.

Clears buffer objects and resets output branch addresses. This prepares the event bus for a new input file (with new addresses).

Definition at line 186 of file Event.cxx.

                        {
  if (output_tree_)
    output_tree_->ResetBranchAddresses();  // reset addresses for output branch
  if (input_tree_)
    input_tree_ = nullptr;  // detach old input_tree (owned by EventFile)
  known_lookups_.clear();   // reset caching of empty pass requests
  bus_.everybodyOff();      // delete buffer objects
}

References bus_, framework::Bus::everybodyOff(), input_tree_, known_lookups_, and output_tree_.

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

print()

void framework::Event::print

(

)

const

Print event bus.

Prints the list of products using the current stored product tags.

Definition at line 18 of file Event.cxx.

                        {
  for (const ProductTag& tag : getProducts()) {
    std::cout << tag << std::endl;
  }
}

References getProducts().

searchProducts()

std::vector< ProductTag > framework::Event::searchProducts	(	const std::string &	namematch,
		const std::string &	passmatch,
		const std::string &	typematch,
		bool	full_string_match = false ) const

Get a list of products which match the given POSIX-Extended, case-insenstive regular-expressions.

An empty argument is interpreted as ".*", which matches everything.

By default (with full_string_match = false), the pattern can match the full string or any substring within it. One can require the pattern to match the full string by changing that parameter.

Parameters

namematch	Regular expression to compare with the product name
passmatch	Regular expression to compare with the pass name
typematch	Regular expression to compare with the type name
full_string_match	require all non-empty regular expressions to match the full string and not a sub-string

Definition at line 79 of file Event.cxx.

                                                                            {
  std::vector<ProductTag> retval;
  regex_t reg_name{constructRegex(namematch, full_string_match)},
      reg_pass{constructRegex(passmatch, full_string_match)},
      reg_type{constructRegex(typematch, full_string_match)};
 
  // all passed expressions are valid regular expressions
  const std::vector<ProductTag>& products = getProducts();
  for (std::vector<ProductTag>::const_iterator i = products.begin();
       i != products.end(); i++) {
    if (!regexec(&reg_name, i->name().c_str(), 0, 0, 0) &&
        !regexec(&reg_pass, i->passname().c_str(), 0, 0, 0) &&
        !regexec(&reg_type, i->type().c_str(), 0, 0, 0))
      retval.push_back(*i);
  }
 
  regfree(&reg_type);
  regfree(&reg_pass);
  regfree(&reg_name);
 
  return retval;
}

References framework::constructRegex(), and getProducts().

Referenced by exists(), and getObject().

setElectronCount()

void framework::Event::setElectronCount ( const int & electronCount )

inline

Set the beam electron count.

Parameters

electronCount

The beam electron count.

Definition at line 504 of file Event.h.

                                                  {
    electron_count_ = electronCount;
  }

References electron_count_.

setInputTree()

void framework::Event::setInputTree

(

TTree *

tree

)

Set the input data tree.

Parameters

tree	The input data tree.

Definition at line 123 of file Event.cxx.

                                    {
  input_tree_ = tree;
 
  // in some cases, setInputTree is called more than once,
  // so reset branch listing before starting
  products_.clear();
  known_lookups_.clear();  // reset caching of empty pass requests
  bus_.everybodyOff();
 
  // put in EventHeader (only one without pass name)
  products_.emplace_back(ldmx::EventHeader::BRANCH, "", "ldmx::EventHeader");
 
  // find the names of all the existing branches
  TObjArray* branches = input_tree_->GetListOfBranches();
  if (!branches) {
    EXCEPTION_RAISE(
        "BadInputFile",
        "Input tree doesn't have a list of branches but still made it to this "
        "point. This is bad and has never been seen before!");
    return;
  }
  for (int i = 0; i < branches->GetEntriesFast(); i++) {
    std::string brname;
    if (branches->At(i)) {
      brname = branches->At(i)->GetName();
    }
    if (brname != ldmx::EventHeader::BRANCH) {
      if (shouldIgnore(brname)) continue;
      size_t j = brname.find("_");
      auto br = dynamic_cast<TBranchElement*>(branches->At(i));
      // can't determine type if branch isn't
      //  the higher-level TBranchElement type
      // Only occurs if the type on the bus is one of:
      //  bool, short, int, long, float, double (BSILFD)
      products_.emplace_back(
          brname.substr(0, j),   // collection name is before '_'
          brname.substr(j + 1),  // pass name is after
          br ? br->GetClassName() : "BSILFD");
    }
  }
}

References ldmx::EventHeader::BRANCH, bus_, framework::Bus::everybodyOff(), input_tree_, known_lookups_, products_, and shouldIgnore().

Referenced by framework::EventFile::nextEvent(), and framework::EventFile::setupEvent().

setOutputTree()

void framework::Event::setOutputTree

(

TTree *

tree

)

Set the output data tree.

Parameters

tree	The output data tree.

Definition at line 121 of file Event.cxx.

{ output_tree_ = tree; }

References output_tree_.

Referenced by framework::EventFile::nextEvent(), and framework::EventFile::setupEvent().

shouldDrop()

bool framework::Event::shouldDrop ( const std::string & collName ) const

private

Check if collection should be dropped.

Parameters

collName

name of collection

Returns

true if the collection should be dropped (i.e. NOT saved)

Definition at line 195 of file Event.cxx.

                                                         {
  for (const regex_t& exp : regex_drop_collections_) {
    if (!regexec(&exp, branch_name.c_str(), 0, 0, 0)) return true;
  }
  return false;
}

References regex_drop_collections_.

Referenced by add().

shouldIgnore()

bool framework::Event::shouldIgnore ( const std::string & branchName ) const

private

Check if a branch from the input tree should be ignored.

Ignored branches are not added to the products list and are therefore inaccessible to processors.

Parameters

branchName

name of branch

Returns

true if the branch should be ignored (i.e. NOT loaded)

Definition at line 202 of file Event.cxx.

                                                           {
  for (const regex_t& exp : regex_ignore_collections_) {
    if (!regexec(&exp, branch_name.c_str(), 0, 0, 0)) return true;
  }
  return false;
}

References regex_ignore_collections_.

Referenced by setInputTree().

Member Data Documentation

branches_filled_

std::set<std::string> framework::Event::branches_filled_

private

Names of branches filled during this event.

This is used to make sure the same passenger isn't modified more than once in one event and to make sure the event header is updated if it wasn't updated manually.

Definition at line 588 of file Event.h.

Referenced by add(), beforeFill(), and clear().

bus_

framework::Bus framework::Event::bus_

mutableprivate

The Bus.

We buffer the event bus objects by having passengers on the bus carry them.

See also

framework::Bus for how this buffering works

Definition at line 578 of file Event.h.

Referenced by add(), clear(), getObject(), onEndOfFile(), and setInputTree().

electron_count_

int framework::Event::electron_count_ {1}

private

The total number of electrons in the event.

Definition at line 568 of file Event.h.

{1};

Referenced by getElectronCount(), and setElectronCount().

event_header_

ldmx::EventHeader framework::Event::event_header_

private

The event header object.

Definition at line 550 of file Event.h.

Referenced by beforeFill(), getEventHeader(), getEventHeader(), getEventHeaderPtr(), getEventNumber(), getEventWeight(), and nextEvent().

input_tree_

TTree* framework::Event::input_tree_ {nullptr}

private

The input tree for reading existing data.

Definition at line 565 of file Event.h.

{nullptr};

Referenced by beforeFill(), getObject(), onEndOfFile(), and setInputTree().

known_lookups_

std::map<std::string, std::string> framework::Event::known_lookups_

mutableprivate

Efficiency cache for empty pass name lookups.

Definition at line 603 of file Event.h.

Referenced by add(), getObject(), onEndOfFile(), and setInputTree().

output_tree_

TTree* framework::Event::output_tree_ {nullptr}

private

The output tree for writing a new file.

Definition at line 560 of file Event.h.

{nullptr};

Referenced by add(), createTree(), onEndOfFile(), and setOutputTree().

pass_name_

std::string framework::Event::pass_name_

private

The default pass name.

Definition at line 555 of file Event.h.

Referenced by add(), getObject(), getPassName(), and makeBranchName().

products_

std::vector<ProductTag> framework::Event::products_

private

List of all the event products.

Definition at line 608 of file Event.h.

Referenced by add(), getProducts(), and setInputTree().

regex_drop_collections_

std::vector<regex_t> framework::Event::regex_drop_collections_

private

Regex of collection names to not store in event.

Definition at line 593 of file Event.h.

Referenced by addDrop(), shouldDrop(), and ~Event().

regex_ignore_collections_

std::vector<regex_t> framework::Event::regex_ignore_collections_

private

Regex of branch names to not even read from the input tree.

Definition at line 598 of file Event.h.

Referenced by addIgnore(), shouldIgnore(), and ~Event().

---

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

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