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>
#include <typeinfo>
 
namespace framework {
 
class Event {
 public:
  Event(const std::string &passName);
 
  ~Event();
 
  ldmx::EventHeader &getEventHeader() { return event_header_; }
 
  const ldmx::EventHeader &getEventHeader() const { return event_header_; }
 
  const ldmx::EventHeader *getEventHeaderPtr() { return &event_header_; }
 
  int getEventNumber() const { return event_header_.getEventNumber(); }
 
  double getEventWeight() const { return event_header_.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);
 
  void addIgnore(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 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;
  }
 
  template <typename T>
  const T &getObject(const std::string &collectionName,
                     const std::string &passName) const {
    // 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
 
  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 pass_name_; }
 
  int getElectronCount() const { return electron_count_; }
 
  void setElectronCount(const int &electronCount) {
    electron_count_ = electronCount;
  }
 
 private:
  bool shouldDrop(const std::string &collName) const;
 
  bool shouldIgnore(const std::string &branchName) 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, pass_name_);
  }
 
 private:
  ldmx::EventHeader event_header_;
 
  std::string pass_name_;
 
  TTree *output_tree_{nullptr};
 
  TTree *input_tree_{nullptr};
 
  int electron_count_{1};
 
  mutable framework::Bus bus_;
 
  std::set<std::string> branches_filled_;
 
  std::vector<regex_t> regex_drop_collections_;
 
  std::vector<regex_t> regex_ignore_collections_;
 
  mutable std::map<std::string, std::string> known_lookups_;
 
  std::vector<ProductTag> products_;
};
}  // namespace framework
 
#endif /* FRAMEWORK_EVENT_H_ */