Inheritance diagram for EGExtraInfoModifierFromFloatValueMaps:

Classes
struct	electron_config

struct	photon_config

Public Types
typedef edm::EDGetTokenT < edm::ValueMap< float > >	ValMapFloatToken

typedef std::unordered_map < std::string, ValMapFloatToken >	ValueMaps

typedef std::unordered_map < std::string, edm::InputTag >	ValueMapsTags

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

void	modifyObject (pat::Electron &) const overridefinal

void	modifyObject (pat::Photon &) const overridefinal

void	setConsumes (edm::ConsumesCollector &) overridefinal

void	setEvent (const edm::Event &) overridefinal

void	setEventContent (const edm::EventSetup &) overridefinal

Public Member Functions inherited from ModifyObjectValueBase
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 EGExtraInfoModifierFromFloatValueMaps.cc.

Member Typedef Documentation

typedef edm::EDGetTokenT<edm::ValueMap<float> > EGExtraInfoModifierFromFloatValueMaps::ValMapFloatToken

Definition at line 19 of file EGExtraInfoModifierFromFloatValueMaps.cc.

typedef std::unordered_map<std::string,ValMapFloatToken> EGExtraInfoModifierFromFloatValueMaps::ValueMaps

Definition at line 20 of file EGExtraInfoModifierFromFloatValueMaps.cc.

typedef std::unordered_map<std::string,edm::InputTag> EGExtraInfoModifierFromFloatValueMaps::ValueMapsTags

Definition at line 21 of file EGExtraInfoModifierFromFloatValueMaps.cc.

Constructor & Destructor Documentation

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

Definition at line 60 of file EGExtraInfoModifierFromFloatValueMaps.cc.

References constexpr, EGExtraInfoModifierFromFloatValueMaps::electron_config::electron_src, HI_PhotonSkim_cff::electrons, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), ModifyObjectValueBase::name(), Parameters::parameters, EGExtraInfoModifierFromFloatValueMaps::photon_config::photon_src, interactiveExample::photons, AlCaHLTBitMon_QueryRunRegistry::string, EGExtraInfoModifierFromFloatValueMaps::electron_config::valuemaps, and EGExtraInfoModifierFromFloatValueMaps::photon_config::valuemaps.

                                                                    :
   ModifyObjectValueBase(conf) {
   constexpr char electronSrc[] =  "electronSrc";
   constexpr char photonSrc[] =  "photonSrc";
 
   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);
     const std::vector<std::string> parameters = electrons.getParameterNames();
     for( const std::string& name : parameters ) {
       if( std::string(electronSrc) == name ) continue;
       if( electrons.existsAs<edm::InputTag>(name) ) {
         e_conf.valuemaps[name] = electrons.getParameter<edm::InputTag>(name);
       }
     }    
   }
   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);
     const std::vector<std::string> parameters = photons.getParameterNames();
     for( const std::string& name : parameters ) {
       if( std::string(photonSrc) == name ) continue;
       if( photons.existsAs<edm::InputTag>(name) ) {
         ph_conf.valuemaps[name] = photons.getParameter<edm::InputTag>(name);
       }
     } 
   }
   ele_idx = pho_idx = 0;
 }

Member Function Documentation

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

finaloverridevirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 164 of file EGExtraInfoModifierFromFloatValueMaps.cc.

References pat::PATObject< ObjectType >::addUserFloat(), assignValue(), e_conf, ele_idx, ele_vmaps, eles_by_oop, edm::hlt::Exception, pat::PATObject< ObjectType >::hasUserFloat(), edm::EDGetTokenT< T >::isUninitialized(), edm::Ptr< T >::key(), relval_steps::key, pat::PATObject< ObjectType >::originalObjectRef(), EGExtraInfoModifierFromFloatValueMaps::electron_config::tok_electron_src, EGExtraInfoModifierFromFloatValueMaps::electron_config::tok_valuemaps, and relativeConstraints::value.

                                      {
   // 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
   for( auto itr = e_conf.tok_valuemaps.begin(); itr != e_conf.tok_valuemaps.end(); ++itr ) {
     float value(0.0);
     assignValue(ptr,itr->second,ele_vmaps,value);
     if( !ele.hasUserFloat(itr->first) ) {
       ele.addUserFloat(itr->first,value);
     } else {
       throw cms::Exception("ValueNameAlreadyExists")
         << "Trying to add new UserFloat = " << itr->first
         << " failed because it already exists!";
     }
   }  
   ++ele_idx;
 }

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

finaloverridevirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 195 of file EGExtraInfoModifierFromFloatValueMaps.cc.

References pat::PATObject< ObjectType >::addUserFloat(), assignValue(), edm::hlt::Exception, pat::PATObject< ObjectType >::hasUserFloat(), edm::EDGetTokenT< T >::isUninitialized(), edm::Ptr< T >::key(), relval_steps::key, pat::PATObject< ObjectType >::originalObjectRef(), ph_conf, pho_idx, pho_vmaps, phos_by_oop, EGExtraInfoModifierFromFloatValueMaps::photon_config::tok_photon_src, EGExtraInfoModifierFromFloatValueMaps::photon_config::tok_valuemaps, and relativeConstraints::value.

                                    {
   // 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
   for( auto itr = ph_conf.tok_valuemaps.begin(); itr != ph_conf.tok_valuemaps.end(); ++itr ) {
     float value(0.0);
     assignValue(ptr,itr->second,pho_vmaps,value);
     if( !pho.hasUserFloat(itr->first) ) {
       pho.addUserFloat(itr->first,value);
     } else {
       throw cms::Exception("ValueNameAlreadyExists")
         << "Trying to add new UserFloat = " << itr->first
         << " failed because it already exists!";
     }
   }    
   ++pho_idx;
 }

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

finaloverridevirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 142 of file EGExtraInfoModifierFromFloatValueMaps.cc.

                                          {
   //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( auto itr = e_conf.valuemaps.begin(); itr != e_conf.valuemaps.end(); ++itr ) {
     make_consumes(itr->second,e_conf.tok_valuemaps[itr->first],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( auto itr = ph_conf.valuemaps.begin(); itr != ph_conf.valuemaps.end(); ++itr ) {
     make_consumes(itr->second,ph_conf.tok_valuemaps[itr->first],sumes);
   }
 }

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

finaloverridevirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 97 of file EGExtraInfoModifierFromFloatValueMaps.cc.

References e_conf, ele_idx, ele_vmaps, eles_by_oop, get_product(), edm::Event::getByToken(), i, edm::EDGetTokenT< T >::isUninitialized(), ph_conf, pho_idx, pho_vmaps, phos_by_oop, EGExtraInfoModifierFromFloatValueMaps::electron_config::tok_electron_src, EGExtraInfoModifierFromFloatValueMaps::photon_config::tok_photon_src, EGExtraInfoModifierFromFloatValueMaps::electron_config::tok_valuemaps, and EGExtraInfoModifierFromFloatValueMaps::photon_config::tok_valuemaps.

                               {
   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( auto itr = e_conf.tok_valuemaps.begin(); itr != e_conf.tok_valuemaps.end(); ++itr ) {
     get_product(evt,itr->second,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( auto itr = ph_conf.tok_valuemaps.begin(); itr != ph_conf.tok_valuemaps.end(); ++itr ) {
     get_product(evt,itr->second,pho_vmaps);
   }
 }