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	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &
	)

Definition at line 89 of file EGEtScaleSysModifier.cc.

References Exception, edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, and uncertFunc_.

     : ModifyObjectValueBase(conf), epCombTool_(conf.getParameter<edm::ParameterSet>("epCombConfig")) {
   const edm::ParameterSet funcPSet = conf.getParameter<edm::ParameterSet>("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 ( )

inlineoverride

Definition at line 31 of file EGEtScaleSysModifier.cc.

References calCombinedMom(), modifyObject(), Scenarios_cff::scale, setEcalEnergy(), setEvent(), and setEventContent().

31 {}

Member Function Documentation

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(), reco::GsfElectron::setCorrectedEcalEnergy(), reco::GsfElectron::setCorrectedEcalEnergyError(), setEcalEnergy(), and reco::GsfElectron::trackMomentumError().

Referenced by modifyObject(), and ~EGEtScaleSysModifier().

                                                                                       {
   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;
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 105 of file EGEtScaleSysModifier.cc.

Referenced by ~EGEtScaleSysModifier().

                                                               {
   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);
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 144 of file EGEtScaleSysModifier.cc.

References pat::PATObject< ObjectType >::addUserFloat(), 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);
 }

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

private

Definition at line 183 of file EGEtScaleSysModifier.cc.

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

Referenced by calCombinedMom(), and ~EGEtScaleSysModifier().

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