#include <ElectronMVAEstimatorRun2Fall17.h>

Inheritance diagram for ElectronMVAEstimatorRun2Fall17:

Classes
struct	Clip

Public Member Functions
void	constrainMVAVariables (std::vector< float > &) const

	ElectronMVAEstimatorRun2Fall17 (const edm::ParameterSet &conf, bool withIso)

	ElectronMVAEstimatorRun2Fall17 (const std::string &mvaTag, const std::string &mvaName, bool withIso, const std::string &conversionsTag="reducedEgamma:reducedConversions", const std::string &beamspotTag="offlineBeamSpot", const double ptSplit=10., const double ebSplit=0.800, const double ebeeSplit=1.479, const bool debug=false)

std::vector< float >	fillMVAVariables (const edm::Ptr< reco::Candidate > &particle, const edm::Event &) const override

std::vector< float >	fillMVAVariables (const reco::GsfElectron particle, const edm::Handle< reco::ConversionCollection > conversions, const reco::BeamSpot beamSpot, const edm::Handle< double > rho) const

int	findCategory (const edm::Ptr< reco::Candidate > &particle) const override

int	findCategory (const reco::GsfElectron *particle) const

const std::string &	getName () const final

int	getNCategories () const override

const std::string &	getTag () const final

void	init (const std::vector< std::string > &weightFileNames)

float	mvaValue (const edm::Ptr< reco::Candidate > &particle, const edm::Event &) const override

float	mvaValue (const reco::GsfElectron *particle, const edm::EventBase &) const

float	mvaValue (const int iCategory, const std::vector< float > &vars) const

void	setClips (const std::vector< double > &clipsLowerValues, const std::vector< double > &clipsUpperValues)

void	setConsumes (edm::ConsumesCollector &&) const final

	~ElectronMVAEstimatorRun2Fall17 () override

Public Member Functions inherited from AnyMVAEstimatorRun2Base
	AnyMVAEstimatorRun2Base (const edm::ParameterSet &conf)

virtual void	getEventContent (const edm::Event &iEvent) const final

template<typename... Args>
std::vector< float >	packMVAVariables (const Args...args) const

virtual	~AnyMVAEstimatorRun2Base ()

Protected Types
enum	MVACategories_ { UNDEFINED = -1, CAT_EB1_PTLow = 0, CAT_EB2_PTLow = 1, CAT_EE_PTLow = 2, CAT_EB1_PTHig = 3, CAT_EB2_PTHig = 4, CAT_EE_PTHig = 5 }

Protected Attributes
const edm::InputTag	beamSpotLabel_

std::vector< Clip >	clipsLower_

std::vector< Clip >	clipsUpper_

const edm::InputTag	conversionsLabelAOD_

const edm::InputTag	conversionsLabelMiniAOD_

bool	debug_

double	ebeeSplit_

double	ebSplit_

std::vector< std::unique_ptr< const GBRForest > >	gbrForests_

const std::string	methodName_

const std::string	name_

const int	nCategories_ = 6

const int	nVar_ = 22

double	ptSplit_

const edm::InputTag	rhoLabel_

const std::string	tag_

std::vector< std::string >	varNames_

bool	withIso_

Additional Inherited Members
Public Attributes inherited from AnyMVAEstimatorRun2Base
const edm::ParameterSet	_conf

Detailed Description

Definition at line 18 of file ElectronMVAEstimatorRun2Fall17.h.

Member Enumeration Documentation

enum ElectronMVAEstimatorRun2Fall17::MVACategories_

protected

Enumerator
UNDEFINED
CAT_EB1_PTLow
CAT_EB2_PTLow
CAT_EE_PTLow
CAT_EB1_PTHig
CAT_EB2_PTHig
CAT_EE_PTHig

Definition at line 78 of file ElectronMVAEstimatorRun2Fall17.h.

                       {
     UNDEFINED = -1,
     CAT_EB1_PTLow = 0,
     CAT_EB2_PTLow = 1,
     CAT_EE_PTLow  = 2,
     CAT_EB1_PTHig = 3,
     CAT_EB2_PTHig = 4,
     CAT_EE_PTHig  = 5
   };

Constructor & Destructor Documentation

ElectronMVAEstimatorRun2Fall17::ElectronMVAEstimatorRun2Fall17	(	const edm::ParameterSet &	conf,
		bool	withIso
	)

Definition at line 3 of file ElectronMVAEstimatorRun2Fall17.cc.

References debug_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), init(), setClips(), mvaElectronID_Fall17_iso_V1_cff::weightFileNames, and withIso_.

                                                                                                        :
   AnyMVAEstimatorRun2Base(conf),
   tag_(conf.getParameter<std::string>("mvaTag")),
   name_(conf.getParameter<std::string>("mvaName")),
   methodName_("BDTG method"),
   beamSpotLabel_          (conf.getParameter<edm::InputTag>           ("beamSpot")),
   conversionsLabelAOD_    (conf.getParameter<edm::InputTag>           ("conversionsAOD")),
   conversionsLabelMiniAOD_(conf.getParameter<edm::InputTag>           ("conversionsMiniAOD")),
   rhoLabel_               (edm::InputTag                              ("fixedGridRhoFastjetAll")),
   ptSplit_                (conf.getParameter<double>                  ("ptSplit")),
   ebSplit_                (conf.getParameter<double>                  ("ebSplit")),
   ebeeSplit_              (conf.getParameter<double>                  ("ebeeSplit")),
   varNames_               (conf.getParameter<std::vector<std::string>>("varNames"))
 {
 
   const std::vector <std::string> weightFileNames
     = conf.getParameter<std::vector<std::string> >("weightFileNames");
 
   std::vector<double> clipsLowerValues = conf.getParameter<std::vector<double>>("clipLower");
   std::vector<double> clipsUpperValues = conf.getParameter<std::vector<double>>("clipUpper");
 
   // Initialize GBRForests and and clipping instructions
   init(weightFileNames);
   setClips(clipsLowerValues, clipsUpperValues);
 
   withIso_ = withIso;
   debug_ = conf.getUntrackedParameter<bool>("debug", false);
 
 }

ElectronMVAEstimatorRun2Fall17::~ElectronMVAEstimatorRun2Fall17 ( )

override

Definition at line 102 of file ElectronMVAEstimatorRun2Fall17.cc.

Referenced by setClips().

102 {

103 }

ElectronMVAEstimatorRun2Fall17::ElectronMVAEstimatorRun2Fall17	(	const std::string &	mvaTag,
		const std::string &	mvaName,
		bool	withIso,
		const std::string &	conversionsTag = `"reducedEgamma:reducedConversions"`,
		const std::string &	beamspotTag = `"offlineBeamSpot"`,
		const double	ptSplit = `10.`,
		const double	ebSplit = `0.800`,
		const double	ebeeSplit = `1.479`,
		const bool	debug = `false`
	)

Definition at line 33 of file ElectronMVAEstimatorRun2Fall17.cc.

References debug, debug_, and withIso_.

                                                                                              :
   AnyMVAEstimatorRun2Base( edm::ParameterSet() ),
   tag_                    (mvaTag),
   name_                   (mvaName),
   methodName_             ("BDTG method"),
   beamSpotLabel_          (edm::InputTag(beamspotTag)),
   conversionsLabelAOD_    (edm::InputTag(conversionsTag)),
   conversionsLabelMiniAOD_(conversionsLabelAOD_),
   rhoLabel_               (edm::InputTag("fixedGridRhoFastjetAll")),
   ptSplit_                (ptSplit),
   ebSplit_                (ebSplit),
   ebeeSplit_              (ebeeSplit)
 {
 
   // Set if this is the ID with or without PF isolations
   withIso_ = withIso;
 
   // Set debug flag
   debug_ = debug;
 
 }

Member Function Documentation

void ElectronMVAEstimatorRun2Fall17::constrainMVAVariables ( std::vector< float > & vars ) const

Definition at line 456 of file ElectronMVAEstimatorRun2Fall17.cc.

References clip(), clipsLower_, and clipsUpper_.

Referenced by fillMVAVariables(), and getTag().

                                                                                        {
 
   // Check that variables do not have crazy values
 
   for(auto const& clip: clipsLower_) {
       if ( vars[clip.varIdx] < clip.value  ) {
           vars[clip.varIdx] =   clip.value;
       }
   }
 
   for(auto const& clip: clipsUpper_) {
       if ( vars[clip.varIdx] > clip.value  ) {
           vars[clip.varIdx] =   clip.value;
       }
   }
 
 }

std::vector< float > ElectronMVAEstimatorRun2Fall17::fillMVAVariables	(	const edm::Ptr< reco::Candidate > &	particle,
		const edm::Event &	iEvent
	)		const

overridevirtual

Implements AnyMVAEstimatorRun2Base.

Definition at line 252 of file ElectronMVAEstimatorRun2Fall17.cc.

References beamSpotLabel_, conversions_cfi::conversions, conversionsLabelAOD_, conversionsLabelMiniAOD_, Exception, edm::Ptr< T >::get(), edm::Event::getByLabel(), edm::HandleBase::isValid(), nullptr, edm::Handle< T >::product(), and rhoLabel_.

Referenced by findCategory(), getTag(), and mvaValue().

                                                                                       {
 
   //
   // Declare all value maps corresponding to the products we defined earlier
   //
   edm::Handle<double> theRho;
   edm::Handle<reco::BeamSpot> theBeamSpot;
   edm::Handle<reco::ConversionCollection> conversions;
 
   iEvent.getByLabel(rhoLabel_, theRho);
 
   // Get data needed for conversion rejection
   iEvent.getByLabel(beamSpotLabel_, theBeamSpot);
 
   // Conversions in miniAOD and AOD have different names,
   // but the same type, so we use the same handle with different tokens.
   iEvent.getByLabel(conversionsLabelAOD_, conversions);
   if( !conversions.isValid() ) {
     iEvent.getByLabel(conversionsLabelMiniAOD_, conversions);
   }
 
   // Make sure everything is retrieved successfully
   if(! (theBeamSpot.isValid()
     && conversions.isValid() )
      ) {
     throw cms::Exception("MVA failure: ")
       << "Failed to retrieve event content needed for this MVA"
       << std::endl
       << "Check python MVA configuration file."
       << std::endl;
   }
 
   // Try to cast the particle into a reco particle.
   // This should work for both reco and pat.
   const edm::Ptr<reco::GsfElectron> eleRecoPtr = ( edm::Ptr<reco::GsfElectron> )particle;
   if( eleRecoPtr.get() == nullptr ) {
     throw cms::Exception("MVA failure: ")
       << " given particle is expected to be reco::GsfElectron or pat::Electron," << std::endl
       << " but appears to be neither" << std::endl;
   }
 
   return fillMVAVariables(eleRecoPtr.get(), conversions, theBeamSpot.product(), theRho);
 }

std::vector< float > ElectronMVAEstimatorRun2Fall17::fillMVAVariables	(	const reco::GsfElectron *	particle,
		const edm::Handle< reco::ConversionCollection >	conversions,
		const reco::BeamSpot *	beamSpot,
		const edm::Handle< double >	rho
	)		const

Definition at line 298 of file ElectronMVAEstimatorRun2Fall17.cc.

                                                                                                                                                                                {
 
 
   // Both pat and reco particles have exactly the same accessors, so we use a reco ptr
   // throughout the code, with a single exception as of this writing, handled separately below.
   auto superCluster = eleRecoPtr->superCluster();
 
   // Pure ECAL -> shower shapes
   float see            = eleRecoPtr->full5x5_sigmaIetaIeta();
   float spp            = eleRecoPtr->full5x5_sigmaIphiIphi();
   float circularity = 1. - eleRecoPtr->full5x5_e1x5() / eleRecoPtr->full5x5_e5x5();
   float r9             = eleRecoPtr->full5x5_r9();
   float etawidth       = superCluster->etaWidth();
   float phiwidth       = superCluster->phiWidth();
   float hoe            = eleRecoPtr->full5x5_hcalOverEcal(); //hadronicOverEm();
   // Endcap only variables
   float preShowerOverRaw  = superCluster->preshowerEnergy() / superCluster->rawEnergy();
 
   // To get to CTF track information in pat::Electron, we have to have the pointer
   // to pat::Electron, it is not accessible from the pointer to reco::GsfElectron.
   // This behavior is reported and is expected to change in the future (post-7.4.5 some time).
   bool validKF= false;
   reco::TrackRef myTrackRef = eleRecoPtr->closestCtfTrackRef();
   const pat::Electron * elePatPtr = dynamic_cast<const pat::Electron *>(eleRecoPtr);
   // Check if this is really a pat::Electron, and if yes, get the track ref from this new
   // pointer instead
   if( elePatPtr != nullptr ) {
     myTrackRef = elePatPtr->closestCtfTrackRef();
   }
   validKF = (myTrackRef.isAvailable() && (myTrackRef.isNonnull()) );
 
   //Pure tracking variables
   float kfhits         = (validKF) ? myTrackRef->hitPattern().trackerLayersWithMeasurement() : -1. ;
   float kfchi2          = (validKF) ? myTrackRef->normalizedChi2() : 0;
   float gsfchi2         = eleRecoPtr->gsfTrack()->normalizedChi2();
 
   // Energy matching
   float fbrem           = eleRecoPtr->fbrem();
 
   float gsfhits         = eleRecoPtr->gsfTrack()->hitPattern().trackerLayersWithMeasurement();
   float expectedMissingInnerHits = eleRecoPtr->gsfTrack()
     ->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
 
   reco::ConversionRef convRef = ConversionTools::matchedConversion(*eleRecoPtr,
                                     conversions,
                                     theBeamSpot->position());
   float convVtxFitProbability = -1.;
   if(!convRef.isNull()) {
     const reco::Vertex &vtx = convRef.get()->conversionVertex();
     if (vtx.isValid()) {
       convVtxFitProbability = (float)TMath::Prob( vtx.chi2(), vtx.ndof());
     }
   }
 
   float eop             = eleRecoPtr->eSuperClusterOverP();
   float eleeopout       = eleRecoPtr->eEleClusterOverPout();
   float pAtVertex            = eleRecoPtr->trackMomentumAtVtx().R();
   float oneOverEminusOneOverP         = (1.0/eleRecoPtr->ecalEnergy()) - (1.0 / pAtVertex );
 
   // Geometrical matchings
   float deta            = eleRecoPtr->deltaEtaSuperClusterTrackAtVtx();
   float dphi            = eleRecoPtr->deltaPhiSuperClusterTrackAtVtx();
   float detacalo        = eleRecoPtr->deltaEtaSeedClusterTrackAtCalo();
 
   if(withIso_)
   {
 
     // Isolation variables
     float pfChargedHadIso   = (eleRecoPtr->pfIsolationVariables()).sumChargedHadronPt ; //chargedHadronIso();
     float pfNeutralHadIso   = (eleRecoPtr->pfIsolationVariables()).sumNeutralHadronEt ; //neutralHadronIso();
     float pfPhotonIso       = (eleRecoPtr->pfIsolationVariables()).sumPhotonEt; //photonIso();
 
     /*
      * Packing variables for the MVA evaluation.
      * CAREFUL: It is critical that all the variables that are packed into “vars” are
      * exactly in the order they are found in the weight files
      */
     std::vector<float> vars = packMVAVariables(
                                   see,                      // 0
                                   spp,                      // 1
                                   circularity,
                                   r9,
                                   etawidth,
                                   phiwidth,                 // 5
                                   hoe,
                                   //Pure tracking variables
                                   kfhits,
                                   kfchi2,
                                   gsfchi2,                  // 9
                                   // Energy matching
                                   fbrem,
                                   gsfhits,
                                   expectedMissingInnerHits,
                                   convVtxFitProbability,     // 13
                                   eop,
                                   eleeopout,                // 15
                                   oneOverEminusOneOverP,
                                   // Geometrical matchings
                                   deta,                     // 17
                                   dphi,
                                   detacalo,
                                   // Isolation variables
                                   pfPhotonIso,
                                   pfChargedHadIso,
                                   pfNeutralHadIso,
                                   // Pileup
                                   (float)*rho,
 
                                   // Endcap only variables NOTE: we don't need
                                   // to check if we are actually in the endcap
                                   // or not, as it is the last variable in the
                                   // vector and it will be ignored by the
                                   // GBRForest for the barrel.
                                   //
                                   // The GBRForest classification just needs an
                                   // array with the input variables in the
                                   // right order, what comes after doesn't
                                   // matter.
                                   preShowerOverRaw          // 24
                               );
 
     constrainMVAVariables(vars);
 
     return vars;
   }
   else
   {
     std::vector<float> vars = packMVAVariables(
                                   see,                      // 0
                                   spp,                      // 1
                                   circularity,
                                   r9,
                                   etawidth,
                                   phiwidth,                 // 5
                                   hoe,
                                   kfhits,
                                   kfchi2,
                                   gsfchi2,                  // 9
                                   fbrem,
                                   gsfhits,
                                   expectedMissingInnerHits,
                                   convVtxFitProbability,     // 13
                                   eop,
                                   eleeopout,                // 15
                                   oneOverEminusOneOverP,
                                   deta,                     // 17
                                   dphi,
                                   detacalo,
                                   (float)*rho,
                                   preShowerOverRaw          // 21
                               );
 
     constrainMVAVariables(vars);
 
     return vars;
   }
 }

int ElectronMVAEstimatorRun2Fall17::findCategory ( const edm::Ptr< reco::Candidate > & particle ) const

overridevirtual

Implements AnyMVAEstimatorRun2Base.

Definition at line 200 of file ElectronMVAEstimatorRun2Fall17.cc.

References Exception, edm::Ptr< T >::get(), and nullptr.

Referenced by getTag(), and mvaValue().

                                                                                              {
 
   // Try to cast the particle into a reco particle.
   // This should work for both reco and pat.
   const edm::Ptr<reco::GsfElectron> eleRecoPtr = ( edm::Ptr<reco::GsfElectron> )particle;
   if( eleRecoPtr.get() == nullptr ) {
     throw cms::Exception("MVA failure: ")
       << " given particle is expected to be reco::GsfElectron or pat::Electron," << std::endl
       << " but appears to be neither" << std::endl;
   }
   return findCategory(eleRecoPtr.get());
 }

int ElectronMVAEstimatorRun2Fall17::findCategory ( const reco::GsfElectron * particle ) const

Definition at line 213 of file ElectronMVAEstimatorRun2Fall17.cc.

References funct::abs(), CAT_EB1_PTHig, CAT_EB1_PTLow, CAT_EB2_PTHig, CAT_EB2_PTLow, CAT_EE_PTHig, CAT_EE_PTLow, ebeeSplit_, ebSplit_, PVValHelper::eta, fillMVAVariables(), EnergyCorrector::pt, reco::LeafCandidate::pt(), ptSplit_, reco::GsfElectron::superCluster(), and UNDEFINED.

                                                                                            {
   float pt = eleRecoPtr->pt();
   float eta = eleRecoPtr->superCluster()->eta();
   float absEta = std::abs(eta);
 
   //
   // Determine the category
   //
   int  iCategory = UNDEFINED;
 
   if (pt < ptSplit_ && absEta < ebSplit_) {
     iCategory = CAT_EB1_PTLow;
   }
 
   else if (pt < ptSplit_ && absEta >= ebSplit_ && absEta < ebeeSplit_) {
     iCategory = CAT_EB2_PTLow;
   }
 
   else if (pt < ptSplit_ && absEta >= ebeeSplit_) {
     iCategory = CAT_EE_PTLow;
   }
 
   else if (pt >= ptSplit_ && absEta < ebSplit_) {
     iCategory = CAT_EB1_PTHig;
   }
 
   else if (pt >= ptSplit_ && absEta >= ebSplit_ && absEta < ebeeSplit_) {
     iCategory = CAT_EB2_PTHig;
   }
 
   else if (pt >= ptSplit_ && absEta >= ebeeSplit_) {
     iCategory = CAT_EE_PTHig;
   }
 
   return iCategory;
 }

const std::string& ElectronMVAEstimatorRun2Fall17::getName ( void ) const

inlinefinalvirtual

Implements AnyMVAEstimatorRun2Base.

Definition at line 48 of file ElectronMVAEstimatorRun2Fall17.h.

References name_.

Referenced by plotting.Plot::draw().

48 { return name_; }

ElectronMVAEstimatorRun2Fall17::name_

const std::string name_

Definition: ElectronMVAEstimatorRun2Fall17.h:97

int ElectronMVAEstimatorRun2Fall17::getNCategories ( ) const

inlineoverridevirtual

Implements AnyMVAEstimatorRun2Base.

Definition at line 47 of file ElectronMVAEstimatorRun2Fall17.h.

References nCategories_.

47 { return nCategories_; }

ElectronMVAEstimatorRun2Fall17::nCategories_

const int nCategories_

Definition: ElectronMVAEstimatorRun2Fall17.h:76

const std::string& ElectronMVAEstimatorRun2Fall17::getTag ( ) const

inlinefinalvirtual

Implements AnyMVAEstimatorRun2Base.

Definition at line 49 of file ElectronMVAEstimatorRun2Fall17.h.

References ecalDrivenElectronSeedsParameters_cff::beamSpot, constrainMVAVariables(), conversions_cfi::conversions, fillMVAVariables(), findCategory(), rho, setConsumes(), and tag_.

49 { return tag_; }

ElectronMVAEstimatorRun2Fall17::tag_

const std::string tag_

Definition: ElectronMVAEstimatorRun2Fall17.h:91

void ElectronMVAEstimatorRun2Fall17::init ( const std::vector< std::string > & weightFileNames )

Definition at line 57 of file ElectronMVAEstimatorRun2Fall17.cc.

References GBRForestTools::createGBRForest(), Exception, gbrForests_, mps_fire::i, nCategories_, and electrons_cff::weightFile.

Referenced by ElectronMVAEstimatorRun2Fall17().

                                                                                      {
 
   // Initialize GBRForests
   if( (int)(weightFileNames.size()) != nCategories_ )
     throw cms::Exception("MVA config failure: ")
       << "wrong number of weightfiles" << std::endl;
 
   gbrForests_.clear();
   // Create a TMVA reader object for each category
   for(int i=0; i<nCategories_; i++){
 
     // Use unique_ptr so that all readers are properly cleaned up
     // when the vector clear() is called in the destructor
 
     edm::FileInPath weightFile( weightFileNames[i] );
     gbrForests_.push_back( GBRForestTools::createGBRForest( weightFile ) );
 
   }
 
 }

float ElectronMVAEstimatorRun2Fall17::mvaValue	(	const edm::Ptr< reco::Candidate > &	particle,
		const edm::Event &	iEvent
	)		const

overridevirtual

Implements AnyMVAEstimatorRun2Base.

Definition at line 128 of file ElectronMVAEstimatorRun2Fall17.cc.

References Exception, fillMVAVariables(), findCategory(), edm::Ptr< T >::get(), and nullptr.

Referenced by mvaValue(), and setConsumes().

                                                                                {
   // Try to cast the particle into a reco particle.
   // This should work for both reco and pat.
   const edm::Ptr<reco::GsfElectron> eleRecoPtr = ( edm::Ptr<reco::GsfElectron> )particle;
   if( eleRecoPtr.get() == nullptr ) {
     throw cms::Exception("MVA failure: ")
       << " given particle is expected to be reco::GsfElectron or pat::Electron," << std::endl
       << " but appears to be neither" << std::endl;
   }
 
   const int iCategory = findCategory( eleRecoPtr.get() );
   const std::vector<float> vars = fillMVAVariables( particle, iEvent );
   return mvaValue(iCategory, vars);
 }

float ElectronMVAEstimatorRun2Fall17::mvaValue	(	const reco::GsfElectron *	particle,
		const edm::EventBase &	iEvent
	)		const

Definition at line 144 of file ElectronMVAEstimatorRun2Fall17.cc.

References ecalDrivenElectronSeedsParameters_cff::beamSpot, beamSpotLabel_, conversions_cfi::conversions, conversionsLabelAOD_, fillMVAVariables(), findCategory(), edm::EventBase::getByLabel(), mvaValue(), edm::Handle< T >::product(), rho, and rhoLabel_.

                                                                                {
   edm::Handle<reco::ConversionCollection> conversions;
   edm::Handle<reco::BeamSpot> beamSpot;
   edm::Handle<double> rho;
   iEvent.getByLabel(conversionsLabelAOD_, conversions);
   iEvent.getByLabel(beamSpotLabel_, beamSpot);
   iEvent.getByLabel(rhoLabel_, rho);
   const int iCategory = findCategory( particle );
   const std::vector<float> vars = fillMVAVariables( particle, conversions, beamSpot.product(), rho );
   return mvaValue(iCategory, vars);
 }

float ElectronMVAEstimatorRun2Fall17::mvaValue	(	const int	iCategory,
		const std::vector< float > &	vars
	)		const

Definition at line 157 of file ElectronMVAEstimatorRun2Fall17.cc.

References gather_cfg::cout, debug_, gbrForests_, methodName_, mps_fire::result, and withIso_.

                                                                      {
   const float result = gbrForests_.at(iCategory)->GetClassifier(vars.data());
 
   if(debug_) {
     std::cout << " *** Inside the class methodName_ " << methodName_ << std::endl;
     std::cout << " bin "                      << iCategory << std::endl
               << " see "                      << vars[0] << std::endl
               << " spp "                      << vars[1] << std::endl
               << " circularity "              << vars[2] << std::endl
               << " r9 "                       << vars[3] << std::endl
               << " etawidth "                 << vars[4] << std::endl
               << " phiwidth "                 << vars[5] << std::endl
               << " hoe "                      << vars[6] << std::endl
               << " kfhits "                   << vars[7] << std::endl
               << " kfchi2 "                   << vars[8] << std::endl
               << " gsfchi2 "                  << vars[9] << std::endl
               << " fbrem "                    << vars[10] << std::endl
               << " gsfhits "                  << vars[11] << std::endl
               << " expectedMissingInnerHits " << vars[12] << std::endl
               << " convVtxFitProbability "    << vars[13] << std::endl
               << " eop "                      << vars[14] << std::endl
               << " eleeopout "                << vars[15] << std::endl
               << " oneOverEminusOneOverP "    << vars[16] << std::endl
               << " deta "                     << vars[17] << std::endl
               << " dphi "                     << vars[18] << std::endl
               << " detacalo "                 << vars[19] << std::endl;
     if (withIso_) {
       std::cout << " ele_pfPhotonIso "          << vars[20] << std::endl
                 << " ele_pfChargedHadIso "      << vars[21] << std::endl
                 << " ele_pfNeutralHadIso "      << vars[22] << std::endl
                 << " rho "                      << vars[23] << std::endl
                 << " preShowerOverRaw "         << vars[24] << std::endl;
     }
     else {
       std::cout << " rho "                      << vars[20] << std::endl
                 << " preShowerOverRaw "         << vars[21] << std::endl;
     }
     std::cout << " ### MVA " << result << std::endl << std::endl;
   }
 
   return result;
 }

void ElectronMVAEstimatorRun2Fall17::setClips	(	const std::vector< double > &	clipsLowerValues,
		const std::vector< double > &	clipsUpperValues
	)

Definition at line 78 of file ElectronMVAEstimatorRun2Fall17.cc.

References clip(), clipsLower_, clipsUpper_, objects.autophobj::float, mps_fire::i, edm::isFinite(), and ~ElectronMVAEstimatorRun2Fall17().

Referenced by ElectronMVAEstimatorRun2Fall17().

                                                                                                                                   {
 
   // Set up the variable clipping intructions
   unsigned int i = 0;
   for(auto const& value: clipsLowerValues) {
       if (edm::isFinite(value)) {
           Clip clip = {i, false, (float)value};
           clipsLower_.push_back(clip);
       }
       ++i;
   }
 
   i = 0;
   for(auto const& value: clipsUpperValues) {
       if (edm::isFinite(value)) {
           Clip clip = {i, true, (float)value};
           clipsUpper_.push_back(clip);
       }
       ++i;
   }
 
 }

void ElectronMVAEstimatorRun2Fall17::setConsumes ( edm::ConsumesCollector && cc ) const

finalvirtual

Reimplemented from AnyMVAEstimatorRun2Base.

Definition at line 105 of file ElectronMVAEstimatorRun2Fall17.cc.

References beamSpotLabel_, conversionsLabelAOD_, conversionsLabelMiniAOD_, mvaValue(), and rhoLabel_.

Referenced by getTag().

                                                                                 {
 
   // All tokens for event content needed by this MVA
 
   // Beam spot (same for AOD and miniAOD)
   cc.consumes<reco::BeamSpot>(beamSpotLabel_);
   // Conversions collection (different names in AOD and miniAOD)
   cc.mayConsume<reco::ConversionCollection>(conversionsLabelAOD_);
   cc.mayConsume<reco::ConversionCollection>(conversionsLabelMiniAOD_);
   // Event-by-event pileup estimate rho
   cc.consumes<double>(rhoLabel_);
 
   //beamSpotToken_           = cc.consumes<reco::BeamSpot>(beamSpotLabel_);
   //conversionsTokenAOD_     = cc.mayConsume<reco::ConversionCollection>(conversionsLabelAOD_);
   //conversionsTokenMiniAOD_ = cc.mayConsume<reco::ConversionCollection>(conversionsLabelMiniAOD_);
   //rhoToken_                = cc.consumes<double>(rhoLabel_);
 
 }