EpCombinationTool Class Reference

#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, edm::ConsumesCollector &&cc)
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,
		edm::ConsumesCollector &&	cc
	)

Definition at line 15 of file EpCombinationTool.cc.

    : ecalTrkEnergyRegress_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionConfig"), cc),
      ecalTrkEnergyRegressUncert_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionUncertConfig"), cc),
      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 23 of file EpCombinationTool.h.

{}

Member Function Documentation

void EpCombinationTool::combine

(

SimpleElectron &

mySimpleElectron

)

const

Definition at line 58 of file EpCombinationTool.cc.

References gather_cfg::cout, relval_parameters_module::energy, mathSSE::sqrt(), and histoStyle::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 40 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 47 of file EpCombinationTool.cc.

References funct::abs(), reco::GsfElectron::correctedEcalEnergy(), reco::GsfElectron::ecalDrivenSeed(), ecalTrkEnergyRegress_, ecalTrkEnergyRegressUncert_, reco::GsfElectron::fbrem(), reco::GsfElectron::full5x5_showerShape(), reco::GsfElectron::gsfTrack(), reco::GsfElectron::isEB(), maxEPDiffInSigmaForComb_, maxRelTrkMomErrForComb_, SiStripPI::mean, minEOverPForComb_, reco::GsfElectron::nSaturatedXtals(), reco::GsfElectron::ShowerShape::r9, mathSSE::sqrt(), and reco::GsfElectron::superCluster().

                                                                                                                {
  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.

                                                    {
  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 23 of file EpCombinationTool.cc.

References edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, 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 35 of file EpCombinationTool.cc.

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

Referenced by EGEtScaleSysModifier::setEventContent().

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

Member Data Documentation

EgammaRegressionContainer EpCombinationTool::ecalTrkEnergyRegress_

private

Definition at line 32 of file EpCombinationTool.h.

Referenced by combine(), and setEventContent().

EgammaRegressionContainer EpCombinationTool::ecalTrkEnergyRegressUncert_

private

Definition at line 33 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 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 34 of file EpCombinationTool.h.

float EpCombinationTool::maxEPDiffInSigmaForComb_

private

Definition at line 36 of file EpCombinationTool.h.

Referenced by combine().

float EpCombinationTool::maxRelTrkMomErrForComb_

private

Definition at line 37 of file EpCombinationTool.h.

Referenced by combine().

float EpCombinationTool::minEOverPForComb_

private

Definition at line 35 of file EpCombinationTool.h.

Referenced by combine().