StringBasedNTupler Class Reference

#include <StringBasedNTupler.h>

Inheritance diagram for StringBasedNTupler:

Public Member Functions
void	callBack ()
void	fill (edm::Event &iEvent) override
uint	registerleaves (edm::ProducerBase *producer) 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 202 of file StringBasedNTupler.h.

Member Typedef Documentation

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

protected

Definition at line 484 of file StringBasedNTupler.h.

Constructor & Destructor Documentation

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

inline

Definition at line 206 of file StringBasedNTupler.h.

References b, TreeBranch::branchAlias(), TreeBranch::className(), edm::ParameterSet::exists(), TreeBranch::expr(), plotBeamSpotDB::first, objects.autophobj::float, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getParameterSetNames(), edm::ParameterSet::getUntrackedParameter(), checklumidiff::l, dataset::name, TreeBranch::order(), edm::second(), TreeBranch::selection(), mps_merge::separator, TreeBranch::src(), AlCaHLTBitMon_QueryRunRegistry::string, TreeBranch::TreeBranch(), and parallelization::uint().

                                                    {



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

inlineoverride

Definition at line 471 of file StringBasedNTupler.h.

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

Member Function Documentation

void StringBasedNTupler::callBack ( )

inline

Definition at line 454 of file StringBasedNTupler.h.

References b, and TreeBranch::dataHolderPtr().

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

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

inlineoverridevirtual

Implements NTupler.

Definition at line 371 of file StringBasedNTupler.h.

References TreeBranch::assignDataHolderPtr(), b, TreeBranch::branch(), TreeBranch::branchName(), edm::EventBase::bunchCrossing(), LHEEventProduct::comments_begin(), LHEEventProduct::comments_end(), edm::EventID::event(), edm::EventBase::experimentType(), runEdmFileComparison::found, edm::Event::getByLabel(), edm::EventBase::id(), edm::EventBase::isRealData(), edm::EventBase::luminosityBlock(), eostools::move(), edm::EventBase::orbitNumber(), edm::Event::put(), edm::EventID::run(), parallelization::uint(), and GenEventInfoProduct::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);
      }
    }
  }

uint StringBasedNTupler::registerleaves ( edm::ProducerBase *  producer )

inlineoverridevirtual

Implements NTupler.

Definition at line 294 of file StringBasedNTupler.h.

References b, beamvalidation::br, TreeBranch::branchAlias(), TreeBranch::branchName(), TreeBranch::branchTitle(), TFileService::file(), TFileService::make(), resolutioncreator_cfi::object, edm::ProductRegistryHelper::produces(), and parallelization::uint().

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
    producer->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
      producer->produces<std::vector<float> >(b.branchName()).setBranchAlias(b.branchAlias());
      nLeaves++;
    }
      }
    }
    return nLeaves;
  }

Member Data Documentation

Branches StringBasedNTupler::branches_

protected

Definition at line 485 of file StringBasedNTupler.h.

uint* StringBasedNTupler::bunchCrossing_

protected

Definition at line 496 of file StringBasedNTupler.h.

uint64_t* StringBasedNTupler::ev_

protected

Definition at line 492 of file StringBasedNTupler.h.

uint* StringBasedNTupler::experimentType_

protected

Definition at line 495 of file StringBasedNTupler.h.

uint* StringBasedNTupler::indexDataHolder_

protected

Definition at line 489 of file StringBasedNTupler.h.

uint* StringBasedNTupler::lumiblock_

protected

Definition at line 494 of file StringBasedNTupler.h.

std::string* StringBasedNTupler::model_params_

protected

Definition at line 499 of file StringBasedNTupler.h.

uint* StringBasedNTupler::orbitNumber_

protected

Definition at line 497 of file StringBasedNTupler.h.

bool StringBasedNTupler::ownTheTree_

protected

Definition at line 487 of file StringBasedNTupler.h.

uint* StringBasedNTupler::run_

protected

Definition at line 493 of file StringBasedNTupler.h.

std::string StringBasedNTupler::treeName_

protected

Definition at line 488 of file StringBasedNTupler.h.

float* StringBasedNTupler::weight_

protected

Definition at line 498 of file StringBasedNTupler.h.