#include <EpCombinationTool.h>

Public Member Functions
void	combine (SimpleElectron &mySimpleElectron) const

std::pair< float, float >	combine (const reco::GsfElectron &electron) const

std::pair< float, float >	combine (const reco::GsfElectron &electron, float corrEcalEnergyErr) const

	EpCombinationTool ()

	EpCombinationTool (const EpCombinationTool &other)=delete

	EpCombinationTool (const edm::ParameterSet &iConfig)

bool	init (const GBRForest *forest)

bool	init (const std::string &regressionFile, const std::string &bdtName)

EpCombinationTool &	operator= (const EpCombinationTool &other)=delete

void	setEventContent (const edm::EventSetup &iSetup)

	~EpCombinationTool ()

	~EpCombinationTool ()

Static Public Member Functions
static edm::ParameterSetDescription	makePSetDescription ()

Private Attributes
EgammaRegressionContainer	ecalTrkEnergyRegress_

EgammaRegressionContainer	ecalTrkEnergyRegressUncert_

const GBRForest *	m_forest

bool	m_ownForest

float	maxEcalEnergyForComb_

float	maxEPDiffInSigmaForComb_

float	maxRelTrkMomErrForComb_

float	minEOverPForComb_

Detailed Description

Definition at line 10 of file EpCombinationTool.h.

Constructor & Destructor Documentation

EpCombinationTool::EpCombinationTool ( )

Definition at line 12 of file EpCombinationTool.cc.

     : m_forest(nullptr),
       m_ownForest(false)
 /*****************************************************************/
 {}

EpCombinationTool::~EpCombinationTool ( )

Definition at line 19 of file EpCombinationTool.cc.

References m_forest, and m_ownForest.

 {
   if (m_ownForest)
     delete m_forest;
 }

EpCombinationTool::EpCombinationTool ( const EpCombinationTool & other )

delete

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

Definition at line 14 of file EpCombinationTool.cc.

     : ecalTrkEnergyRegress_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionConfig")),
       ecalTrkEnergyRegressUncert_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionUncertConfig")),
       maxEcalEnergyForComb_(iConfig.getParameter<double>("maxEcalEnergyForComb")),
       minEOverPForComb_(iConfig.getParameter<double>("minEOverPForComb")),
       maxEPDiffInSigmaForComb_(iConfig.getParameter<double>("maxEPDiffInSigmaForComb")),
       maxRelTrkMomErrForComb_(iConfig.getParameter<double>("maxRelTrkMomErrForComb")) {}

EpCombinationTool::~EpCombinationTool ( )

inline

Definition at line 22 of file EpCombinationTool.h.

References funct::combine(), and metsig::electron.

22 {}

Member Function Documentation

void EpCombinationTool::combine ( SimpleElectron & mySimpleElectron ) const

Definition at line 58 of file EpCombinationTool.cc.

References gather_cfg::cout, HCALHighEnergyHPDFilter_cfi::energy, EgHLTOffHistBins_cfi::eOverP, GBRForest::GetResponse(), m_forest, mathSSE::sqrt(), and mps_merge::weight.

Referenced by EGEtScaleSysModifier::calCombinedMom(), ElectronEnergyCalibrator::calCombinedMom(), ElectronEnergyCalibratorRun2::calibrate(), and combine().

 {
   if (!m_forest) {
     cout << "ERROR: The combination tool is not initialized\n";
     return;
   }
 
   float energy = mySimpleElectron.getNewEnergy();
   float energyError = mySimpleElectron.getNewEnergyError();
   float momentum = mySimpleElectron.getTrackerMomentum();
   float momentumError = mySimpleElectron.getTrackerMomentumError();
   int electronClass = mySimpleElectron.getElClass();
   bool isEcalDriven = mySimpleElectron.isEcalDriven();
   bool isTrackerDriven = mySimpleElectron.isTrackerDriven();
   bool isEB = mySimpleElectron.isEB();
 
   // compute relative errors and ratio of errors
   float energyRelError = energyError / energy;
   float momentumRelError = momentumError / momentum;
   float errorRatio = energyRelError / momentumRelError;
 
   // calculate E/p and corresponding error
   float eOverP = energy / momentum;
   float eOverPerror =
       sqrt((energyError / momentum) * (energyError / momentum) +
            (energy * momentumError / momentum / momentum) * (energy * momentumError / momentum / momentum));
 
   // fill input variables
   float regressionInputs[11];
   regressionInputs[0] = energy;
   regressionInputs[1] = energyRelError;
   regressionInputs[2] = momentum;
   regressionInputs[3] = momentumRelError;
   regressionInputs[4] = errorRatio;
   regressionInputs[5] = eOverP;
   regressionInputs[6] = eOverPerror;
   regressionInputs[7] = static_cast<float>(isEcalDriven);
   regressionInputs[8] = static_cast<float>(isTrackerDriven);
   regressionInputs[9] = static_cast<float>(electronClass);
   regressionInputs[10] = static_cast<float>(isEB);
 
   // retrieve combination weight
   float weight = 0.;
   if (eOverP > 0.025 &&
       fabs(momentum - energy) < 15. * sqrt(momentumError * momentumError + energyError * energyError) &&
       ((momentumError < 10. * momentum) || (energy < 200.)))  // protection against crazy track measurement
   {
     weight = m_forest->GetResponse(regressionInputs);
     if (weight > 1.)
       weight = 1.;
     else if (weight < 0.)
       weight = 0.;
   }
 
   float combinedMomentum = weight * momentum + (1. - weight) * energy;
   float combinedMomentumError =
       sqrt(weight * weight * momentumError * momentumError + (1. - weight) * (1. - weight) * energyError * energyError);
 
   // FIXME : pure tracker electrons have track momentum error of 999.
   // If the combination try to combine such electrons then the original combined momentum is kept
   if (momentumError != 999. || weight == 0.) {
     mySimpleElectron.setCombinedMomentum(combinedMomentum);
     mySimpleElectron.setCombinedMomentumError(combinedMomentumError);
   }
 }

std::pair< float, float > EpCombinationTool::combine ( const reco::GsfElectron & electron ) const

Definition at line 39 of file EpCombinationTool.cc.

References combine(), and reco::GsfElectron::correctedEcalEnergyError().

                                                                                  {
   return combine(ele, ele.correctedEcalEnergyError());
 }

std::pair< float, float > EpCombinationTool::combine	(	const reco::GsfElectron &	electron,
		float	corrEcalEnergyErr
	)		const

Definition at line 46 of file EpCombinationTool.cc.

                                                                                                                 {
   const float scRawEnergy = ele.superCluster()->rawEnergy();
   const float esEnergy = ele.superCluster()->preshowerEnergy();
 
   const float corrEcalEnergy = ele.correctedEcalEnergy();
   const float ecalMean = ele.correctedEcalEnergy() / (scRawEnergy + esEnergy);
   const float ecalSigma = corrEcalEnergyErr / corrEcalEnergy;
 
   auto gsfTrk = ele.gsfTrack();
 
   const float trkP = gsfTrk->pMode();
   const float trkEta = gsfTrk->etaMode();
   const float trkPhi = gsfTrk->phiMode();
   const float trkPErr = std::abs(gsfTrk->qoverpModeError()) * trkP * trkP;
   const float eOverP = corrEcalEnergy / trkP;
   const float fbrem = ele.fbrem();
 
   if (corrEcalEnergy < maxEcalEnergyForComb_ && eOverP > minEOverPForComb_ &&
       std::abs(corrEcalEnergy - trkP) <
           maxEPDiffInSigmaForComb_ * std::sqrt(trkPErr * trkPErr + corrEcalEnergyErr * corrEcalEnergyErr) &&
       trkPErr < maxRelTrkMomErrForComb_ * trkP) {
     std::array<float, 9> eval;
     eval[0] = corrEcalEnergy;
     eval[1] = ecalSigma / ecalMean;
     eval[2] = trkPErr / trkP;
     eval[3] = eOverP;
     eval[4] = ele.ecalDrivenSeed();
     eval[5] = ele.full5x5_showerShape().r9;
     eval[6] = fbrem;
     eval[7] = trkEta;
     eval[8] = trkPhi;
 
     const float preCombinationEt = corrEcalEnergy / std::cosh(trkEta);
     float mean = ecalTrkEnergyRegress_(preCombinationEt, ele.isEB(), ele.nSaturatedXtals() != 0, eval.data());
     float sigma = ecalTrkEnergyRegressUncert_(preCombinationEt, ele.isEB(), ele.nSaturatedXtals() != 0, eval.data());
     // Final correction
     // A negative energy means that the correction went
     // outside the boundaries of the training. In this case uses raw.
     // The resolution estimation, on the other hand should be ok.
     if (mean < 0.)
       mean = 1.0;
 
     //why this differs from the defination of corrEcalEnergyErr (it misses the mean) is not clear to me
     //still this is a direct port from EGExtraInfoModifierFromDB, potential bugs and all
     const float ecalSigmaTimesRawEnergy = ecalSigma * (scRawEnergy + esEnergy);
     const float rawCombEnergy =
         (corrEcalEnergy * trkPErr * trkPErr + trkP * ecalSigmaTimesRawEnergy * ecalSigmaTimesRawEnergy) /
         (trkPErr * trkPErr + ecalSigmaTimesRawEnergy * ecalSigmaTimesRawEnergy);
 
     return std::make_pair(mean * rawCombEnergy, sigma * rawCombEnergy);
   } else {
     return std::make_pair(corrEcalEnergy, corrEcalEnergyErr);
   }
 }

bool EpCombinationTool::init ( const GBRForest * forest )

Definition at line 49 of file EpCombinationTool.cc.

References m_forest, and m_ownForest.

Referenced by CalibratedElectronProducerRun2T< T >::produce().

                                                     {
   if (m_ownForest)
     delete m_forest;
   m_forest = forest;
   m_ownForest = false;
   return true;
 }

bool EpCombinationTool::init	(	const std::string &	regressionFile,
		const std::string &	bdtName
	)

Definition at line 27 of file EpCombinationTool.cc.

References gather_cfg::cout, m_forest, and m_ownForest.

 {
   TFile* regressionFile = TFile::Open(regressionFileName.c_str());
   if (!regressionFile) {
     cout << "ERROR: Cannot open regression file " << regressionFileName << "\n";
     return false;
   }
   if (m_ownForest)
     delete m_forest;
   m_forest = (GBRForest*)regressionFile->Get(bdtName.c_str());
   m_ownForest = true;
   //regressionFile->GetObject(bdtName.c_str(), m_forest);
   if (!m_forest) {
     cout << "ERROR: Cannot find forest " << bdtName << " in " << regressionFileName << "\n";
     regressionFile->Close();
     return false;
   }
   regressionFile->Close();
   return true;
 }

edm::ParameterSetDescription EpCombinationTool::makePSetDescription ( )

static

Definition at line 22 of file EpCombinationTool.cc.

References edm::ParameterSetDescription::add(), and EgammaRegressionContainer::makePSetDescription().

Referenced by CalibratedElectronProducerT< T >::fillDescriptions().

                                                                   {
   edm::ParameterSetDescription desc;
   desc.add<edm::ParameterSetDescription>("ecalTrkRegressionConfig", EgammaRegressionContainer::makePSetDescription());
   desc.add<edm::ParameterSetDescription>("ecalTrkRegressionUncertConfig",
                                          EgammaRegressionContainer::makePSetDescription());
   desc.add<double>("maxEcalEnergyForComb", 200.);
   desc.add<double>("minEOverPForComb", 0.025);
   desc.add<double>("maxEPDiffInSigmaForComb", 15.);
   desc.add<double>("maxRelTrkMomErrForComb", 10.);
   return desc;
 }

EpCombinationTool& EpCombinationTool::operator= ( const EpCombinationTool & other )

delete

void EpCombinationTool::setEventContent ( const edm::EventSetup & iSetup )

Definition at line 34 of file EpCombinationTool.cc.

References ecalTrkEnergyRegress_, ecalTrkEnergyRegressUncert_, and EgammaRegressionContainer::setEventContent().

Referenced by CalibratedElectronProducerT< T >::produce(), EGRegressionModifierV3::EleRegs::setEventContent(), and EGEtScaleSysModifier::setEventContent().

                                                                    {
   ecalTrkEnergyRegress_.setEventContent(iSetup);
   ecalTrkEnergyRegressUncert_.setEventContent(iSetup);
 }

Member Data Documentation

EgammaRegressionContainer EpCombinationTool::ecalTrkEnergyRegress_

private

Definition at line 31 of file EpCombinationTool.h.

Referenced by combine(), and setEventContent().

EgammaRegressionContainer EpCombinationTool::ecalTrkEnergyRegressUncert_

private

Definition at line 32 of file EpCombinationTool.h.

Referenced by combine(), and setEventContent().

const GBRForest* EpCombinationTool::m_forest

private

Definition at line 23 of file EpCombinationTool.h.

Referenced by combine(), init(), and ~EpCombinationTool().

bool EpCombinationTool::m_ownForest

private

Definition at line 24 of file EpCombinationTool.h.

Referenced by init(), and ~EpCombinationTool().

float EpCombinationTool::maxEcalEnergyForComb_

private

Definition at line 33 of file EpCombinationTool.h.

float EpCombinationTool::maxEPDiffInSigmaForComb_

private

Definition at line 35 of file EpCombinationTool.h.

Referenced by combine().

float EpCombinationTool::maxRelTrkMomErrForComb_

private

Definition at line 36 of file EpCombinationTool.h.

Referenced by combine().

float EpCombinationTool::minEOverPForComb_

private

Definition at line 34 of file EpCombinationTool.h.

Referenced by combine().

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation