NtupleManager.h

 
#ifndef _NTUPLE_MANAGER_H_
#define _NTUPLE_MANAGER_H_
 
/*~~~~~~~~~~~~*/
/*   StdLib   */
/*~~~~~~~~~~~~*/
#include <string>
#include <unordered_map>
 
/*~~~~~~~~~~*/
/*   ROOT   */
/*~~~~~~~~~~*/
#include "TTree.h"
 
/*~~~~~~~~~~*/
/*   Core   */
/*~~~~~~~~~~*/
#include "Framework/Bus.h"
#include "Framework/Exception/Exception.h"
#include "Framework/Logger.h"
 
namespace framework {
 
class NtupleManager {
 public:
  static NtupleManager& getInstance();
 
  void create(const std::string& tname);
 
  template <typename VarType>
  void addVar(const std::string& tname, const std::string& vname) {
    // Check if a tree named 'tname' has already been created.  If
    // not, throw an exception.
    if (trees_.count(tname) == 0)
      EXCEPTION_RAISE("NtupleManager", "A tree with name " + tname +
                                           " has not been been created.");
 
    // Check if the variable exists in the map. If it does, throw
    // an exception.
    if (bus_.isOnBoard(vname)) {
      EXCEPTION_RAISE("NtupleManager", "A variable with name " + vname +
                                           " has already been defined.");
    }
 
    // Board the bus
    bus_.board<VarType>(vname);
 
    // Attach the tree to the bus
    bus_.attach(trees_[tname], vname, true);
  }
 
  template <typename T>
  void setVar(const std::string& vname, const T& value) {
    // Check if the variable already exists in the map.  If it
    // doesn't, warn the user and don't try to set the variable
    // value.
    if (not bus_.isOnBoard(vname)) {
      ldmx_log(warn) << "The variable " << vname
                     << " does not exist in the tree. Skipping.";
      return;
    }
 
    // Set the value of the variable
    try {
      bus_.update(vname, value);
    } catch (const std::bad_cast&) {
      EXCEPTION_RAISE("TypeMismatch", "Ntuple variable '" + vname +
                                          "' is being set by the wrong type '" +
                                          typeid(value).name() + "'.");
    }
  }
 
  // Fill all of the ROOT trees.
  void fill();
 
  void clear();
 
  void reset();
 
  NtupleManager(const NtupleManager&) = delete;
 
  void operator=(const NtupleManager&) = delete;
 
 private:
  std::unordered_map<std::string, TTree*> trees_;
 
  framework::Bus bus_;
 
  NtupleManager();
 
  enableLogging("NtupleManager")
 
};  // NtupleManager
 
}  // namespace framework
 
#endif  // _NTUPLE_MANAGER_H_