Inheritance diagram for EGFull5x5ShowerShapeModifierFromValueMaps:

Classes
struct	electron_config

struct	photon_config

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

void	modifyObject (pat::Electron &) const final

void	modifyObject (pat::Photon &) const final

void	setConsumes (edm::ConsumesCollector &) final

void	setEvent (const edm::Event &) final

void	setEventContent (const edm::EventSetup &) final

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 Attributes
electron_config	e_conf

unsigned	ele_idx

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

std::unordered_map< unsigned, 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::unordered_map< unsigned, edm::Ptr< reco::Photon > >	phos_by_oop

Detailed Description

Definition at line 17 of file EGFull5x5ShowerShapeModifier.cc.

Constructor & Destructor Documentation

EGFull5x5ShowerShapeModifierFromValueMaps::EGFull5x5ShowerShapeModifierFromValueMaps ( const edm::ParameterSet & conf )

Definition at line 97 of file EGFull5x5ShowerShapeModifier.cc.

                                                                        :
   ModifyObjectValueBase(conf) {
   if( conf.exists("electron_config") ) {
     const edm::ParameterSet& electrons = conf.getParameter<edm::ParameterSet>("electron_config");
     if( electrons.exists("electronSrc") ) e_conf.electron_src = electrons.getParameter<edm::InputTag>("electronSrc");
     if( electrons.exists("sigmaEtaEta") ) e_conf.sigmaEtaEta = electrons.getParameter<edm::InputTag>("sigmaEtaEta");
     if( electrons.exists("sigmaIetaIeta") ) e_conf.sigmaIetaIeta = electrons.getParameter<edm::InputTag>("sigmaIetaIeta");
     if( electrons.exists("sigmaIphiIphi") ) e_conf.sigmaIphiIphi = electrons.getParameter<edm::InputTag>("sigmaIphiIphi");
     if( electrons.exists("e1x5") ) e_conf.e1x5 = electrons.getParameter<edm::InputTag>("e1x5");
     if( electrons.exists("e2x5Max") ) e_conf.e2x5Max = electrons.getParameter<edm::InputTag>("e2x5Max");
     if( electrons.exists("e5x5") ) e_conf.e5x5 = electrons.getParameter<edm::InputTag>("e5x5");
     if( electrons.exists("r9") ) e_conf.r9 = electrons.getParameter<edm::InputTag>("r9");
     if( electrons.exists("hcalDepth1OverEcal") ) e_conf.hcalDepth1OverEcal = electrons.getParameter<edm::InputTag>("hcalDepth1OverEcal");
     if( electrons.exists("hcalDepth2OverEcal") ) e_conf.hcalDepth2OverEcal = electrons.getParameter<edm::InputTag>("hcalDepth2OverEcal");
     if( electrons.exists("hcalDepth1OverEcalBc") ) e_conf.hcalDepth1OverEcalBc = electrons.getParameter<edm::InputTag>("hcalDepth1OverEcalBc");
     if( electrons.exists("hcalDepth2OverEcalBc") ) e_conf.hcalDepth2OverEcalBc = electrons.getParameter<edm::InputTag>("hcalDepth2OverEcalBc");
   }
   if( conf.exists("photon_config") ) {
     const edm::ParameterSet& photons = conf.getParameter<edm::ParameterSet>("photon_config");
     if( photons.exists("photonSrc") ) ph_conf.photon_src = photons.getParameter<edm::InputTag>("photonSrc");
     if( photons.exists("sigmaEtaEta") ) ph_conf.sigmaEtaEta = photons.getParameter<edm::InputTag>("sigmaEtaEta");
     if( photons.exists("sigmaIetaIeta") ) ph_conf.sigmaIetaIeta = photons.getParameter<edm::InputTag>("sigmaIetaIeta");
     if( photons.exists("e1x5") ) ph_conf.e1x5 = photons.getParameter<edm::InputTag>("e1x5");
     if( photons.exists("e2x5") ) ph_conf.e2x5 = photons.getParameter<edm::InputTag>("e2x5");
     if( photons.exists("e3x3") ) ph_conf.e3x3 = photons.getParameter<edm::InputTag>("e3x3");
     if( photons.exists("e5x5") ) ph_conf.e5x5 = photons.getParameter<edm::InputTag>("e5x5");
     if( photons.exists("maxEnergyXtal") ) ph_conf.maxEnergyXtal = photons.getParameter<edm::InputTag>("maxEnergyXtal");
     if( photons.exists("hcalDepth1OverEcal") ) ph_conf.hcalDepth1OverEcal = photons.getParameter<edm::InputTag>("hcalDepth1OverEcal");
     if( photons.exists("hcalDepth2OverEcal") ) ph_conf.hcalDepth2OverEcal = photons.getParameter<edm::InputTag>("hcalDepth2OverEcal");
     if( photons.exists("hcalDepth1OverEcalBc") ) ph_conf.hcalDepth1OverEcalBc = photons.getParameter<edm::InputTag>("hcalDepth1OverEcalBc");
     if( photons.exists("hcalDepth2OverEcalBc") ) ph_conf.hcalDepth2OverEcalBc = photons.getParameter<edm::InputTag>("hcalDepth2OverEcalBc");
   }
   
   ele_idx = pho_idx = 0;
 }

Member Function Documentation

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 244 of file EGFull5x5ShowerShapeModifier.cc.

Referenced by setConsumes().

                                      {
   // 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());
   if( !e_conf.tok_electron_src.isUninitialized() ) {
     auto key = eles_by_oop.find(ele_idx);
     if( key != eles_by_oop.end() ) {
       ptr = key->second;
     } else {
       throw cms::Exception("BadElectronKey")
         << "Original object pointer with key = " << ele.originalObjectRef().key() << " not found in cache!";
     }
   }
   //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;
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 278 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());
   if( !ph_conf.tok_photon_src.isUninitialized() ) {
     auto key = phos_by_oop.find(pho_idx);
     if( key != phos_by_oop.end() ) {
       ptr = key->second;
     } else {
       throw cms::Exception("BadPhotonKey")
         << "Original object pointer with key = " << pho.originalObjectRef().key() << " not found in cache!";
     }
   }
   //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;
 }

void EGFull5x5ShowerShapeModifierFromValueMaps::setConsumes ( edm::ConsumesCollector & sumes )

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 206 of file EGFull5x5ShowerShapeModifier.cc.

Referenced by setEventContent().

                                          {
   //setup electrons
   if( !(empty_tag == e_conf.electron_src) ) e_conf.tok_electron_src = sumes.consumes<edm::View<pat::Electron> >(e_conf.electron_src);  
   make_consumes(e_conf.sigmaEtaEta,e_conf.tok_sigmaEtaEta,sumes);
   make_consumes(e_conf.sigmaIetaIeta,e_conf.tok_sigmaIetaIeta,sumes);
   make_consumes(e_conf.sigmaIphiIphi,e_conf.tok_sigmaIphiIphi,sumes);
   make_consumes(e_conf.e1x5,e_conf.tok_e1x5,sumes);
   make_consumes(e_conf.e2x5Max,e_conf.tok_e2x5Max,sumes);
   make_consumes(e_conf.e5x5,e_conf.tok_e5x5,sumes);
   make_consumes(e_conf.r9,e_conf.tok_r9,sumes);
   make_consumes(e_conf.hcalDepth1OverEcal,e_conf.tok_hcalDepth1OverEcal,sumes);
   make_consumes(e_conf.hcalDepth2OverEcal,e_conf.tok_hcalDepth2OverEcal,sumes);
   make_consumes(e_conf.hcalDepth1OverEcalBc,e_conf.tok_hcalDepth1OverEcalBc,sumes);
   make_consumes(e_conf.hcalDepth2OverEcalBc,e_conf.tok_hcalDepth2OverEcalBc,sumes);    
 
   // setup photons 
   if( !(empty_tag == ph_conf.photon_src) ) ph_conf.tok_photon_src = sumes.consumes<edm::View<pat::Photon> >(ph_conf.photon_src);
   make_consumes(ph_conf.sigmaEtaEta,ph_conf.tok_sigmaEtaEta,sumes);
   make_consumes(ph_conf.sigmaIetaIeta,ph_conf.tok_sigmaIetaIeta,sumes);
   make_consumes(ph_conf.e1x5,ph_conf.tok_e1x5,sumes);
   make_consumes(ph_conf.e2x5,ph_conf.tok_e2x5,sumes);
   make_consumes(ph_conf.e3x3,ph_conf.tok_e3x3,sumes);
   make_consumes(ph_conf.e5x5,ph_conf.tok_e5x5,sumes);
   make_consumes(ph_conf.maxEnergyXtal,ph_conf.tok_maxEnergyXtal,sumes);
   make_consumes(ph_conf.hcalDepth1OverEcal,ph_conf.tok_hcalDepth1OverEcal,sumes);
   make_consumes(ph_conf.hcalDepth2OverEcal,ph_conf.tok_hcalDepth2OverEcal,sumes);
   make_consumes(ph_conf.hcalDepth1OverEcalBc,ph_conf.tok_hcalDepth1OverEcalBc,sumes);
   make_consumes(ph_conf.hcalDepth2OverEcalBc,ph_conf.tok_hcalDepth2OverEcalBc,sumes);   
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 142 of file EGFull5x5ShowerShapeModifier.cc.

Referenced by EGFull5x5ShowerShapeModifierFromValueMaps().

                               {
   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() ) {
     edm::Handle<edm::View<pat::Electron> > eles;
     evt.getByToken(e_conf.tok_electron_src,eles);
     
     for( unsigned i = 0; i < eles->size(); ++i ) {
       edm::Ptr<pat::Electron> ptr = eles->ptrAt(i);
       eles_by_oop[i] = ptr;
     }
   }
 
   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() ) {
     edm::Handle<edm::View<pat::Photon> > phos;
     evt.getByToken(ph_conf.tok_photon_src,phos);
 
     for( unsigned i = 0; i < phos->size(); ++i ) {
       edm::Ptr<pat::Photon> ptr = phos->ptrAt(i);
       phos_by_oop[i] = ptr;
     }
   }
 
   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);
 
 }