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 *	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.
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.
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	eventHeader_
	The event header object.
std::string	passName_
	The default pass name.
TTree *	outputTree_ {nullptr}
	The output tree for writing a new file.
TTree *	inputTree_ {nullptr}
	The input tree for reading existing data.
int	electronCount_ {1}
	The total number of electrons in the event.
framework::Bus	bus_
	The Bus.
std::set< std::string >	branchesFilled_
	Names of branches filled during this event.
std::vector< regex_t >	regexDropCollections_
	Regex of collection names to not store in event.
std::map< std::string, std::string >	knownLookups_
	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 41 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.

: passName_(thePassName) {}

~Event()

framework::Event::~Event

(

)

Class destructor.

Definition at line 9 of file Event.cxx.

              {
  for (regex_t& reg : regexDropCollections_) {
    regfree(&reg);
  }
}

References regexDropCollections_.

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 173 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 branchName;
    if (collectionName == ldmx::EventHeader::BRANCH)
      branchName = collectionName;
    else
      branchName = makeBranchName(collectionName);
 
    if (branchesFilled_.find(branchName) != branchesFilled_.end()) {
      EXCEPTION_RAISE("ProductExists",
                      "A product named '" + collectionName +
                          "' already exists in the event (has been loaded by a "
                          "previous producer in this process).");
    }
    branchesFilled_.insert(branchName);
    // 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(branchName)) {
      // create a new branch for this collection
 
      // have type T board bus under name 'branchName'
      bus_.board<T>(branchName);
 
      // type name (want to use branch element if possible)
      std::string tname = typeid(obj).name();
 
      if (outputTree_ and not shouldDrop(branchName)) {
        // we are writing this branch to an output file, so let's
        //  attach this passenger to the output tree
        TBranch *outBranch = bus_.attach(outputTree_, branchName, true);
        // get type name from branch if possible,
        //  otherwise use compiler level type name (above)
        std::string class_name{outBranch->GetClassName()};
        if (not class_name.empty()) tname = class_name;
      }  // output tree exists or not
 
      // check for cache entry to remove
      auto it_known{knownLookups_.find(collectionName)};
      if (it_known != knownLookups_.end()) knownLookups_.erase(it_known);
 
      // add us to list of products
      products_.emplace_back(collectionName, passName_, tname);
    }
 
    // copy input contents into bus passenger
    try {
      bus_.update(branchName, 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, branchesFilled_, bus_, framework::Bus::isOnBoard(), knownLookups_, makeBranchName(), outputTree_, passName_, products_, shouldDrop(), and framework::Bus::update().

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

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 21 of file Event.cxx.

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

References regexDropCollections_.

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

beforeFill()

void framework::Event::beforeFill

(

)

Action to be executed before the tree is filled.

Definition at line 156 of file Event.cxx.

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

References add(), ldmx::EventHeader::BRANCH, branchesFilled_, eventHeader_, and inputTree_.

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

Clear()

void framework::Event::Clear

(

)

Clear this object's data (including passengers).

Definition at line 165 of file Event.cxx.

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

References branchesFilled_, 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 102 of file Event.cxx.

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

References outputTree_.

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 92 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::TrigScintClusterDQM::analyze(), trigger::DumpFileWriter::analyze(), dqm::RecoilTrackerDQM::analyze(), tracking::dqm::TrackerDigiDQM::analyze(), tracking::dqm::TrackingRecoDQM::analyze(), trigscint::TestBeamClusterAnalyzer::analyze(), packing::rawdatafile::File::nextEvent(), ecal::EcalRecProducer::produce(), recon::ParticleFlow::produce(), recon::PFEcalClusterProducer::produce(), recon::PFHcalClusterProducer::produce(), recon::PFTrackProducer::produce(), recon::PFTruthProducer::produce(), trigger::EcalTPSelector::produce(), trigger::NtupleWriter::produce(), trigger::PropagationMapWriter::produce(), trigger::TrigEcalClusterProducer::produce(), trigger::TrigEcalEnergySum::produce(), trigger::TrigElectronProducer::produce(), trigger::TrigHcalEnergySum::produce(), ecal::EcalVetoProcessor::produce(), hcal::HcalRecProducer::produce(), recon::BeamElectronLocator::produce(), recon::ElectronCounter::produce(), recon::MyProcessor::produce(), tracking::reco::CKFProcessor::produce(), tracking::reco::GSFProcessor::produce(), tracking::reco::SeedFinderProcessor::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 386 of file Event.h.

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

Referenced by dqm::SampleValidation::analyze(), tracking::dqm::TrackingRecoDQM::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 475 of file Event.h.

{ return electronCount_; }

References electronCount_.

getEventHeader()

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

inline

Get the event header.

Returns

A reference to the event header.

Definition at line 58 of file Event.h.

{ return eventHeader_; }

References eventHeader_.

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

getEventHeaderPtr()

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

inline

Get the event header as a pointer.

Returns

A const pointer to the event header.

Definition at line 64 of file Event.h.

{ return &eventHeader_; }

References eventHeader_.

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

getEventNumber()

int framework::Event::getEventNumber ( ) const

inline

Get the event number.

Returns

the event index/number

Definition at line 70 of file Event.h.

{ return eventHeader_.getEventNumber(); }

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

Referenced by 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 76 of file Event.h.

{ return eventHeader_.getWeight(); }

References eventHeader_, 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 404 of file Event.h.

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

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 277 of file Event.h.

                                                           {
    // get branch name
    std::string branchName;
    if (collectionName == ldmx::EventHeader::BRANCH) {
      branchName = collectionName;
    } else if (passName.empty()) {
      // if no passName, then find branchName by looking over known products
      if (knownLookups_.find(collectionName) == knownLookups_.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
          knownLookups_[collectionName] =
              makeBranchName(collectionName, matches.at(0).passname());
        }  // different options for number of possible branch matches
      }    // collection not in known lookups
      branchName = knownLookups_.at(collectionName);
    } else {
      branchName = 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(branchName)};
    if (not already_on_board and inputTree_) {
      // 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>(branchName);
 
      // attempt to attach the new passenger to the input tree
      TBranch *branch = bus_.attach(inputTree_, branchName, false);
      if (branch == 0) {
        // inputTree doesn't have that branch
        EXCEPTION_RAISE("ProductNotFound", "No product found for branch '" +
                                               branchName + "' on input tree.");
      }
      // ooh, new branch!
      branch->SetStatus(1);  // overrides any 'ignore' rules
      long long int ientry{inputTree_->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 '" + branchName + "'.");
      }
      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 '" +
                                             passName_ + "'");
    }
 
    // 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>(branchName);
      return obj;
    } catch (const std::bad_cast &) {
      EXCEPTION_RAISE("BadType", "Trying to get product from '" + branchName +
                                     "' but asking for wrong type.");
    }
  }  // getObject

References framework::Bus::attach(), framework::Bus::board(), ldmx::EventHeader::BRANCH, bus_, framework::Bus::get(), inputTree_, framework::Bus::isOnBoard(), knownLookups_, makeBranchName(), passName_, and searchProducts().

Referenced by eventdisplay::Display::draw().

getPassName()

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

inline

Get the current/default pass name.

Returns

The current/default pass name.

Definition at line 472 of file Event.h.

{ return passName_; }

References passName_.

getProducts()

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

inline

Get a list of the data products in the event.

Definition at line 431 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 509 of file Event.h.

                                                                  {
    return makeBranchName(collectionName, passName_);
  }

References makeBranchName(), and passName_.

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 500 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 151 of file Event.cxx.

                      {
  eventHeader_ = getObject<ldmx::EventHeader>(ldmx::EventHeader::BRANCH);
  return true;
}

References ldmx::EventHeader::BRANCH, and eventHeader_.

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

onEndOfEvent()

void framework::Event::onEndOfEvent

(

)

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

Definition at line 170 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 172 of file Event.cxx.

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

References bus_, framework::Bus::everybodyOff(), inputTree_, knownLookups_, and outputTree_.

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 15 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 66 of file Event.cxx.

                                                                            {
  std::vector<ProductTag> retval;
  regex_t reg_name{construct_regex(namematch, full_string_match)},
      reg_pass{construct_regex(passmatch, full_string_match)},
      reg_type{construct_regex(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::construct_regex(), 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 482 of file Event.h.

                                                  {
    electronCount_ = electronCount;
  }

References electronCount_.

setInputTree()

void framework::Event::setInputTree

(

TTree *

tree

)

Set the input data tree.

Parameters

tree	The input data tree.

Definition at line 110 of file Event.cxx.

                                    {
  inputTree_ = tree;
 
  // in some cases, setInputTree is called more than once,
  // so reset branch listing before starting
  products_.clear();
  knownLookups_.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 = inputTree_->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) {
      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(), inputTree_, knownLookups_, and products_.

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 108 of file Event.cxx.

{ outputTree_ = tree; }

References outputTree_.

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 181 of file Event.cxx.

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

References regexDropCollections_.

Referenced by add().

Member Data Documentation

branchesFilled_

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

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 555 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 545 of file Event.h.

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

electronCount_

int framework::Event::electronCount_ {1}

private

The total number of electrons in the event.

Definition at line 535 of file Event.h.

{1};

Referenced by getElectronCount(), and setElectronCount().

eventHeader_

ldmx::EventHeader framework::Event::eventHeader_

private

The event header object.

Definition at line 517 of file Event.h.

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

inputTree_

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

private

The input tree for reading existing data.

Definition at line 532 of file Event.h.

{nullptr};

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

knownLookups_

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

mutableprivate

Efficiency cache for empty pass name lookups.

Definition at line 565 of file Event.h.

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

outputTree_

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

private

The output tree for writing a new file.

Definition at line 527 of file Event.h.

{nullptr};

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

passName_

std::string framework::Event::passName_

private

The default pass name.

Definition at line 522 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 570 of file Event.h.

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

regexDropCollections_

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

private

Regex of collection names to not store in event.

Definition at line 560 of file Event.h.

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

---

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

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