Inheritance diagram for EGEtScaleSysModifier:

Classes
class	UncertFuncBase

class	UncertFuncV1

Public Member Functions
	EGEtScaleSysModifier (const edm::ParameterSet &conf, edm::ConsumesCollector &)

void	modifyObject (pat::Electron &ele) const final

void	modifyObject (pat::Photon &pho) const final

void	setEvent (const edm::Event &) final

void	setEventContent (const edm::EventSetup &) final

	~EGEtScaleSysModifier () override

Public Member Functions inherited from ModifyObjectValueBase
virtual void	modifyObject (reco::GsfElectron &) const

virtual void	modifyObject (reco::Photon &) const

virtual void	modifyObject (reco::Muon &) const

virtual void	modifyObject (reco::BaseTau &) const

virtual void	modifyObject (reco::Jet &) const

virtual void	modifyObject (pat::Muon &) const

virtual void	modifyObject (pat::Tau &) const

virtual void	modifyObject (pat::Jet &) const

	ModifyObjectValueBase (const edm::ParameterSet &conf)

const std::string &	name () const

virtual	~ModifyObjectValueBase ()

Private Member Functions
std::pair< float, float >	calCombinedMom (reco::GsfElectron &ele, const float scale, const float smear) const

void	setEcalEnergy (reco::GsfElectron &ele, const float scale, const float smear) const

Private Attributes
EpCombinationTool	epCombTool_

std::unique_ptr< UncertFuncBase >	uncertFunc_

Detailed Description

Definition at line 28 of file EGEtScaleSysModifier.cc.

Constructor & Destructor Documentation

◆ EGEtScaleSysModifier()

EGEtScaleSysModifier::EGEtScaleSysModifier	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	cc
	)

Definition at line 89 of file EGEtScaleSysModifier.cc.

References gpuPixelDoublets::cc, edm::ParameterSet::getParameterSet(), and eostools::move().

     : ModifyObjectValueBase(conf), epCombTool_{conf.getParameterSet("epCombConfig"), std::move(cc)} {
   const edm::ParameterSet& funcPSet = conf.getParameterSet("uncertFunc");
   const std::string& funcName = funcPSet.getParameter<std::string>("name");
   if (funcName == "UncertFuncV1") {
     uncertFunc_ = std::make_unique<UncertFuncV1>(funcPSet);
   } else {
     throw cms::Exception("ConfigError") << "Error constructing EGEtScaleSysModifier, function name " << funcName
                                         << " not valid";
   }
 }

◆ ~EGEtScaleSysModifier()

EGEtScaleSysModifier::~EGEtScaleSysModifier ( )

inlineoverride

Definition at line 31 of file EGEtScaleSysModifier.cc.

31 {}

Member Function Documentation

◆ calCombinedMom()

std::pair< float, float > EGEtScaleSysModifier::calCombinedMom	(	reco::GsfElectron &	ele,
		const float	scale,
		const float	smear
	)		const

private

Definition at line 165 of file EGEtScaleSysModifier.cc.

References EpCombinationTool::combine(), reco::GsfElectron::correctMomentum(), reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), epCombTool_, reco::GsfElectron::p4(), reco::GsfElectron::P4_COMBINATION, reco::GsfElectron::p4Error(), L1EGammaClusterEmuProducer_cfi::scale, reco::GsfElectron::setCorrectedEcalEnergy(), reco::GsfElectron::setCorrectedEcalEnergyError(), setEcalEnergy(), and reco::GsfElectron::trackMomentumError().

Referenced by modifyObject().

                                                                                       {
   const float oldEcalEnergy = ele.ecalEnergy();
   const float oldEcalEnergyErr = ele.ecalEnergyError();
   const auto oldP4 = ele.p4();
   const float oldP4Err = ele.p4Error(reco::GsfElectron::P4_COMBINATION);
   const float oldTrkMomErr = ele.trackMomentumError();
 
   setEcalEnergy(ele, scale, smear);
   const auto& combinedMomentum = epCombTool_.combine(ele);
   ele.setCorrectedEcalEnergy(oldEcalEnergy);
   ele.setCorrectedEcalEnergyError(oldEcalEnergyErr);
   ele.correctMomentum(oldP4, oldTrkMomErr, oldP4Err);
 
   return combinedMomentum;
 }

◆ modifyObject() [1/2]

void EGEtScaleSysModifier::modifyObject ( pat::Electron & ele ) const

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 105 of file EGEtScaleSysModifier.cc.

                                                               {
   auto getVal = [](const pat::Electron& ele, EGEnergySysIndex::Index valIndex) {
     return ele.userFloat(EGEnergySysIndex::name(valIndex));
   };
   //so ele.energy() may be either pre or post corrections, we have no idea
   //so we explicity access the pre and post correction ecal energies
   //we need the pre corrected to properly do the e/p combination
   //we need the post corrected to get et uncertainty
   const float ecalEnergyPostCorr = getVal(ele, EGEnergySysIndex::kEcalPostCorr);
   const float ecalEnergyPreCorr = getVal(ele, EGEnergySysIndex::kEcalPreCorr);
   const float ecalEnergyErrPreCorr = getVal(ele, EGEnergySysIndex::kEcalErrPreCorr);
 
   //the et cut is in terms of ecal et using the track angle and post corr ecal energy
   const float etUncert = uncertFunc_->val(ele.et() / ele.energy() * ecalEnergyPostCorr);
   const float smear = getVal(ele, EGEnergySysIndex::kSmearValue);
   const float corr = getVal(ele, EGEnergySysIndex::kScaleValue);
 
   //get the values we have to reset back to
   const float oldEcalEnergy = ele.ecalEnergy();
   const float oldEcalEnergyErr = ele.ecalEnergyError();
   const auto oldP4 = ele.p4();
   const float oldP4Err = ele.p4Error(reco::GsfElectron::P4_COMBINATION);
   const float oldTrkMomErr = ele.trackMomentumError();
 
   ele.setCorrectedEcalEnergy(ecalEnergyPreCorr);
   ele.setCorrectedEcalEnergyError(ecalEnergyErrPreCorr);
 
   const float energyEtUncertUp = calCombinedMom(ele, corr + etUncert, smear).first;
   const float energyEtUncertDn = calCombinedMom(ele, corr - etUncert, smear).first;
 
   //reset it back to how it was
   ele.setCorrectedEcalEnergy(oldEcalEnergy);
   ele.setCorrectedEcalEnergyError(oldEcalEnergyErr);
   ele.correctMomentum(oldP4, oldTrkMomErr, oldP4Err);
 
   ele.addUserFloat("energyScaleEtUp", energyEtUncertUp);
   ele.addUserFloat("energyScaleEtDown", energyEtUncertDn);
 }

◆ modifyObject() [2/2]

void EGEtScaleSysModifier::modifyObject ( pat::Photon & pho ) const

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 144 of file EGEtScaleSysModifier.cc.

References pat::PATObject< ObjectType >::addUserFloat(), alignCSCRings::corr, reco::LeafCandidate::energy(), reco::LeafCandidate::et(), EGEnergySysIndex::kEcalPostCorr, EGEnergySysIndex::kEcalPreCorr, EGEnergySysIndex::kScaleValue, EGEnergySysIndex::name(), uncertFunc_, and pat::PATObject< ObjectType >::userFloat().

                                                             {
   auto getVal = [](const pat::Photon& pho, EGEnergySysIndex::Index valIndex) {
     return pho.userFloat(EGEnergySysIndex::name(valIndex));
   };
   //so pho.energy() may be either pre or post corrections, we have no idea
   //so we explicity access the pre and post correction ecal energies
   //post corr for the et value for the systematic, pre corr to apply them
   const float ecalEnergyPostCorr = getVal(pho, EGEnergySysIndex::kEcalPostCorr);
   const float ecalEnergyPreCorr = getVal(pho, EGEnergySysIndex::kEcalPreCorr);
 
   //the et cut is in terms of post corr ecal energy
   const float etUncert = uncertFunc_->val(pho.et() / pho.energy() * ecalEnergyPostCorr);
   const float corr = getVal(pho, EGEnergySysIndex::kScaleValue);
 
   const float energyEtUncertUp = ecalEnergyPreCorr * (corr + etUncert);
   const float energyEtUncertDn = ecalEnergyPreCorr * (corr - etUncert);
 
   pho.addUserFloat("energyScaleEtUp", energyEtUncertUp);
   pho.addUserFloat("energyScaleEtDown", energyEtUncertDn);
 }

◆ setEcalEnergy()

void EGEtScaleSysModifier::setEcalEnergy	(	reco::GsfElectron &	ele,
		const float	scale,
		const float	smear
	)		const

private

Definition at line 183 of file EGEtScaleSysModifier.cc.

References reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), L1EGammaClusterEmuProducer_cfi::scale, reco::GsfElectron::setCorrectedEcalEnergy(), and reco::GsfElectron::setCorrectedEcalEnergyError().

Referenced by calCombinedMom().

                                                                                                          {
   const float oldEcalEnergy = ele.ecalEnergy();
   const float oldEcalEnergyErr = ele.ecalEnergyError();
   ele.setCorrectedEcalEnergy(oldEcalEnergy * scale);
   ele.setCorrectedEcalEnergyError(std::hypot(oldEcalEnergyErr * scale, oldEcalEnergy * smear * scale));
 }