#include <StringBasedNTupler.h>

Inheritance diagram for StringBasedNTupler:

Public Member Functions
void	callBack ()

void	fill (edm::Event &iEvent)

uint	registerleaves (edm::ProducerBase *producer)

	StringBasedNTupler (const edm::ParameterSet &iConfig)

	~StringBasedNTupler ()

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

Member Typedef Documentation

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

protected

Definition at line 486 of file StringBasedNTupler.h.

Constructor & Destructor Documentation

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

inline

Definition at line 207 of file StringBasedNTupler.h.

References b, branches_, bunchCrossing_, className(), ev_, edm::ParameterSet::exists(), experimentType_, first, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getParameterSetNames(), edm::ParameterSet::getUntrackedParameter(), prof2calltree::l, lumiblock_, model_params_, mergeVDriftHistosByStation::name, orbitNumber_, ownTheTree_, run_, edm::second(), corrVsCorr::selection, cmsHarvester::sep, alcazmumu_cfi::src, AlCaHLTBitMon_QueryRunRegistry::string, treeName_, 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 ( )

inline

Definition at line 473 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

void StringBasedNTupler::callBack ( )

inline

Definition at line 456 of file StringBasedNTupler.h.

References b, branches_, TreeBranch::dataHolderPtr(), 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();
     }
       }
     }
   }

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

inlinevirtual

Implements NTupler.

Definition at line 372 of file StringBasedNTupler.h.

References TreeBranch::assignDataHolderPtr(), b, TreeBranch::branch(), branches_, TreeBranch::branchName(), edm::EventBase::bunchCrossing(), bunchCrossing_, ev_, edm::EventID::event(), edm::EventBase::experimentType(), experimentType_, newFWLiteAna::found, edm::Event::getByLabel(), edm::EventBase::id(), indexDataHolder_, edm::EventBase::isRealData(), lumiblock_, edm::EventBase::luminosityBlock(), model_params_, edm::EventBase::orbitNumber(), orbitNumber_, ownTheTree_, edm::Event::put(), edm::EventID::run(), run_, NTupler::tree_, NTupler::useTFileService_, 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::auto_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 auto_ptr to the tree data pointer
       b.assignDataHolderPtr(branch.release());
       // for memory tracing, object b is holding the data (not auto_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::auto_ptr<std::vector<float> > branch(b.branch(iEvent));
       if (branch->size()>maxS) maxS=branch->size();
       iEvent.put(branch, b.branchName());
     }
     //index should be put only once per branch. doe not really mattter for edm root files
     std::auto_ptr<uint> maxN(new uint(maxS));
     iEvent.put(maxN, iB->first);
       }
     }
   }

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

inlinevirtual

Implements NTupler.

Definition at line 295 of file StringBasedNTupler.h.

References b, beamvalidation::br, TreeBranch::branchAlias(), branches_, TreeBranch::branchName(), TreeBranch::branchTitle(), bunchCrossing_, ev_, experimentType_, TFileService::file(), indexDataHolder_, lumiblock_, TFileService::make(), model_params_, dbtoconf::object, orbitNumber_, ownTheTree_, edm::ProductRegistryHelper::produces(), run_, NTupler::tree_, treeName_, 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
     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;
   }