#include <CachingVariable.h>

Inheritance diagram for ExpressionVariable< Object, label >:

Public Member Functions
CachingVariable::evalType	eval (const edm::Event &iEvent) const override

	ExpressionVariable (const CachingVariableFactoryArg &arg, edm::ConsumesCollector &iC)

	~ExpressionVariable () override

Public Member Functions inherited from CachingVariable
void	addDescriptionLine (const std::string &s)

	CachingVariable (std::string m, std::string n, const edm::ParameterSet &iConfig, edm::ConsumesCollector &iC)

bool	compute (const edm::Event &iEvent) const

const Description &	description () const

const std::string &	holderName () const

const std::string &	method () const

const std::string &	name () const

valueType	operator() (const edm::Event &iEvent) const

void	print () const

void	setHolder (std::string hn) const

virtual	~CachingVariable ()

Private Attributes
StringObjectFunction< Object > *	f_

StringObjectFunction< Object > *	forder_

unsigned int	index_

StringCutObjectSelector< Object > *	selector_

edm::EDGetTokenT< edm::View< Object > >	src_

edm::InputTag	srcTag_

Additional Inherited Members
Public Types inherited from CachingVariable
typedef std::pair< bool, valueType >	evalType

typedef double	valueType

typedef std::map< std::string, const CachingVariable * >	vMap

Protected Member Functions inherited from CachingVariable
evalType &	baseEval (const edm::Event &iEvent) const

bool	notSeenThisEventAlready (const edm::Event &iEvent) const

void	setCache (valueType &v) const

void	setNotCompute () const

Protected Attributes inherited from CachingVariable
evalType	cache_

edm::ParameterSet	conf_

Description	d_

edm::Event::CacheIdentifier_t	eventCacheID_ = 0

std::string	holderName_

std::string	method_

std::string	name_

Detailed Description

template<typename Object, const char * label>
class ExpressionVariable< Object, label >

Definition at line 281 of file CachingVariable.h.

Constructor & Destructor Documentation

◆ ExpressionVariable()

template<typename Object , const char * label>

ExpressionVariable< Object, label >::ExpressionVariable	(	const CachingVariableFactoryArg &	arg,
		edm::ConsumesCollector &	iC
	)

inline

Definition at line 283 of file CachingVariable.h.

References CachingVariable::addDescriptionLine(), edm::ConsumesCollector::consumes(), MillePedeFileConverter_cfg::e, electrons_cff::expr, ExpressionVariable< Object, label >::f_, ExpressionVariable< Object, label >::forder_, ExpressionVariable< Object, label >::index_, edm::ParameterSet::insert(), CachingVariable::name(), eventshapeDQM_cfi::order, corrVsCorr::selection, ExpressionVariable< Object, label >::selector_, ExpressionVariable< Object, label >::src_, ExpressionVariable< Object, label >::srcTag_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

       : CachingVariable(std::string(label) + "ExpressionVariable", arg.n, arg.iConfig, iC),
         f_(nullptr),
         forder_(nullptr) {
     srcTag_ = edm::Service<InputTagDistributorService>()->retrieve("src", arg.iConfig);
     src_ = iC.consumes<edm::View<Object> >(srcTag_);
     //old style constructor
     if (arg.iConfig.exists("expr") && arg.iConfig.exists("index")) {
       std::string expr = arg.iConfig.getParameter<std::string>("expr");
       index_ = arg.iConfig.getParameter<unsigned int>("index");
       f_ = new StringObjectFunction<Object>(expr);
       addDescriptionLine("calculating: " + expr);
       std::stringstream ss;
       ss << "on object at index: " << index_ << " of: " << srcTag_;
 
       if (arg.iConfig.exists("order")) {
         std::string order = arg.iConfig.getParameter<std::string>("order");
         forder_ = new StringObjectFunction<Object>(order);
         ss << " after sorting according to: " << order;
       } else
         forder_ = nullptr;
 
       if (arg.iConfig.exists("selection")) {
         std::string selection = arg.iConfig.getParameter<std::string>("selection");
         selector_ = new StringCutObjectSelector<Object>(selection);
         ss << " and selecting only: " << selection;
       } else
         selector_ = nullptr;
 
       addDescriptionLine(ss.str());
       ss.str("");
       arg.m[arg.n] = this;
     } else {
       //multiple instance constructor
       std::map<std::string, edm::Entry> indexEntry;
       if (arg.n.find("_N") != std::string::npos) {
         //will have to loop over indexes
         std::vector<unsigned int> indexes = arg.iConfig.getParameter<std::vector<unsigned int> >("indexes");
         for (unsigned int iI = 0; iI != indexes.size(); ++iI) {
           edm::ParameterSet toUse = arg.iConfig;
           edm::Entry e("unsigned int", indexes[iI], true);
           std::stringstream ss;
           //add +1 0->1, 1->2, ... in the variable label
           ss << indexes[iI] + 1;
           indexEntry.insert(std::make_pair(ss.str(), e));
         }
       }  //contains "_N"
 
       std::map<std::string, edm::Entry> varEntry;
       if (arg.n.find("_V") != std::string::npos) {
         //do something fancy for multiple variable from one PSet
         std::vector<std::string> vars = arg.iConfig.getParameter<std::vector<std::string> >("vars");
         for (unsigned int v = 0; v != vars.size(); ++v) {
           unsigned int sep = vars[v].find(':');
           std::string name = vars[v].substr(0, sep);
           std::string expr = vars[v].substr(sep + 1);
 
           edm::Entry e("string", expr, true);
           varEntry.insert(std::make_pair(name, e));
         }
       }  //contains "_V"
 
       std::string radical = arg.n;
       //remove the "_V";
       if (!varEntry.empty())
         radical = radical.substr(0, radical.size() - 2);
       //remove the "_N";
       if (!indexEntry.empty())
         radical = radical.substr(0, radical.size() - 2);
 
       if (varEntry.empty()) {
         //loop only the indexes
         for (std::map<std::string, edm::Entry>::iterator iIt = indexEntry.begin(); iIt != indexEntry.end(); ++iIt) {
           edm::ParameterSet toUse = arg.iConfig;
           toUse.insert(true, "index", iIt->second);
           std::string newVname = radical + iIt->first;
           //      std::cout<<"in the loop, creating variable with name: "<<newVname<<std::endl;
           // the constructor auto log the new variable in the map
           new ExpressionVariable(CachingVariable::CachingVariableFactoryArg(newVname, arg.m, toUse), iC);
         }
       } else {
         for (std::map<std::string, edm::Entry>::iterator vIt = varEntry.begin(); vIt != varEntry.end(); ++vIt) {
           if (indexEntry.empty()) {
             edm::ParameterSet toUse = arg.iConfig;
             toUse.insert(true, "expr", vIt->second);
             std::string newVname = radical + vIt->first;
             //      std::cout<<"in the loop, creating variable with name: "<<newVname<<std::endl;
             // the constructor auto log the new variable in the map
             new ExpressionVariable(CachingVariable::CachingVariableFactoryArg(newVname, arg.m, toUse), iC);
           } else {
             for (std::map<std::string, edm::Entry>::iterator iIt = indexEntry.begin(); iIt != indexEntry.end(); ++iIt) {
               edm::ParameterSet toUse = arg.iConfig;
               toUse.insert(true, "expr", vIt->second);
               toUse.insert(true, "index", iIt->second);
               std::string newVname = radical + iIt->first + vIt->first;
               //          std::cout<<"in the loop, creating variable with name: "<<newVname<<std::endl;
               // the constructor auto log the new variable in the map
               new ExpressionVariable(CachingVariable::CachingVariableFactoryArg(newVname, arg.m, toUse), iC);
             }
           }
         }
       }
       //there is a memory leak here, because the object we are in is not logged in the arg.m, the variable is not valid
       // anyways, but reside in memory with no ways of de-allocating it.
       // since the caching variables are actually "global" objects, it does not matter.
       // we cannot add it to the map, otherwise, it would be considered for eventV ntupler
     }
   }

◆ ~ExpressionVariable()

template<typename Object , const char * label>

ExpressionVariable< Object, label >::~ExpressionVariable ( )

inlineoverride

Definition at line 391 of file CachingVariable.h.

References ExpressionVariable< Object, label >::f_, ExpressionVariable< Object, label >::forder_, and ExpressionVariable< Object, label >::selector_.

                                  {
     if (f_)
       delete f_;
     if (forder_)
       delete forder_;
     if (selector_)
       delete selector_;
   }

Member Function Documentation

◆ eval()

template<typename Object , const char * label>

CachingVariable::evalType ExpressionVariable< Object, label >::eval ( const edm::Event & iEvent ) const

inlineoverridevirtual

Reimplemented from CachingVariable.

Definition at line 400 of file CachingVariable.h.

References ExpressionVariable< Object, label >::f_, ExpressionVariable< Object, label >::forder_, mps_fire::i, iEvent, ExpressionVariable< Object, label >::index_, LogDebug, CachingVariable::method(), EcalTangentSkim_cfg::o, ExpressionVariable< Object, label >::selector_, jetUpdater_cfi::sort, ExpressionVariable< Object, label >::src_, and ExpressionVariable< Object, label >::srcTag_.

                                                                       {
     if (!f_) {
       edm::LogError(method()) << " no parser attached.";
       return std::make_pair(false, 0);
     }
     edm::Handle<edm::View<Object> > oH;
     iEvent.getByToken(src_, oH);
     if (index_ >= oH->size()) {
       LogDebug(method()) << "fail to get object at index: " << index_ << " in collection: " << srcTag_;
       return std::make_pair(false, 0);
     }
 
     //get the ordering right first. if required
     if (selector_ || forder_) {
       std::vector<const Object*> copyToSort(0);
       copyToSort.reserve(oH->size());
       for (unsigned int i = 0; i != oH->size(); ++i) {
         if (selector_ && !((*selector_)((*oH)[i])))
           continue;
         copyToSort.push_back(&(*oH)[i]);
       }
       if (index_ >= copyToSort.size())
         return std::make_pair(false, 0);
       if (forder_)
         std::sort(copyToSort.begin(), copyToSort.end(), sortByStringFunction<Object>(forder_));
 
       const Object* o = copyToSort[index_];
       return std::make_pair(true, (*f_)(*o));
     } else {
       const Object& o = (*oH)[index_];
       return std::make_pair(true, (*f_)(o));
     }
   }