Inheritance diagram for EGPfIsolationModifierFromValueMaps:

Classes
struct	electron_config

struct	photon_config

Public Types
typedef std::unordered_map< std::string, tag_and_token >	input_map

typedef std::tuple< edm::InputTag, edm::EDGetTokenT< edm::ValueMap< float > > >	tag_and_token

Public Member Functions
	EGPfIsolationModifierFromValueMaps (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 38 of file EGPfIsolationModifier.cc.

Member Typedef Documentation

typedef std::unordered_map<std::string,tag_and_token> EGPfIsolationModifierFromValueMaps::input_map

Definition at line 41 of file EGPfIsolationModifier.cc.

typedef std::tuple<edm::InputTag,edm::EDGetTokenT<edm::ValueMap<float> > > EGPfIsolationModifierFromValueMaps::tag_and_token

Definition at line 40 of file EGPfIsolationModifier.cc.

Constructor & Destructor Documentation

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

Definition at line 79 of file EGPfIsolationModifier.cc.

References EGPfIsolationModifierFromValueMaps::electron_config::electron_inputs, EGPfIsolationModifierFromValueMaps::electron_config::electron_src, nano_cff::electrons, edm::ParameterSet::exists(), edm::Event::getByToken(), edm::ParameterSet::getParameter(), genParticles_cff::map, EGPfIsolationModifierFromValueMaps::photon_config::photon_inputs, EGPfIsolationModifierFromValueMaps::photon_config::photon_src, muons_cff::photons, setEvent(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 :
   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");
     for( const std::string& varname : electron_vars ) {
       if( electrons.exists(varname) ) {
         std::get<0>(e_conf.electron_inputs[varname]) = electrons.getParameter<edm::InputTag>(varname);
       }
     }      
   }
   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");  
     for( const std::string& varname : photon_vars ) {
       if( photons.exists(varname) ) {
         std::get<0>(ph_conf.photon_inputs[varname]) = photons.getParameter<edm::InputTag>(varname);
       }
     }     
   }
   
   ele_idx = pho_idx = 0;
 }

Member Function Documentation

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 196 of file EGPfIsolationModifier.cc.

References e_conf, ele_idx, ele_vmaps, EGPfIsolationModifierFromValueMaps::electron_config::electron_inputs, eles_by_oop, Exception, edm::EDGetTokenT< T >::isUninitialized(), crabWrapper::key, edm::Ptr< T >::key(), pat::PATObject< ObjectType >::originalObjectRef(), reco::GsfElectron::pfIsolationVariables(), reco::GsfElectron::setPfIsolationVariables(), and EGPfIsolationModifierFromValueMaps::electron_config::tok_electron_src.

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 pfIso = ele.pfIsolationVariables();
     
   const auto& e_inputs = e_conf.electron_inputs;
 
   assignValue(ptr,e_inputs,electron_vars[0],ele_vmaps,pfIso.sumChargedHadronPt);
   assignValue(ptr,e_inputs,electron_vars[1],ele_vmaps,pfIso.sumNeutralHadronEt);
   assignValue(ptr,e_inputs,electron_vars[2],ele_vmaps,pfIso.sumPhotonEt);
   assignValue(ptr,e_inputs,electron_vars[3],ele_vmaps,pfIso.sumChargedParticlePt);
   assignValue(ptr,e_inputs,electron_vars[4],ele_vmaps,pfIso.sumNeutralHadronEtHighThreshold);
   assignValue(ptr,e_inputs,electron_vars[5],ele_vmaps,pfIso.sumPhotonEtHighThreshold);
   assignValue(ptr,e_inputs,electron_vars[6],ele_vmaps,pfIso.sumPUPt);
   
   ele.setPfIsolationVariables(pfIso);
   ++ele_idx;
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 229 of file EGPfIsolationModifier.cc.

References Exception, reco::Photon::getPflowIsolationVariables(), edm::EDGetTokenT< T >::isUninitialized(), crabWrapper::key, edm::Ptr< T >::key(), pat::PATObject< ObjectType >::originalObjectRef(), ph_conf, pho_idx, pho_vmaps, phos_by_oop, EGPfIsolationModifierFromValueMaps::photon_config::photon_inputs, reco::Photon::setPflowIsolationVariables(), and EGPfIsolationModifierFromValueMaps::photon_config::tok_photon_src.

                                    {
   // 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 pfIso = pho.getPflowIsolationVariables();
 
   const auto& ph_inputs = ph_conf.photon_inputs;
 
   assignValue(ptr,ph_inputs,photon_vars[0],pho_vmaps,pfIso.chargedHadronIso);
   assignValue(ptr,ph_inputs,photon_vars[1],pho_vmaps,pfIso.chargedHadronIsoWrongVtx);
   assignValue(ptr,ph_inputs,photon_vars[2],pho_vmaps,pfIso.neutralHadronIso);
   assignValue(ptr,ph_inputs,photon_vars[3],pho_vmaps,pfIso.photonIso);
   assignValue(ptr,ph_inputs,photon_vars[4],pho_vmaps,pfIso.modFrixione);
   assignValue(ptr,ph_inputs,photon_vars[5],pho_vmaps,pfIso.sumChargedParticlePt);
   assignValue(ptr,ph_inputs,photon_vars[6],pho_vmaps,pfIso.sumNeutralHadronEtHighThreshold);
   assignValue(ptr,ph_inputs,photon_vars[7],pho_vmaps,pfIso.sumPhotonEtHighThreshold);
   assignValue(ptr,ph_inputs,photon_vars[8],pho_vmaps,pfIso.sumPUPt);
   
   pho.setPflowIsolationVariables(pfIso);
   ++pho_idx;
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 163 of file EGPfIsolationModifier.cc.

References edm::ConsumesCollector::consumes(), e_conf, EGPfIsolationModifierFromValueMaps::electron_config::electron_inputs, EGPfIsolationModifierFromValueMaps::electron_config::electron_src, PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, genParticles_cff::map, modifyObject(), ModifyObjectValueBase::name(), ph_conf, EGPfIsolationModifierFromValueMaps::photon_config::photon_inputs, EGPfIsolationModifierFromValueMaps::photon_config::photon_src, edm::second(), AlCaHLTBitMon_QueryRunRegistry::string, EGPfIsolationModifierFromValueMaps::electron_config::tok_electron_src, EGPfIsolationModifierFromValueMaps::photon_config::tok_photon_src, and mitigatedMETSequence_cff::U.

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);  
   
   for( const std::string& varname : electron_vars ) {
     auto& inputs = e_conf.electron_inputs;
     if( inputs.find(varname) == inputs.end() ) continue;
     auto& the_tuple = inputs[varname];
     make_consumes(std::get<0>(the_tuple),std::get<1>(the_tuple),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);
 
   for( const std::string& varname : photon_vars ) {
     auto& inputs = ph_conf.photon_inputs;
     if( inputs.find(varname) == inputs.end() ) continue;
     auto& the_tuple = inputs[varname];
     make_consumes(std::get<0>(the_tuple),std::get<1>(the_tuple),sumes);
   }   
 }

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

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 112 of file EGPfIsolationModifier.cc.

References e_conf, ele_idx, ele_vmaps, EGPfIsolationModifierFromValueMaps::electron_config::electron_inputs, eles_by_oop, edm::Event::getByToken(), mps_fire::i, PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, edm::EDGetTokenT< T >::isUninitialized(), ph_conf, pho_idx, pho_vmaps, phos_by_oop, EGPfIsolationModifierFromValueMaps::photon_config::photon_inputs, setEventContent(), AlCaHLTBitMon_QueryRunRegistry::string, EGPfIsolationModifierFromValueMaps::electron_config::tok_electron_src, and EGPfIsolationModifierFromValueMaps::photon_config::tok_photon_src.

Referenced by EGPfIsolationModifierFromValueMaps().

                               {
   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;
     }
   }
 
   for( const std::string& varname : electron_vars ) {
     auto& inputs = e_conf.electron_inputs;
     if( inputs.find(varname) == inputs.end() ) continue;
     get_product(evt,std::get<1>(inputs[varname]),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;
     }
   }
   
   for( const std::string& varname : photon_vars ) {
     auto& inputs = ph_conf.photon_inputs;
     if( inputs.find(varname) == inputs.end() ) continue;
     get_product(evt,std::get<1>(inputs[varname]),pho_vmaps);
   }   
 }