PhotonEnergyCorrector Class Reference

#include <PhotonEnergyCorrector.h>

Public Member Functions
double	applyCrackCorrection (const reco::SuperCluster &cl, EcalClusterFunctionBaseClass *crackCorrectionFunction)
void	calculate (edm::Event &evt, reco::Photon &, int subdet, const reco::VertexCollection &vtxcol, const edm::EventSetup &iSetup)
std::unique_ptr < ModifyObjectValueBase > &	gedRegression ()
void	init (const edm::EventSetup &theEventSetup)
	PhotonEnergyCorrector (const edm::ParameterSet &config, edm::ConsumesCollector &&iC)

Private Attributes
edm::InputTag	barrelEcalHits_
edm::EDGetTokenT < EcalRecHitCollection >	barrelEcalHitsToken_
const edm::ESGetToken < CaloGeometry, CaloGeometryRecord >	caloGeomToken_
std::string	candidateP4type_
const EcalClusterLazyTools::ESGetTokens	ecalClusterToolsESGetTokens_
edm::InputTag	endcapEcalHits_
edm::EDGetTokenT < EcalRecHitCollection >	endcapEcalHitsToken_
std::unique_ptr < ModifyObjectValueBase >	gedRegression_
double	minR9Barrel_
double	minR9Endcap_
std::unique_ptr < EcalClusterFunctionBaseClass >	photonEcalEnergyCorrFunction_
std::unique_ptr < EnergyUncertaintyPhotonSpecific >	photonUncertaintyCalculator_
std::unique_ptr < EGEnergyCorrector >	regressionCorrector_
std::unique_ptr < EGEnergyCorrectorFactoryFromEventSetup >	regressionCorrectorFactory_
std::unique_ptr < EcalClusterFunctionBaseClass >	scCrackEnergyFunction_
std::unique_ptr < EcalClusterFunctionBaseClass >	scEnergyErrorFunction_
std::unique_ptr < EcalClusterFunctionBaseClass >	scEnergyFunction_
edm::ESHandle< CaloGeometry >	theCaloGeom_
std::string	w_db_
std::string	w_file_
bool	weightsfromDB_

Detailed Description

Author

Nancy Marinelli, U. of Notre Dame, US

Definition at line 26 of file PhotonEnergyCorrector.h.

Constructor & Destructor Documentation

PhotonEnergyCorrector::PhotonEnergyCorrector	(	const edm::ParameterSet &	config,
		edm::ConsumesCollector &&	iC
	)

Definition at line 14 of file PhotonEnergyCorrector.cc.

    : ecalClusterToolsESGetTokens_{iC}, caloGeomToken_{iC.esConsumes()} {
  minR9Barrel_ = config.getParameter<double>("minR9Barrel");
  minR9Endcap_ = config.getParameter<double>("minR9Endcap");
  // get the geometry from the event setup:

  barrelEcalHits_ = config.getParameter<edm::InputTag>("barrelEcalHits");
  endcapEcalHits_ = config.getParameter<edm::InputTag>("endcapEcalHits");
  barrelEcalHitsToken_ = iC.consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("barrelEcalHits"));
  endcapEcalHitsToken_ = iC.consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("endcapEcalHits"));

  //  candidateP4type_ = config.getParameter<std::string>("candidateP4type") ;

  // function to extract f(eta) correction
  std::string superClusterFunctionName = config.getParameter<std::string>("superClusterEnergyCorrFunction");
  scEnergyFunction_ = EcalClusterFunctionFactory::get()->create(superClusterFunctionName, config, iC);

  // function to extract corrections to cracks
  std::string superClusterCrackFunctionName = config.getParameter<std::string>("superClusterCrackEnergyCorrFunction");
  scCrackEnergyFunction_ = EcalClusterFunctionFactory::get()->create(superClusterCrackFunctionName, config, iC);

  // function to extract the error on the sc ecal correction
  std::string superClusterErrorFunctionName = config.getParameter<std::string>("superClusterEnergyErrorFunction");
  scEnergyErrorFunction_ = EcalClusterFunctionFactory::get()->create(superClusterErrorFunctionName, config, iC);

  // function  to extract the error on the photon ecal correction
  std::string photonEnergyFunctionName = config.getParameter<std::string>("photonEcalEnergyCorrFunction");
  photonEcalEnergyCorrFunction_ = EcalClusterFunctionFactory::get()->create(photonEnergyFunctionName, config, iC);
  //ingredient for photon uncertainty
  photonUncertaintyCalculator_ = std::make_unique<EnergyUncertaintyPhotonSpecific>(config);

  if (config.existsAs<edm::ParameterSet>("regressionConfig")) {
    const edm::ParameterSet& regr_conf = config.getParameterSet("regressionConfig");
    const std::string& mname = regr_conf.getParameter<std::string>("modifierName");
    gedRegression_ = ModifyObjectValueFactory::get()->create(mname, regr_conf, iC);
  }

  // ingredient for energy regression
  weightsfromDB_ = config.getParameter<bool>("regressionWeightsFromDB");
  w_file_ = config.getParameter<std::string>("energyRegressionWeightsFileLocation");
  if (weightsfromDB_) {
    w_db_ = config.getParameter<std::string>("energyRegressionWeightsDBLocation");
    regressionCorrectorFactory_ = std::make_unique<EGEnergyCorrectorFactoryFromEventSetup>(iC, w_db_);
  } else if (w_file_ != "none") {
    regressionCorrector_ = std::make_unique<EGEnergyCorrector>(egEnergyCorrectorFactoryFromRootFile(w_file_.c_str()));
  } else {
    regressionCorrector_ = std::make_unique<EGEnergyCorrector>();
  }
}

Member Function Documentation

double PhotonEnergyCorrector::applyCrackCorrection	(	const reco::SuperCluster &	cl,
		EcalClusterFunctionBaseClass *	crackCorrectionFunction
	)

Definition at line 174 of file PhotonEnergyCorrector.cc.

References reco::SuperCluster::clustersBegin(), reco::SuperCluster::clustersEnd(), EcalClusterFunctionBaseClass::getValue(), and reco::SuperCluster::rawEnergy().

Referenced by calculate().

                                                                                                          {
  double crackcor = 1.;

  for (reco::CaloCluster_iterator cIt = cl.clustersBegin(); cIt != cl.clustersEnd(); ++cIt) {
    const reco::CaloClusterPtr cc = *cIt;
    crackcor *= ((cl.rawEnergy() + cc->energy() * (crackCorrectionFunction->getValue(*cc) - 1.)) / cl.rawEnergy());
  }  // loop on BCs

  return crackcor;
}

void PhotonEnergyCorrector::calculate	(	edm::Event &	evt,
		reco::Photon &	thePhoton,
		int	subdet,
		const reco::VertexCollection &	vtxcol,
		const edm::EventSetup &	iSetup
	)

Definition at line 78 of file PhotonEnergyCorrector.cc.

References applyCrackCorrection(), barrelEcalHitsToken_, reco::Photon::e5x5(), DetId::Ecal, reco::Photon::ecal_photons, reco::Photon::ecal_standard, EcalBarrel, ecalClusterToolsESGetTokens_, EcalEndcap, endcapEcalHitsToken_, EcalClusterLazyToolsBase::ESGetTokens::get(), reco::Photon::getCorrectedEnergy(), reco::Photon::getCorrectedEnergyError(), minR9Barrel_, minR9Endcap_, photonUncertaintyCalculator_, reco::Photon::r9(), reco::Photon::regression1, reco::Photon::regression2, regressionCorrector_, scEnergyFunction_, reco::Photon::setCorrectedEnergy(), reco::Photon::superCluster(), theCaloGeom_, and weightsfromDB_.

Referenced by PhotonProducer::fillPhotonCollection().

                                                                   {
  double phoEcalEnergy = -9999.;
  double phoEcalEnergyError = -9999.;
  double phoRegr1Energy = -9999.;
  double phoRegr1EnergyError = -9999.;
  theCaloGeom_->getSubdetectorGeometry(DetId::Ecal, subdet);

  double minR9 = 0;
  if (subdet == EcalBarrel) {
    minR9 = minR9Barrel_;
  } else if (subdet == EcalEndcap) {
    minR9 = minR9Endcap_;
  }

  EcalClusterLazyTools lazyTools(
      evt, ecalClusterToolsESGetTokens_.get(iSetup), barrelEcalHitsToken_, endcapEcalHitsToken_);

  if (thePhoton.r9() > minR9) {
    // f(eta) correction to e5x5
    double deltaE = scEnergyFunction_->getValue(*(thePhoton.superCluster()), 1);
    float e5x5 = thePhoton.e5x5();
    if (subdet == EcalBarrel)
      e5x5 = e5x5 * (1.0 + deltaE / thePhoton.superCluster()->rawEnergy());
    phoEcalEnergy = e5x5 + thePhoton.superCluster()->preshowerEnergy();
  } else {
    phoEcalEnergy = thePhoton.superCluster()->energy();
  }
  // store the value in the Photon.h
  thePhoton.setCorrectedEnergy(reco::Photon::ecal_standard, phoEcalEnergy, phoEcalEnergyError, false);


  if (thePhoton.r9() > minR9) {
    // f(eta) correction to e5x5
    double deltaE = scEnergyFunction_->getValue(*(thePhoton.superCluster()), 1);
    float e5x5 = thePhoton.e5x5();
    if (subdet == EcalBarrel)
      e5x5 = e5x5 * (1.0 + deltaE / thePhoton.superCluster()->rawEnergy());
    phoEcalEnergy = e5x5 + thePhoton.superCluster()->preshowerEnergy();
    // add correction for cracks
    phoEcalEnergy *= scCrackEnergyFunction_->getValue(*(thePhoton.superCluster()));
    phoEcalEnergyError = photonUncertaintyCalculator_->computePhotonEnergyUncertainty_highR9(
        thePhoton.superCluster()->eta(),
        thePhoton.superCluster()->phiWidth() / thePhoton.superCluster()->etaWidth(),
        phoEcalEnergy);
  } else {
    // correction for low r9
    phoEcalEnergy = photonEcalEnergyCorrFunction_->getValue(*(thePhoton.superCluster()), 1);
    phoEcalEnergy *= applyCrackCorrection(*(thePhoton.superCluster()), scCrackEnergyFunction_.get());
    phoEcalEnergyError = photonUncertaintyCalculator_->computePhotonEnergyUncertainty_lowR9(
        thePhoton.superCluster()->eta(),
        thePhoton.superCluster()->phiWidth() / thePhoton.superCluster()->etaWidth(),
        phoEcalEnergy);
  }

  // store the value in the Photon.h
  thePhoton.setCorrectedEnergy(reco::Photon::ecal_photons, phoEcalEnergy, phoEcalEnergyError, false);

  //
  if ((weightsfromDB_ && !gedRegression_) || (!weightsfromDB_ && !(w_file_ == "none"))) {
    std::pair<double, double> cor =
        regressionCorrector_->CorrectedEnergyWithError(thePhoton, vtxcol, lazyTools, *theCaloGeom_);
    phoRegr1Energy = cor.first;
    phoRegr1EnergyError = cor.second;
    // store the value in the Photon.h
    thePhoton.setCorrectedEnergy(reco::Photon::regression1, phoRegr1Energy, phoRegr1EnergyError, false);
  }

  if (gedRegression_) {
    gedRegression_->modifyObject(thePhoton);  // uses regression2 slot
    // force regresions1 and 2 to be the same (no reason to be different)
    thePhoton.setCorrectedEnergy(reco::Photon::regression1,
                                 thePhoton.getCorrectedEnergy(reco::Photon::regression2),
                                 thePhoton.getCorrectedEnergyError(reco::Photon::regression2),
                                 false);
  }

  /*
  std::cout << " ------------------------- " << std::endl;
  std::cout << " Corrector " << std::endl;
  std::cout << " P4 Type " << thePhoton.getCandidateP4type() << " candidate p4 " << thePhoton.p4() << std::endl;
  std::cout << " photon ecalEnergy " << thePhoton.getCorrectedEnergy(reco::Photon::ecal_photons) << " error " << thePhoton.getCorrectedEnergyError(reco::Photon::ecal_photons) << std::endl;
  std::cout << " ecal p4 from accessor " << thePhoton.p4(reco::Photon::ecal_photons) <<  std::endl;
  std::cout << " ------------------------- " << std::endl;
  std::cout << " reg1 energy " << thePhoton.getCorrectedEnergy(reco::Photon::regression1)  << " error " <<  thePhoton.getCorrectedEnergyError(reco::Photon::regression1) << std::endl;
  std::cout << " New p4 from regression " <<  thePhoton.p4(reco::Photon::regression1)    << std::endl;
  std::cout << " ------------------------- " << std::endl;
  */
}

std::unique_ptr<ModifyObjectValueBase>& PhotonEnergyCorrector::gedRegression ( )

inline

Definition at line 30 of file PhotonEnergyCorrector.h.

References gedRegression_.

{ return gedRegression_; }

void PhotonEnergyCorrector::init

(

const edm::EventSetup &

theEventSetup

)

Definition at line 64 of file PhotonEnergyCorrector.cc.

References caloGeomToken_, edm::EventSetup::getHandle(), photonUncertaintyCalculator_, regressionCorrector_, regressionCorrectorFactory_, scEnergyFunction_, and theCaloGeom_.

Referenced by PhotonProducer::fillPhotonCollection().

                                                                   {
  theCaloGeom_ = theEventSetup.getHandle(caloGeomToken_);

  scEnergyFunction_->init(theEventSetup);
  scCrackEnergyFunction_->init(theEventSetup);
  scEnergyErrorFunction_->init(theEventSetup);
  photonEcalEnergyCorrFunction_->init(theEventSetup);

  if (not regressionCorrector_) {
    regressionCorrector_ = std::make_unique<EGEnergyCorrector>(regressionCorrectorFactory_->build(theEventSetup));
  }
  photonUncertaintyCalculator_->init(theEventSetup);
}

Member Data Documentation

edm::InputTag PhotonEnergyCorrector::barrelEcalHits_

private

Definition at line 52 of file PhotonEnergyCorrector.h.

edm::EDGetTokenT<EcalRecHitCollection> PhotonEnergyCorrector::barrelEcalHitsToken_

private

Definition at line 54 of file PhotonEnergyCorrector.h.

Referenced by calculate().

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> PhotonEnergyCorrector::caloGeomToken_

private

Definition at line 57 of file PhotonEnergyCorrector.h.

Referenced by init().

std::string PhotonEnergyCorrector::candidateP4type_

private

Definition at line 41 of file PhotonEnergyCorrector.h.

const EcalClusterLazyTools::ESGetTokens PhotonEnergyCorrector::ecalClusterToolsESGetTokens_

private

Definition at line 56 of file PhotonEnergyCorrector.h.

Referenced by calculate().

edm::InputTag PhotonEnergyCorrector::endcapEcalHits_

private

Definition at line 53 of file PhotonEnergyCorrector.h.

edm::EDGetTokenT<EcalRecHitCollection> PhotonEnergyCorrector::endcapEcalHitsToken_

private

Definition at line 55 of file PhotonEnergyCorrector.h.

Referenced by calculate().

std::unique_ptr<ModifyObjectValueBase> PhotonEnergyCorrector::gedRegression_

private

Definition at line 48 of file PhotonEnergyCorrector.h.

Referenced by gedRegression().

double PhotonEnergyCorrector::minR9Barrel_

private

Definition at line 49 of file PhotonEnergyCorrector.h.

Referenced by calculate().

double PhotonEnergyCorrector::minR9Endcap_

private

Definition at line 50 of file PhotonEnergyCorrector.h.

Referenced by calculate().

std::unique_ptr<EcalClusterFunctionBaseClass> PhotonEnergyCorrector::photonEcalEnergyCorrFunction_

private

Definition at line 47 of file PhotonEnergyCorrector.h.

std::unique_ptr<EnergyUncertaintyPhotonSpecific> PhotonEnergyCorrector::photonUncertaintyCalculator_

private

Definition at line 59 of file PhotonEnergyCorrector.h.

Referenced by calculate(), and init().

std::unique_ptr<EGEnergyCorrector> PhotonEnergyCorrector::regressionCorrector_

private

Definition at line 43 of file PhotonEnergyCorrector.h.

Referenced by calculate(), and init().

std::unique_ptr<EGEnergyCorrectorFactoryFromEventSetup> PhotonEnergyCorrector::regressionCorrectorFactory_

private

Definition at line 42 of file PhotonEnergyCorrector.h.

Referenced by init().

std::unique_ptr<EcalClusterFunctionBaseClass> PhotonEnergyCorrector::scCrackEnergyFunction_

private

Definition at line 45 of file PhotonEnergyCorrector.h.

std::unique_ptr<EcalClusterFunctionBaseClass> PhotonEnergyCorrector::scEnergyErrorFunction_

private

Definition at line 46 of file PhotonEnergyCorrector.h.

std::unique_ptr<EcalClusterFunctionBaseClass> PhotonEnergyCorrector::scEnergyFunction_

private

Definition at line 44 of file PhotonEnergyCorrector.h.

Referenced by calculate(), and init().

edm::ESHandle<CaloGeometry> PhotonEnergyCorrector::theCaloGeom_

private

Definition at line 51 of file PhotonEnergyCorrector.h.

Referenced by calculate(), and init().

std::string PhotonEnergyCorrector::w_db_

private

Definition at line 40 of file PhotonEnergyCorrector.h.

std::string PhotonEnergyCorrector::w_file_

private

Definition at line 39 of file PhotonEnergyCorrector.h.

bool PhotonEnergyCorrector::weightsfromDB_

private

Definition at line 38 of file PhotonEnergyCorrector.h.

Referenced by calculate().