StringBasedNTupler Class Reference

#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 198 of file StringBasedNTupler.h.

Member Typedef Documentation

Branches

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

protected

Definition at line 470 of file StringBasedNTupler.h.

Constructor & Destructor Documentation

StringBasedNTupler()

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

inline

Definition at line 200 of file StringBasedNTupler.h.

References b, branches_, bunchCrossing_, className(), ev_, edm::ParameterSet::exists(), experimentType_, dqmdumpme::first, dqmMemoryStats::float, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getParameterSetNames(), edm::ParameterSet::getUntrackedParameter(), MainPageGenerator::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_.

                                                     {
    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;
      }
    }
  }

~StringBasedNTupler()

StringBasedNTupler::~StringBasedNTupler ( )

inlineoverride

Definition at line 457 of file StringBasedNTupler.h.

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

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

Member Function Documentation

callBack()

void StringBasedNTupler::callBack ( )

inline

Definition at line 441 of file StringBasedNTupler.h.

References b, branches_, and NTupler::useTFileService_.

Referenced by CompleteNTupler::fill().

                  {
    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();
        }
      }
    }
  }

fill()

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

inlineoverridevirtual

Implements NTupler.

Definition at line 355 of file StringBasedNTupler.h.

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().

                                       {
    //    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);
      }
    }
  }

registerleaves()

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

inlineoverridevirtual

Implements NTupler.

Definition at line 280 of file StringBasedNTupler.h.

References b, beamvalidation::br, branches_, bunchCrossing_, ev_, experimentType_, compareTotals::fs, indexDataHolder_, lumiblock_, model_params_, resolutioncreator_cfi::object, orbitNumber_, ownTheTree_, edm::ProducesCollector::produces(), run_, NTupler::tree_, treeName_, parallelization::uint, NTupler::useTFileService_, and weight_.

Referenced by CompleteNTupler::registerleaves().

                                                                       {
    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;
  }

Member Data Documentation

branches_

Branches StringBasedNTupler::branches_

protected

Definition at line 471 of file StringBasedNTupler.h.

Referenced by callBack(), fill(), registerleaves(), and StringBasedNTupler().

bunchCrossing_

uint* StringBasedNTupler::bunchCrossing_

protected

Definition at line 482 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

ev_

uint64_t* StringBasedNTupler::ev_

protected

Definition at line 478 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

experimentType_

uint* StringBasedNTupler::experimentType_

protected

Definition at line 481 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

indexDataHolder_

uint* StringBasedNTupler::indexDataHolder_

protected

Definition at line 475 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), and ~StringBasedNTupler().

lumiblock_

uint* StringBasedNTupler::lumiblock_

protected

Definition at line 480 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

model_params_

std::string* StringBasedNTupler::model_params_

protected

Definition at line 485 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

orbitNumber_

uint* StringBasedNTupler::orbitNumber_

protected

Definition at line 483 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

ownTheTree_

bool StringBasedNTupler::ownTheTree_

protected

Definition at line 473 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), and StringBasedNTupler().

run_

uint* StringBasedNTupler::run_

protected

Definition at line 479 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().

treeName_

std::string StringBasedNTupler::treeName_

protected

Definition at line 474 of file StringBasedNTupler.h.

Referenced by registerleaves(), and StringBasedNTupler().

weight_

float* StringBasedNTupler::weight_

protected

Definition at line 484 of file StringBasedNTupler.h.

Referenced by fill(), registerleaves(), StringBasedNTupler(), and ~StringBasedNTupler().