#include <StringBasedNTupler.h>

Inheritance diagram for StringBasedNTupler:

Public Member Functions
void	callBack ()

void	fill (edm::Event &iEvent) override

uint	registerleaves (edm::ProducesCollector producesCollector) override

	StringBasedNTupler (const edm::ParameterSet &iConfig)

	~StringBasedNTupler () override

Public Member Functions inherited from NTupler
	NTupler ()

virtual	~NTupler ()

Protected Types
typedef std::map< std::string, std::vector< TreeBranch > >	Branches

Protected Attributes
Branches	branches_

uint *	bunchCrossing_

uint64_t *	ev_

uint *	experimentType_

uint *	indexDataHolder_

uint *	lumiblock_

std::string *	model_params_

uint *	orbitNumber_

bool	ownTheTree_

uint *	run_

std::string	treeName_

float *	weight_

Protected Attributes inherited from NTupler
TTree *	tree_

bool	useTFileService_

Detailed Description

Definition at line 201 of file StringBasedNTupler.h.

Member Typedef Documentation

◆ Branches

typedef std::map<std::string, std::vector<TreeBranch> > StringBasedNTupler::Branches

protected

Definition at line 473 of file StringBasedNTupler.h.

Constructor & Destructor Documentation

◆ StringBasedNTupler()

StringBasedNTupler::StringBasedNTupler ( const edm::ParameterSet & iConfig )

inline

Definition at line 203 of file StringBasedNTupler.h.

                                                      {
     edm::ParameterSet branchesPSet = iConfig.getParameter<edm::ParameterSet>("branchesPSet");
     std::vector<std::string> branches;
     branchesPSet.getParameterSetNames(branches);
     const std::string separator = branchesPSet.getUntrackedParameter<std::string>("separator", ":");
     for (uint b = 0; b != branches.size(); ++b) {
       edm::ParameterSet bPSet = branchesPSet.getParameter<edm::ParameterSet>(branches[b]);
       std::string className = "";
       if (bPSet.exists("class"))
         className = bPSet.getParameter<std::string>("class");
       else
         className = bPSet.getParameter<std::string>("Class");
       edm::InputTag src = edm::Service<InputTagDistributorService>()->retrieve("src", bPSet);
       edm::ParameterSet leavesPSet = bPSet.getParameter<edm::ParameterSet>("leaves");
       std::string order = "";
       if (bPSet.exists("order"))
         order = bPSet.getParameter<std::string>("order");
       std::string selection = "";
       if (bPSet.exists("selection"))
         selection = bPSet.getParameter<std::string>("selection");
       // do it one by one with configuration [string x = "x"]
       std::vector<std::string> leaves = leavesPSet.getParameterNamesForType<std::string>();
       std::string maxName = "N" + branches[b];
       for (uint l = 0; l != leaves.size(); ++l) {
         std::string leave_expr = leavesPSet.getParameter<std::string>(leaves[l]);
         std::string branchAlias = branches[b] + "_" + leaves[l];
  
         //add a branch manager for this expression on this collection
         branches_[maxName].push_back(TreeBranch(className, src, leave_expr, order, selection, maxName, branchAlias));
       }  //loop the provided leaves
  
       //do it once with configuration [vstring vars = { "x:x" ,... } ] where ":"=separator
       if (leavesPSet.exists("vars")) {
         std::vector<std::string> leavesS = leavesPSet.getParameter<std::vector<std::string> >("vars");
         for (uint l = 0; l != leavesS.size(); ++l) {
           uint sep = leavesS[l].find(separator);
           std::string name = leavesS[l].substr(0, sep);
           //removes spaces from the variable name
           /*uint*/ int space = name.find(" ");
           while (space != -1 /*std::string::npos*/) {
             std::string first = name.substr(0, space);
             std::string second = name.substr(space + 1);
             name = first + second;
             space = name.find(" ");
           }
           std::string expr = leavesS[l].substr(sep + 1);
           std::string branchAlias = branches[b] + "_" + name;
  
           //add a branch manager for this expression on this collection
           branches_[maxName].push_back(TreeBranch(className, src, expr, order, selection, maxName, branchAlias));
         }
       }
  
     }  //loop the provided branches
  
     ev_ = new uint64_t;
     run_ = new uint;
     lumiblock_ = new uint;
     experimentType_ = new uint;
     bunchCrossing_ = new uint;
     orbitNumber_ = new uint;
     weight_ = new float;
     model_params_ = new std::string;
  
     if (branchesPSet.exists("useTFileService"))
       useTFileService_ = branchesPSet.getParameter<bool>("useTFileService");
     else
       useTFileService_ = iConfig.getParameter<bool>("useTFileService");
  
     if (useTFileService_) {
       if (branchesPSet.exists("treeName")) {
         treeName_ = branchesPSet.getParameter<std::string>("treeName");
         ownTheTree_ = true;
       } else {
         treeName_ = iConfig.getParameter<std::string>("treeName");
         ownTheTree_ = false;
       }
     }
   }

References b, branches_, bunchCrossing_, className(), ev_, edm::ParameterSet::exists(), experimentType_, jets_cff::expr, dqmdumpme::first, dqmMemoryStats::float, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getParameterSetNames(), edm::ParameterSet::getUntrackedParameter(), cmsLHEtoEOSManager::l, lumiblock_, model_params_, Skims_PA_cff::name, orbitNumber_, eventshapeDQM_cfi::order, ownTheTree_, run_, edm::second(), corrVsCorr::selection, mps_merge::separator, TrackRefitter_38T_cff::src, AlCaHLTBitMon_QueryRunRegistry::string, treeName_, parallelization::uint, NTupler::useTFileService_, and weight_.

◆ ~StringBasedNTupler()

StringBasedNTupler::~StringBasedNTupler ( )

inlineoverride

Definition at line 460 of file StringBasedNTupler.h.

                                  {
     delete indexDataHolder_;
     delete ev_;
     delete run_;
     delete lumiblock_;
     delete experimentType_;
     delete bunchCrossing_;
     delete orbitNumber_;
     delete weight_;
     delete model_params_;
   }

References bunchCrossing_, ev_, experimentType_, indexDataHolder_, lumiblock_, model_params_, orbitNumber_, run_, and weight_.

Member Function Documentation

◆ callBack()

void StringBasedNTupler::callBack ( )

inline

Definition at line 444 of file StringBasedNTupler.h.

                   {
     if (useTFileService_) {
       Branches::iterator iB = branches_.begin();
       Branches::iterator iB_end = branches_.end();
       //de-allocate memory now: allocated in branch(...) and released to the pointer.
       for (; iB != iB_end; ++iB) {
         std::vector<TreeBranch>::iterator iL = iB->second.begin();
         std::vector<TreeBranch>::iterator iL_end = iB->second.end();
         for (; iL != iL_end; ++iL) {
           TreeBranch& b = *iL;
           delete b.dataHolderPtr();
         }
       }
     }
   }

References b, branches_, and NTupler::useTFileService_.

Referenced by CompleteNTupler::fill().

◆ fill()

void StringBasedNTupler::fill ( edm::Event & iEvent )

inlineoverridevirtual

Implements NTupler.

Definition at line 358 of file StringBasedNTupler.h.

                                        {
     //    if (!edm::Service<UpdaterService>()->checkOnce("StringBasedNTupler::fill")) return;
     //well if you do that, you cannot have two ntupler of the same type in the same job...
  
     if (useTFileService_) {
       // loop the automated leafer
       Branches::iterator iB = branches_.begin();
       Branches::iterator iB_end = branches_.end();
       uint indexOfIndexInDataHolder = 0;
       for (; iB != iB_end; ++iB, ++indexOfIndexInDataHolder) {
         std::vector<TreeBranch>::iterator iL = iB->second.begin();
         std::vector<TreeBranch>::iterator iL_end = iB->second.end();
         uint maxS = 0;
         for (; iL != iL_end; ++iL) {
           TreeBranch& b = *iL;
           // grab the vector of values from the interpretation of expression for the associated collection
           std::unique_ptr<std::vector<float> > branch(b.branch(iEvent));
           // calculate the maximum index size.
           if (branch->size() > maxS)
             maxS = branch->size();
           // transfer of (no copy) pointer to the vector of float from the std::unique_ptr to the tree data pointer
           b.assignDataHolderPtr(branch.release());
           // for memory tracing, object b is holding the data (not std::unique_ptr) and should delete it for each event (that's not completely optimum)
         }
         //assigne the maximum vector size for this collection
         indexDataHolder_[indexOfIndexInDataHolder] = maxS;
       }
  
       //fill event info.
       *run_ = iEvent.id().run();
       *ev_ = iEvent.id().event();
       //      *lumiblock_ = iEvent.id().luminosityBlock();
       *lumiblock_ = iEvent.luminosityBlock();
       *experimentType_ = iEvent.experimentType();
       *bunchCrossing_ = iEvent.bunchCrossing();
       *orbitNumber_ = iEvent.orbitNumber();
  
       *weight_ = 1;
       if (!iEvent.isRealData()) {
         edm::Handle<GenEventInfoProduct> wgeneventinfo;
         iEvent.getByLabel("generator", wgeneventinfo);
         *weight_ = wgeneventinfo->weight();
       }
  
       typedef std::vector<std::string>::const_iterator comments_const_iterator;
       //      using namespace edm;
  
       edm::Handle<LHEEventProduct> product;
       *model_params_ = "NULL";
       if (iEvent.getByLabel("source", product)) {
         comments_const_iterator c_begin = product->comments_begin();
         comments_const_iterator c_end = product->comments_end();
  
         for (comments_const_iterator cit = c_begin; cit != c_end; ++cit) {
           size_t found = (*cit).find("model");
           if (found != std::string::npos) {
             //std::cout << *cit << std::endl;
             *model_params_ = *cit;
           }
         }
       }
  
       if (ownTheTree_) {
         tree_->Fill();
       }
     } else {
       // loop the automated leafer
       Branches::iterator iB = branches_.begin();
       Branches::iterator iB_end = branches_.end();
       for (; iB != iB_end; ++iB) {
         std::vector<TreeBranch>::iterator iL = iB->second.begin();
         std::vector<TreeBranch>::iterator iL_end = iB->second.end();
         uint maxS = 0;
         for (; iL != iL_end; ++iL) {
           TreeBranch& b = *iL;
           std::unique_ptr<std::vector<float> > branch(b.branch(iEvent));
           if (branch->size() > maxS)
             maxS = branch->size();
           iEvent.put(std::move(branch), b.branchName());
         }
         //index should be put only once per branch. doe not really mattter for edm root files
         iEvent.put(std::make_unique<uint>(maxS), iB->first);
       }
     }
   }

References b, MicroEventContent_cff::branch, branches_, bunchCrossing_, LHEEventProduct::comments_begin(), LHEEventProduct::comments_end(), ev_, experimentType_, newFWLiteAna::found, iEvent, indexDataHolder_, lumiblock_, model_params_, eostools::move(), orbitNumber_, ownTheTree_, run_, NTupler::tree_, parallelization::uint, NTupler::useTFileService_, GenEventInfoProduct::weight(), and weight_.

Referenced by CompleteNTupler::fill().

◆ registerleaves()

uint StringBasedNTupler::registerleaves ( edm::ProducesCollector producesCollector )

inlineoverridevirtual

Implements NTupler.

Definition at line 283 of file StringBasedNTupler.h.

                                                                        {
     uint nLeaves = 0;
  
     if (useTFileService_) {
       edm::Service<TFileService> fs;
       if (ownTheTree_) {
         ownTheTree_ = true;
         tree_ = fs->make<TTree>(treeName_.c_str(), "StringBasedNTupler tree");
       } else {
         TObject* object = fs->file().Get(treeName_.c_str());
         if (!object) {
           ownTheTree_ = true;
           tree_ = fs->make<TTree>(treeName_.c_str(), "StringBasedNTupler tree");
         } else {
           tree_ = dynamic_cast<TTree*>(object);
           if (!tree_) {
             ownTheTree_ = true;
             tree_ = fs->make<TTree>(treeName_.c_str(), "StringBasedNTupler tree");
           } else
             ownTheTree_ = false;
         }
       }
  
       //reserve memory for the indexes
       indexDataHolder_ = new uint[branches_.size()];
       // loop the automated leafer
       Branches::iterator iB = branches_.begin();
       Branches::iterator iB_end = branches_.end();
       uint indexOfIndexInDataHolder = 0;
       for (; iB != iB_end; ++iB, ++indexOfIndexInDataHolder) {
         //create a branch for the index: an integer
         tree_->Branch(iB->first.c_str(), &(indexDataHolder_[indexOfIndexInDataHolder]), (iB->first + "/i").c_str());
         //loop on the "leaves"
         std::vector<TreeBranch>::iterator iL = iB->second.begin();
         std::vector<TreeBranch>::iterator iL_end = iB->second.end();
         for (; iL != iL_end; ++iL) {
           TreeBranch& b = *iL;
           //create a branch for the leaves: vector of floats
           TBranch* br = tree_->Branch(b.branchAlias().c_str(), "std::vector<float>", iL->dataHolderPtrAdress());
           br->SetTitle(b.branchTitle().c_str());
           nLeaves++;
         }
       }
  
       //extra leaves for event info.
       tree_->Branch("run", run_, "run/i");
       tree_->Branch("event", ev_, "event/l");
       tree_->Branch("lumiblock", lumiblock_, "lumiblock/i");
       tree_->Branch("experimentType", experimentType_, "experimentType/i");
       tree_->Branch("bunchCrossing", bunchCrossing_, "bunchCrossing/i");
       tree_->Branch("orbitNumber", orbitNumber_, "orbitNumber/i");
       tree_->Branch("weight", weight_, "weight/f");
       tree_->Branch("model_params", &model_params_);
  
     } else {
       // loop the automated leafer
       Branches::iterator iB = branches_.begin();
       Branches::iterator iB_end = branches_.end();
       for (; iB != iB_end; ++iB) {
         //the index. should produce it only once
         // a simple uint for the index
         producesCollector.produces<uint>(iB->first).setBranchAlias(iB->first);
         std::vector<TreeBranch>::iterator iL = iB->second.begin();
         std::vector<TreeBranch>::iterator iL_end = iB->second.end();
         for (; iL != iL_end; ++iL) {
           TreeBranch& b = *iL;
           //a vector of float for each leave
           producesCollector.produces<std::vector<float> >(b.branchName()).setBranchAlias(b.branchAlias());
           nLeaves++;
         }
       }
     }
     return nLeaves;
   }