#include <CachingVariable.h>

Inheritance diagram for ExpressionVariable< Object, label >:

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

	ExpressionVariable (CachingVariableFactoryArg arg)

	~ExpressionVariable ()

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

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

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::InputTag	src_

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

void	setCache (valueType &v) const

void	setNotCompute () const

Protected Attributes inherited from CachingVariable
evalType	cache_

edm::ParameterSet	conf_

Description	d_

std::string	holderName_

std::string	method_

std::string	name_

Detailed Description

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

Definition at line 256 of file CachingVariable.h.

Constructor & Destructor Documentation

template<typename Object , const char * label>

ExpressionVariable< Object, label >::ExpressionVariable ( CachingVariableFactoryArg arg )

inline

Definition at line 258 of file CachingVariable.h.

References CachingVariable::addDescriptionLine(), alignCSCRings::e, edm::ParameterSet::exists(), ExpressionVariable< Object, label >::f_, ExpressionVariable< Object, label >::forder_, edm::ParameterSet::getParameter(), CachingVariable::CachingVariableFactoryArg::iConfig, ExpressionVariable< Object, label >::index_, edm::ParameterSet::insert(), CachingVariable::CachingVariableFactoryArg::m, CachingVariable::CachingVariableFactoryArg::n, CachingVariable::name(), corrVsCorr::selection, ExpressionVariable< Object, label >::selector_, ExpressionVariable< Object, label >::src_, and v.

                                                     :
     CachingVariable(std::string(label)+"ExpressionVariable",arg.n,arg.iConfig) , f_(0), forder_(0) {
     src_=edm::Service<InputTagDistributorService>()->retrieve("src",arg.iConfig);
     //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: "<<src_;
 
       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_ =0;
 
       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_=0;
 
 
 
       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));
     }
       }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));
       }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));
         }}
     }
       }
       //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
     }
   }

template<typename Object , const char * label>

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

inline

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

template<typename Object , const char * label>

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

inlinevirtual

Reimplemented from CachingVariable.

Definition at line 368 of file CachingVariable.h.

References ExpressionVariable< Object, label >::f_, ExpressionVariable< Object, label >::forder_, edm::Event::getByLabel(), i, ExpressionVariable< Object, label >::index_, LogDebug, CachingVariable::method(), python.connectstrParser::o, ExpressionVariable< Object, label >::selector_, python.multivaluedict::sort(), and ExpressionVariable< Object, label >::src_.

                                                               {
     if (!f_) {
       edm::LogError(method())<<" no parser attached.";
       return std::make_pair(false,0);
     }
     edm::Handle<edm::View<Object> > oH;
     iEvent.getByLabel(src_,oH);
     if (index_>=oH->size()){
       LogDebug(method())<<"fail to get object at index: "<<index_<<" in collection: "<<src_;
       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));
     }
   }