Inheritance diagram for EGFull5x5ShowerShapeModifierFromValueMaps:

Classes
struct	electron_config

struct	photon_config

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

void	modifyObject (pat::Electron &) const final

void	modifyObject (pat::Photon &) const final

void	setEvent (const edm::Event &) final

Public Member Functions inherited from ModifyObjectValueBase
virtual void	modifyObject (pat::Jet &) const

virtual void	modifyObject (pat::Muon &) const

virtual void	modifyObject (pat::Tau &) const

virtual void	modifyObject (reco::BaseTau &) const

virtual void	modifyObject (reco::GsfElectron &) const

virtual void	modifyObject (reco::Jet &) const

virtual void	modifyObject (reco::Muon &) const

virtual void	modifyObject (reco::Photon &) const

	ModifyObjectValueBase (const edm::ParameterSet &conf)

const std::string &	name () const

virtual void	setEventContent (const edm::EventSetup &)

virtual	~ModifyObjectValueBase ()

Private Attributes
electron_config	e_conf

unsigned	ele_idx

std::unordered_map< unsigned, edm::Handle< edm::ValueMap< float > > >	ele_vmaps

std::vector< edm::Ptr< reco::GsfElectron > >	eles_by_oop

photon_config	ph_conf

unsigned	pho_idx

std::unordered_map< unsigned, edm::Handle< edm::ValueMap< float > > >	pho_vmaps

std::vector< edm::Ptr< reco::Photon > >	phos_by_oop

Detailed Description

Definition at line 21 of file EGFull5x5ShowerShapeModifier.cc.

Constructor & Destructor Documentation

◆ EGFull5x5ShowerShapeModifierFromValueMaps()

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

Definition at line 75 of file EGFull5x5ShowerShapeModifier.cc.

     : ModifyObjectValueBase(conf) {
   if (conf.exists("electron_config")) {
     auto const& electrons = conf.getParameterSet("electron_config");
     if (electrons.exists("electronSrc"))
       make_consumes(electrons.getParameter<edm::InputTag>("electronSrc"), e_conf.tok_electron_src, cc);
     if (electrons.exists("sigmaEtaEta"))
       make_consumes(electrons.getParameter<edm::InputTag>("sigmaEtaEta"), e_conf.tok_sigmaEtaEta, cc);
     if (electrons.exists("sigmaIetaIeta"))
       make_consumes(electrons.getParameter<edm::InputTag>("sigmaIetaIeta"), e_conf.tok_sigmaIetaIeta, cc);
     if (electrons.exists("sigmaIphiIphi"))
       make_consumes(electrons.getParameter<edm::InputTag>("sigmaIphiIphi"), e_conf.tok_sigmaIphiIphi, cc);
     if (electrons.exists("e1x5"))
       make_consumes(electrons.getParameter<edm::InputTag>("e1x5"), e_conf.tok_e1x5, cc);
     if (electrons.exists("e2x5Max"))
       make_consumes(electrons.getParameter<edm::InputTag>("e2x5Max"), e_conf.tok_e2x5Max, cc);
     if (electrons.exists("e5x5"))
       make_consumes(electrons.getParameter<edm::InputTag>("e5x5"), e_conf.tok_e5x5, cc);
     if (electrons.exists("r9"))
       make_consumes(electrons.getParameter<edm::InputTag>("r9"), e_conf.tok_r9, cc);
     if (electrons.exists("hcalDepth1OverEcal"))
       make_consumes(electrons.getParameter<edm::InputTag>("hcalDepth1OverEcal"), e_conf.tok_hcalDepth1OverEcal, cc);
     if (electrons.exists("hcalDepth2OverEcal"))
       make_consumes(electrons.getParameter<edm::InputTag>("hcalDepth2OverEcal"), e_conf.tok_hcalDepth2OverEcal, cc);
     if (electrons.exists("hcalDepth1OverEcalBc"))
       make_consumes(electrons.getParameter<edm::InputTag>("hcalDepth1OverEcalBc"), e_conf.tok_hcalDepth1OverEcalBc, cc);
     if (electrons.exists("hcalDepth2OverEcalBc"))
       make_consumes(electrons.getParameter<edm::InputTag>("hcalDepth2OverEcalBc"), e_conf.tok_hcalDepth2OverEcalBc, cc);
   }
   if (conf.exists("photon_config")) {
     auto const& photons = conf.getParameterSet("photon_config");
     if (photons.exists("photonSrc"))
       make_consumes(photons.getParameter<edm::InputTag>("photonSrc"), ph_conf.tok_photon_src, cc);
     if (photons.exists("sigmaEtaEta"))
       make_consumes(photons.getParameter<edm::InputTag>("sigmaEtaEta"), ph_conf.tok_sigmaEtaEta, cc);
     if (photons.exists("sigmaIetaIeta"))
       make_consumes(photons.getParameter<edm::InputTag>("sigmaIetaIeta"), ph_conf.tok_sigmaIetaIeta, cc);
     if (photons.exists("e1x5"))
       make_consumes(photons.getParameter<edm::InputTag>("e1x5"), ph_conf.tok_e1x5, cc);
     if (photons.exists("e2x5"))
       make_consumes(photons.getParameter<edm::InputTag>("e2x5"), ph_conf.tok_e2x5, cc);
     if (photons.exists("e3x3"))
       make_consumes(photons.getParameter<edm::InputTag>("e3x3"), ph_conf.tok_e3x3, cc);
     if (photons.exists("e5x5"))
       make_consumes(photons.getParameter<edm::InputTag>("e5x5"), ph_conf.tok_e5x5, cc);
     if (photons.exists("maxEnergyXtal"))
       make_consumes(photons.getParameter<edm::InputTag>("maxEnergyXtal"), ph_conf.tok_maxEnergyXtal, cc);
     if (photons.exists("hcalDepth1OverEcal"))
       make_consumes(photons.getParameter<edm::InputTag>("hcalDepth1OverEcal"), ph_conf.tok_hcalDepth1OverEcal, cc);
     if (photons.exists("hcalDepth2OverEcal"))
       make_consumes(photons.getParameter<edm::InputTag>("hcalDepth2OverEcal"), ph_conf.tok_hcalDepth2OverEcal, cc);
     if (photons.exists("hcalDepth1OverEcalBc"))
       make_consumes(photons.getParameter<edm::InputTag>("hcalDepth1OverEcalBc"), ph_conf.tok_hcalDepth1OverEcalBc, cc);
     if (photons.exists("hcalDepth2OverEcalBc"))
       make_consumes(photons.getParameter<edm::InputTag>("hcalDepth2OverEcalBc"), ph_conf.tok_hcalDepth2OverEcalBc, cc);
   }
  
   ele_idx = pho_idx = 0;
 }

Member Function Documentation

◆ modifyObject() [1/2]

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 200 of file EGFull5x5ShowerShapeModifier.cc.

                                                                                    {
   // we encounter two cases here, either we are running AOD -> MINIAOD
   // and the value maps are to the reducedEG object, can use original object ptr
   // or we are running MINIAOD->MINIAOD and we need to fetch the pat objects to reference
   edm::Ptr<reco::Candidate> ptr(ele.originalObjectRef());
  
   // The calls to this function should be matched to the order of the electrons
   // in eles_by_oop. In case it is called too many times, it will throw thanks
   // to the use of std::vector<T>::at().
   if (!e_conf.tok_electron_src.isUninitialized())
     ptr = eles_by_oop.at(ele_idx);
  
   //now we go through and modify the objects using the valuemaps we read in
   auto full5x5 = ele.full5x5_showerShape();
   assignValue(ptr, e_conf.tok_sigmaEtaEta, ele_vmaps, full5x5.sigmaEtaEta);
   assignValue(ptr, e_conf.tok_sigmaIetaIeta, ele_vmaps, full5x5.sigmaIetaIeta);
   assignValue(ptr, e_conf.tok_sigmaIphiIphi, ele_vmaps, full5x5.sigmaIphiIphi);
   assignValue(ptr, e_conf.tok_e1x5, ele_vmaps, full5x5.e1x5);
   assignValue(ptr, e_conf.tok_e2x5Max, ele_vmaps, full5x5.e2x5Max);
   assignValue(ptr, e_conf.tok_e5x5, ele_vmaps, full5x5.e5x5);
   assignValue(ptr, e_conf.tok_r9, ele_vmaps, full5x5.r9);
   assignValue(ptr, e_conf.tok_hcalDepth1OverEcal, ele_vmaps, full5x5.hcalDepth1OverEcal);
   assignValue(ptr, e_conf.tok_hcalDepth2OverEcal, ele_vmaps, full5x5.hcalDepth2OverEcal);
   assignValue(ptr, e_conf.tok_hcalDepth1OverEcalBc, ele_vmaps, full5x5.hcalDepth1OverEcalBc);
   assignValue(ptr, e_conf.tok_hcalDepth2OverEcalBc, ele_vmaps, full5x5.hcalDepth2OverEcalBc);
  
   ele.full5x5_setShowerShape(full5x5);
   ++ele_idx;
 }

◆ modifyObject() [2/2]

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 230 of file EGFull5x5ShowerShapeModifier.cc.

                                                                                  {
   // we encounter two cases here, either we are running AOD -> MINIAOD
   // and the value maps are to the reducedEG object, can use original object ptr
   // or we are running MINIAOD->MINIAOD and we need to fetch the pat objects to reference
   edm::Ptr<reco::Candidate> ptr(pho.originalObjectRef());
  
   // The calls to this function should be matched to the order of the electrons
   // in eles_by_oop. In case it is called too many times, it will throw thanks
   // to the use of std::vector<T>::at().
   if (!ph_conf.tok_photon_src.isUninitialized())
     ptr = phos_by_oop.at(pho_idx);
  
   //now we go through and modify the objects using the valuemaps we read in
   auto full5x5 = pho.full5x5_showerShapeVariables();
   assignValue(ptr, ph_conf.tok_sigmaEtaEta, pho_vmaps, full5x5.sigmaEtaEta);
   assignValue(ptr, ph_conf.tok_sigmaIetaIeta, pho_vmaps, full5x5.sigmaIetaIeta);
   assignValue(ptr, ph_conf.tok_e1x5, pho_vmaps, full5x5.e1x5);
   assignValue(ptr, ph_conf.tok_e2x5, pho_vmaps, full5x5.e2x5);
   assignValue(ptr, ph_conf.tok_e3x3, pho_vmaps, full5x5.e3x3);
   assignValue(ptr, ph_conf.tok_e5x5, pho_vmaps, full5x5.e5x5);
   assignValue(ptr, ph_conf.tok_maxEnergyXtal, pho_vmaps, full5x5.maxEnergyXtal);
   assignValue(ptr, ph_conf.tok_hcalDepth1OverEcal, pho_vmaps, full5x5.hcalDepth1OverEcal);
   assignValue(ptr, ph_conf.tok_hcalDepth2OverEcal, pho_vmaps, full5x5.hcalDepth2OverEcal);
   assignValue(ptr, ph_conf.tok_hcalDepth1OverEcalBc, pho_vmaps, full5x5.hcalDepth1OverEcalBc);
   assignValue(ptr, ph_conf.tok_hcalDepth2OverEcalBc, pho_vmaps, full5x5.hcalDepth2OverEcalBc);
  
   pho.full5x5_setShowerShapeVariables(full5x5);
   ++pho_idx;
 }

◆ setEvent()

void EGFull5x5ShowerShapeModifierFromValueMaps::setEvent ( const edm::Event & evt )

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 145 of file EGFull5x5ShowerShapeModifier.cc.

                                                                             {
   eles_by_oop.clear();
   phos_by_oop.clear();
   ele_vmaps.clear();
   pho_vmaps.clear();
  
   ele_idx = pho_idx = 0;
  
   if (!e_conf.tok_electron_src.isUninitialized()) {
     auto eles = evt.getHandle(e_conf.tok_electron_src);
  
     eles_by_oop.resize(eles->size());
     std::copy(eles->ptrs().begin(), eles->ptrs().end(), eles_by_oop.begin());
   }
  
   get_product(evt, e_conf.tok_sigmaEtaEta, ele_vmaps);
   get_product(evt, e_conf.tok_sigmaIetaIeta, ele_vmaps);
   get_product(evt, e_conf.tok_sigmaIphiIphi, ele_vmaps);
   get_product(evt, e_conf.tok_e1x5, ele_vmaps);
   get_product(evt, e_conf.tok_e2x5Max, ele_vmaps);
   get_product(evt, e_conf.tok_e5x5, ele_vmaps);
   get_product(evt, e_conf.tok_r9, ele_vmaps);
   get_product(evt, e_conf.tok_hcalDepth1OverEcal, ele_vmaps);
   get_product(evt, e_conf.tok_hcalDepth2OverEcal, ele_vmaps);
   get_product(evt, e_conf.tok_hcalDepth1OverEcalBc, ele_vmaps);
   get_product(evt, e_conf.tok_hcalDepth2OverEcalBc, ele_vmaps);
  
   if (!ph_conf.tok_photon_src.isUninitialized()) {
     auto phos = evt.getHandle(ph_conf.tok_photon_src);
  
     phos_by_oop.resize(phos->size());
     std::copy(phos->ptrs().begin(), phos->ptrs().end(), phos_by_oop.begin());
   }
  
   get_product(evt, ph_conf.tok_sigmaEtaEta, pho_vmaps);
   get_product(evt, ph_conf.tok_sigmaIetaIeta, pho_vmaps);
   get_product(evt, ph_conf.tok_e1x5, pho_vmaps);
   get_product(evt, ph_conf.tok_e2x5, pho_vmaps);
   get_product(evt, ph_conf.tok_e3x3, pho_vmaps);
   get_product(evt, ph_conf.tok_e5x5, pho_vmaps);
   get_product(evt, ph_conf.tok_maxEnergyXtal, pho_vmaps);
   get_product(evt, ph_conf.tok_hcalDepth1OverEcal, pho_vmaps);
   get_product(evt, ph_conf.tok_hcalDepth2OverEcal, pho_vmaps);
   get_product(evt, ph_conf.tok_hcalDepth1OverEcalBc, pho_vmaps);
   get_product(evt, ph_conf.tok_hcalDepth2OverEcalBc, pho_vmaps);
 }