#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_

std::string	candidateP4type_

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

References barrelEcalHits_, barrelEcalHitsToken_, looper::config, endcapEcalHits_, endcapEcalHitsToken_, edm::ParameterSet::existsAs(), gedRegression_, timingPdfMaker::get, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), minR9Barrel_, minR9Endcap_, photonEcalEnergyCorrFunction_, photonUncertaintyCalculator_, regressionCorrector_, scCrackEnergyFunction_, scEnergyErrorFunction_, scEnergyFunction_, AlCaHLTBitMon_QueryRunRegistry::string, w_db_, w_file_, and weightsfromDB_.

                                                                                                      {
   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);
 
   // function to extract corrections to cracks
   std::string superClusterCrackFunctionName = config.getParameter<std::string>("superClusterCrackEnergyCorrFunction");
   scCrackEnergyFunction_ = EcalClusterFunctionFactory::get()->create(superClusterCrackFunctionName, config);
 
   // function to extract the error on the sc ecal correction
   std::string superClusterErrorFunctionName = config.getParameter<std::string>("superClusterEnergyErrorFunction");
   scEnergyErrorFunction_ = EcalClusterFunctionFactory::get()->create(superClusterErrorFunctionName, config);
 
   // function  to extract the error on the photon ecal correction
   std::string photonEnergyFunctionName = config.getParameter<std::string>("photonEcalEnergyCorrFunction");
   photonEcalEnergyCorrFunction_ = EcalClusterFunctionFactory::get()->create(photonEnergyFunctionName, config);
   //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");
   else
     w_db_ = "none";
   regressionCorrector_ = std::make_unique<EGEnergyCorrector>();
 }

Member Function Documentation

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

Definition at line 175 of file PhotonEnergyCorrector.cc.

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

Referenced by calculate(), and gedRegression().

                                                                                                           {
   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 80 of file PhotonEnergyCorrector.cc.

References applyCrackCorrection(), barrelEcalHitsToken_, EgHLTOffHistBins_cfi::deltaE, reco::Photon::e5x5(), DetId::Ecal, reco::Photon::ecal_photons, reco::Photon::ecal_standard, EcalBarrel, EcalEndcap, endcapEcalHitsToken_, gedRegression_, reco::Photon::getCorrectedEnergy(), reco::Photon::getCorrectedEnergyError(), CaloGeometry::getSubdetectorGeometry(), EgHLTOffEleSelection_cfi::minR9, minR9Barrel_, minR9Endcap_, photonEcalEnergyCorrFunction_, photonUncertaintyCalculator_, reco::Photon::r9(), reco::Photon::regression1, reco::Photon::regression2, regressionCorrector_, scCrackEnergyFunction_, scEnergyFunction_, reco::Photon::setCorrectedEnergy(), reco::Photon::superCluster(), theCaloGeom_, w_file_, and weightsfromDB_.

Referenced by PhotonProducer::fillPhotonCollection(), GEDPhotonProducer::fillPhotonCollection(), and gedRegression().

                                                                    {
   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, 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, iSetup);
     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 applyCrackCorrection(), calculate(), GetRecoTauVFromDQM_MC_cff::cl, gedRegression_, and init().

Referenced by GEDPhotonProducer::produce().

30 { return gedRegression_; }

PhotonEnergyCorrector::gedRegression_

std::unique_ptr< ModifyObjectValueBase > gedRegression_

Definition: PhotonEnergyCorrector.h:47

void PhotonEnergyCorrector::init ( const edm::EventSetup & theEventSetup )

Definition at line 60 of file PhotonEnergyCorrector.cc.

References edm::EventSetup::get(), photonEcalEnergyCorrFunction_, photonUncertaintyCalculator_, regressionCorrector_, scCrackEnergyFunction_, scEnergyErrorFunction_, scEnergyFunction_, theCaloGeom_, w_db_, w_file_, and weightsfromDB_.

Referenced by GEDPhotonProducer::beginRun(), PhotonProducer::fillPhotonCollection(), gedRegression(), and GEDPhotonProducer::produce().

                                                                    {
   theEventSetup.get<CaloGeometryRecord>().get(theCaloGeom_);
 
   scEnergyFunction_->init(theEventSetup);
   scCrackEnergyFunction_->init(theEventSetup);
   scEnergyErrorFunction_->init(theEventSetup);
   photonEcalEnergyCorrFunction_->init(theEventSetup);
 
   if (weightsfromDB_) {
     if (!regressionCorrector_->IsInitialized())
       regressionCorrector_->Initialize(theEventSetup, w_db_, weightsfromDB_);
   }
   if (!weightsfromDB_ && !(w_file_ == "none")) {
     if (!regressionCorrector_->IsInitialized())
       regressionCorrector_->Initialize(theEventSetup, w_file_, weightsfromDB_);
   }
 
   photonUncertaintyCalculator_->init(theEventSetup);
 }