Event.h

Go to the documentation of this file.

 
#ifndef FRAMEWORK_EVENT_H_
#define FRAMEWORK_EVENT_H_
 
// ROOT
#include "TTree.h"
 
// LDMX
#include "Framework/Bus.h"
#include "Framework/EventHeader.h"
#include "Framework/Exception/Exception.h"
#include "Framework/ProductTag.h"
 
// STL
#include <regex.h>
 
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
 
namespace framework {
 
class Event {
 public:
  Event(const std::string &passName);
 
  ~Event();
 
  ldmx::EventHeader &getEventHeader() { return eventHeader_; }
 
  const ldmx::EventHeader *getEventHeaderPtr() { return &eventHeader_; }
 
  int getEventNumber() const { return eventHeader_.getEventNumber(); }
 
  double getEventWeight() const { return eventHeader_.getWeight(); }
 
  void Print() const;
 
  std::vector<ProductTag> searchProducts(const std::string &namematch,
                                         const std::string &passmatch,
                                         const std::string &typematch,
                                         bool full_string_match = false) const;
 
  bool exists(const std::string &name, const std::string &passName = "",
              bool unique = true) const;
 
  void addDrop(const std::string &exp);
 
  template <typename T>
  void add(const std::string &collectionName, T &obj) {
    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;
  }
 
  template <typename T>
  const T &getObject(const std::string &collectionName,
                     const std::string &passName = "") const {
    // 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
 
  template <typename ContentType>
  const std::vector<ContentType> &getCollection(
      const std::string &collectionName,
      const std::string &passName = "") const {
    return getObject<std::vector<ContentType> >(collectionName, passName);
  }
 
  template <typename KeyType, typename ValType>
  const std::map<KeyType, ValType> &getMap(
      const std::string &collectionName,
      const std::string &passName = "") const {
    return getObject<std::map<KeyType, ValType> >(collectionName, passName);
  }
 
  void setInputTree(TTree *tree);
 
  void setOutputTree(TTree *tree);
 
  TTree *createTree();
 
  const std::vector<ProductTag> &getProducts() const { return products_; }
 
  bool nextEvent();
 
  void beforeFill();
 
  void Clear();
 
  void onEndOfEvent();
 
  void onEndOfFile();
 
  std::string getPassName() { return passName_; }
 
  int getElectronCount() const { return electronCount_; }
 
  void setElectronCount(const int &electronCount) {
    electronCount_ = electronCount;
  }
 
 private:
  bool shouldDrop(const std::string &collName) const;
 
  std::string makeBranchName(const std::string &collectionName,
                             const std::string &passName) const {
    return collectionName + "_" + passName;
  }
 
  std::string makeBranchName(const std::string &collectionName) const {
    return makeBranchName(collectionName, passName_);
  }
 
 private:
  ldmx::EventHeader eventHeader_;
 
  std::string passName_;
 
  TTree *outputTree_{nullptr};
 
  TTree *inputTree_{nullptr};
 
  int electronCount_{1};
 
  mutable framework::Bus bus_;
 
  std::set<std::string> branchesFilled_;
 
  std::vector<regex_t> regexDropCollections_;
 
  mutable std::map<std::string, std::string> knownLookups_;
 
  std::vector<ProductTag> products_;
};
}  // namespace framework
 
#endif /* FRAMEWORK_EVENT_H_ */