#include <MVAVariableManager.h>

Classes
struct	MVAVariableInfo

Public Member Functions
const std::string &	getName (int index) const

int	getNVars () const

float	getValue (int index, const edm::Ptr< ParticleType > &ptclPtr, const edm::EventBase &iEvent) const

float	getValue (int index, const edm::Ptr< ParticleType > &ptclPtr, const edm::Event &iEvent) const

int	getVarIndex (const std::string &name)

int	init (const std::string &variableDefinitionFileName)

	MVAVariableManager ()

	MVAVariableManager (const std::string &variableDefinitionFileName)

void	setConsumes (edm::ConsumesCollector &&cc)

Private Member Functions
void	addVariable (const std::string &name, const std::string &formula, const std::string &lowerClip, const std::string &upperClip)

Private Attributes
std::vector< std::string >	formulas_

std::vector< StringObjectFunction< ParticleType > >	functions_

std::vector< edm::InputTag >	globalInputTags_

std::vector< edm::EDGetToken >	globalTokens_

std::vector< edm::InputTag >	helperInputTags_

std::vector< edm::EDGetToken >	helperTokens_

std::map< std::string, int >	indexMap_

std::vector< std::string >	names_

int	nGlobalVars_

int	nHelperVars_

int	nVars_

std::vector< MVAVariableInfo >	variableInfos_

Detailed Description

template<class ParticleType>
class MVAVariableManager< ParticleType >

Definition at line 15 of file MVAVariableManager.h.

Constructor & Destructor Documentation

template<class ParticleType>

MVAVariableManager< ParticleType >::MVAVariableManager ( )

inline

Definition at line 18 of file MVAVariableManager.h.

       : nVars_ (0)
       , nHelperVars_ (0)
       , nGlobalVars_ (0)
     {
     };

template<class ParticleType>

MVAVariableManager< ParticleType >::MVAVariableManager ( const std::string & variableDefinitionFileName )

inline

Definition at line 25 of file MVAVariableManager.h.

                                                                     {
         init(variableDefinitionFileName);
     };

Member Function Documentation

template<class ParticleType>

void MVAVariableManager< ParticleType >::addVariable	(	const std::string &	name,
		const std::string &	formula,
		const std::string &	lowerClip,
		const std::string &	upperClip
	)

inlineprivate

Definition at line 152 of file MVAVariableManager.h.

Referenced by MVAVariableManager< reco::GsfElectron >::init().

     {
         bool hasLowerClip = lowerClip.find("None") == std::string::npos;
         bool hasUpperClip = upperClip.find("None") == std::string::npos;
         int fromVariableHelper = formula.find("MVAVariableHelper") != std::string::npos ||
                                  formula.find("IDValueMapProducer") != std::string::npos ||
                                  formula.find("egmPhotonIsolation") != std::string::npos;
         float lowerClipValue = hasLowerClip ? (float)::atof(lowerClip.c_str()) : 0.;
         float upperClipValue = hasUpperClip ? (float)::atof(upperClip.c_str()) : 0.;
 
         // *Rho* is the only global variable used ever, so its hardcoded...
         int isGlobalVariable = formula.find("Rho") != std::string::npos;
 
         if ( !(fromVariableHelper || isGlobalVariable) ) {
             functions_.push_back(StringObjectFunction<ParticleType>(formula));
         } else {
             // Push back a dummy function since we won't use the
             // StringObjectFunction to evaluate a variable form the helper or a
             // global variable
             functions_.push_back(StringObjectFunction<ParticleType>("pt"));
         }
 
         formulas_.push_back(formula);
         if (fromVariableHelper) {
             helperInputTags_.push_back(edm::InputTag(formula));
         }
         if (isGlobalVariable) {
             globalInputTags_.push_back(edm::InputTag(formula));
         }
 
         // Switch from bool to int, corresponding to the token index
         fromVariableHelper = fromVariableHelper ? nHelperVars_++ : -1;
         isGlobalVariable   = isGlobalVariable ? nGlobalVars_++ : - 1;
 
         MVAVariableInfo varInfo = {
             .hasLowerClip       = hasLowerClip,
             .hasUpperClip       = hasUpperClip,
             .lowerClipValue     = lowerClipValue,
             .upperClipValue     = upperClipValue,
             .fromVariableHelper = fromVariableHelper,
             .isGlobalVariable   = isGlobalVariable
         };
         variableInfos_.push_back(varInfo);
         names_.push_back(name);
         indexMap_[name] = nVars_;
         nVars_++;
     };

template<class ParticleType>

const std::string& MVAVariableManager< ParticleType >::getName ( int index ) const

inline

Definition at line 74 of file MVAVariableManager.h.

Referenced by plotting.Plot::draw(), ElectronMVANtuplizer::ElectronMVANtuplizer(), PhotonMVAEstimator::mvaValue(), and ElectronMVAEstimatorRun2::mvaValue().

                                               {
         return names_[index];
     }

template<class ParticleType>

int MVAVariableManager< ParticleType >::getNVars ( ) const

inline

Definition at line 78 of file MVAVariableManager.h.

Referenced by ElectronMVANtuplizer::ElectronMVANtuplizer().

                          {
         return nVars_;
     }

template<class ParticleType>

float MVAVariableManager< ParticleType >::getValue	(	int	index,
		const edm::Ptr< ParticleType > &	ptclPtr,
		const edm::EventBase &	iEvent
	)		const

inline

Definition at line 83 of file MVAVariableManager.h.

Referenced by ElectronMVANtuplizer::analyze(), PhotonMVAEstimator::mvaValue(), and ElectronMVAEstimatorRun2::mvaValue().

                                                                                                      {
         float value;
         MVAVariableInfo varInfo = variableInfos_[index];
         if (varInfo.fromVariableHelper >= 0) {
             edm::Handle<edm::ValueMap<float>> vMap;
             iEvent.getByLabel(edm::InputTag(formulas_[index]), vMap);
             value = (*vMap)[ptclPtr];
         } else if (varInfo.isGlobalVariable >= 0) {
             edm::Handle<double> valueHandle;
             iEvent.getByLabel(edm::InputTag(formulas_[index]), valueHandle);
             value = *valueHandle;
         } else {
             value = functions_[index](*ptclPtr);
         }
         if (varInfo.hasLowerClip && value < varInfo.lowerClipValue) {
             value = varInfo.lowerClipValue;
         }
         if (varInfo.hasUpperClip && value > varInfo.upperClipValue) {
             value = varInfo.upperClipValue;
         }
         return value;
     }

template<class ParticleType>

float MVAVariableManager< ParticleType >::getValue	(	int	index,
		const edm::Ptr< ParticleType > &	ptclPtr,
		const edm::Event &	iEvent
	)		const

inline

Definition at line 107 of file MVAVariableManager.h.

                                                                                                  {
         float value;
         MVAVariableInfo varInfo = variableInfos_[index];
         if (varInfo.fromVariableHelper >= 0) {
             edm::Handle<edm::ValueMap<float>> vMap;
             iEvent.getByToken(helperTokens_[varInfo.fromVariableHelper], vMap);
             value = (*vMap)[ptclPtr];
         } else if (varInfo.isGlobalVariable >= 0) {
             edm::Handle<double> valueHandle;
             iEvent.getByToken(globalTokens_[varInfo.isGlobalVariable], valueHandle);
             value = *valueHandle;
         } else {
             value = functions_[index](*ptclPtr);
         }
         if (varInfo.hasLowerClip && value < varInfo.lowerClipValue) {
             value = varInfo.lowerClipValue;
         }
         if (varInfo.hasUpperClip && value > varInfo.upperClipValue) {
             value = varInfo.upperClipValue;
         }
         return value;
     }

template<class ParticleType>

int MVAVariableManager< ParticleType >::getVarIndex ( const std::string & name )

inline

Definition at line 64 of file MVAVariableManager.h.

Referenced by ElectronMVAEstimatorRun2::init(), and PhotonMVAEstimator::PhotonMVAEstimator().

     {
         std::map<std::string,int>::iterator it = indexMap_.find(name);
         if (it == indexMap_.end()) {
             return -1;
         } else {
             return it->second;
         }
     }

template<class ParticleType>

int MVAVariableManager< ParticleType >::init ( const std::string & variableDefinitionFileName )

inline

Definition at line 29 of file MVAVariableManager.h.

Referenced by MVAVariableManager< reco::GsfElectron >::MVAVariableManager().

     {
         nVars_ = 0;
         nHelperVars_ = 0;
         nGlobalVars_ = 0;
 
         variableInfos_.clear();
         functions_.clear();
         formulas_.clear();
         names_.clear();
         helperInputTags_.clear();
         globalInputTags_.clear();
 
         edm::FileInPath variableDefinitionFileEdm(variableDefinitionFileName);
         std::ifstream file(variableDefinitionFileEdm.fullPath());
 
         std::string name, formula, upper, lower;
         while( true ) {
             file >> name;
             if(file.eof()) {
                 break;
             }
             if (name.find("#") != std::string::npos) {
                 file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                 continue;
             }
             file >> formula >> lower >> upper;
             if (file.eof()) {
                 break;
             }
             addVariable(name, formula, lower, upper);
         }
         return nVars_;
     };

template<class ParticleType>

void MVAVariableManager< ParticleType >::setConsumes ( edm::ConsumesCollector && cc )

inline

Definition at line 130 of file MVAVariableManager.h.

Referenced by ElectronMVANtuplizer::ElectronMVANtuplizer(), PhotonMVAEstimator::setConsumes(), and ElectronMVAEstimatorRun2::setConsumes().

                                                 {
       // All tokens for event content needed by the MVA
       // Tags from the variable helper
       for (auto &tag : helperInputTags_) {
           helperTokens_.push_back(cc.consumes<edm::ValueMap<float>>(tag));
       }
       for (auto &tag : globalInputTags_) {
           globalTokens_.push_back(cc.consumes<double>(tag));
       }
     }