#include <VariableNTupler.h>

Inheritance diagram for VariableNTupler:

Public Member Functions
void	callBack ()

void	fill (edm::Event &iEvent) override

uint	registerleaves (edm::ProducesCollector producesCollector) override

	VariableNTupler (const edm::ParameterSet &iConfig)

Public Member Functions inherited from NTupler
	NTupler ()

virtual	~NTupler ()

Protected Types
typedef std::map< std::string, const CachingVariable * >::iterator	iterator

Protected Attributes
double *	dataHolder_

std::map< std::string, const CachingVariable * >	leaves_

bool	ownTheTree_

std::string	treeName_

Protected Attributes inherited from NTupler
TTree *	tree_

bool	useTFileService_

Detailed Description

Definition at line 23 of file VariableNTupler.h.

Member Typedef Documentation

typedef std::map<std::string, const CachingVariable*>::iterator VariableNTupler::iterator

protected

Definition at line 126 of file VariableNTupler.h.

Constructor & Destructor Documentation

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

inline

Definition at line 25 of file VariableNTupler.h.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), mps_fire::i, leaves_, ownTheTree_, AlCaHLTBitMon_QueryRunRegistry::string, treeName_, parallelization::uint, NTupler::useTFileService_, and findQualityFiles::v.

                                                   {
     ownTheTree_ = false;
     edm::ParameterSet variablePSet = iConfig.getParameter<edm::ParameterSet>("variablesPSet");
     if (variablePSet.getParameter<bool>("allVariables")) {
       VariableHelper::iterator v = edm::Service<VariableHelperService>()->get().begin();
       VariableHelper::iterator v_end = edm::Service<VariableHelperService>()->get().end();
       for (; v != v_end; ++v) {
         leaves_[v->second->name()] = v->second;
       }
     } else {
       std::vector<std::string> leaves = variablePSet.getParameter<std::vector<std::string> >("leaves");
       for (uint i = 0; i != leaves.size(); ++i) {
         leaves_[leaves[i]] = edm::Service<VariableHelperService>()->get().variable(leaves[i]);
       }
     }
     if (variablePSet.exists("useTFileService"))
       useTFileService_ = variablePSet.getParameter<bool>("useTFileService");
     else
       useTFileService_ = iConfig.getParameter<bool>("useTFileService");
 
     if (useTFileService_) {
       if (variablePSet.exists("treeName"))
         treeName_ = variablePSet.getParameter<std::string>("treeName");
       else
         treeName_ = iConfig.getParameter<std::string>("treeName");
     }
   }

Member Function Documentation

void VariableNTupler::callBack ( )

inline

Definition at line 123 of file VariableNTupler.h.

Referenced by CompleteNTupler::fill().

123 {}

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

inlineoverridevirtual

Implements NTupler.

Definition at line 98 of file VariableNTupler.h.

References dataHolder_, mps_fire::i, leaves_, simpleEdmComparison::lName, eostools::move(), ownTheTree_, edm::Event::put(), python.rootplot.root2matplotlib::replace(), AlCaHLTBitMon_QueryRunRegistry::string, NTupler::tree_, parallelization::uint, and NTupler::useTFileService_.

Referenced by CompleteNTupler::fill().

                                        {
     if (useTFileService_) {
       //fill the data holder
       iterator i = leaves_.begin();
       iterator i_end = leaves_.end();
       uint iInDataHolder = 0;
       for (; i != i_end; ++i, ++iInDataHolder) {
         dataHolder_[iInDataHolder] = (*i->second)(iEvent);
       }
       //fill into root;
       if (ownTheTree_) {
         tree_->Fill();
       }
     } else {
       //other leaves
       iterator i = leaves_.begin();
       iterator i_end = leaves_.end();
       for (; i != i_end; ++i) {
         auto leafValue = std::make_unique<double>((*i->second)(iEvent));
         std::string lName(i->first);
         std::replace(lName.begin(), lName.end(), '_', '0');
         iEvent.put(std::move(leafValue), lName);
       }
     }
   }

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

inlineoverridevirtual

Implements NTupler.

Definition at line 53 of file VariableNTupler.h.

References dataHolder_, TFileService::file(), mps_fire::i, leaves_, simpleEdmComparison::lName, TFileService::make(), resolutioncreator_cfi::object, ownTheTree_, edm::ProducesCollector::produces(), python.rootplot.root2matplotlib::replace(), AlCaHLTBitMon_QueryRunRegistry::string, NTupler::tree_, treeName_, parallelization::uint, and NTupler::useTFileService_.

Referenced by CompleteNTupler::registerleaves().

                                                                        {
     uint nLeaves = 0;
     if (useTFileService_) {
       //loop the leaves registered
       nLeaves = leaves_.size();
       // make arrays of pointer to the actual values
       dataHolder_ = new double[nLeaves];
       iterator i = leaves_.begin();
       iterator i_end = leaves_.end();
       edm::Service<TFileService> fs;
       if (ownTheTree_) {
         ownTheTree_ = true;
         tree_ = fs->make<TTree>(treeName_.c_str(), "VariableNTupler tree");
       } else {
         TObject* object = fs->file().Get(treeName_.c_str());
         if (!object) {
           ownTheTree_ = true;
           tree_ = fs->make<TTree>(treeName_.c_str(), "VariableNTupler tree");
         } else {
           tree_ = dynamic_cast<TTree*>(object);
           if (!tree_) {
             ownTheTree_ = true;
             tree_ = fs->make<TTree>(treeName_.c_str(), "VariableNTupler tree");
           } else
             ownTheTree_ = false;
         }
       }
       uint iInDataHolder = 0;
       for (; i != i_end; ++i, ++iInDataHolder) {
         tree_->Branch(i->first.c_str(), &(dataHolder_[iInDataHolder]), (i->first + "/D").c_str());
       }
     } else {
       //loop the leaves registered
       iterator i = leaves_.begin();
       iterator i_end = leaves_.end();
       for (; i != i_end; ++i) {
         nLeaves++;
         std::string lName(i->first);
         std::replace(lName.begin(), lName.end(), '_', '0');
         producesCollector.produces<double>(lName).setBranchAlias(i->first);
       }
     }
     return nLeaves;
   }