#include <EGExtraInfoModifierFromValueMaps.h>

Inheritance diagram for EGExtraInfoModifierFromValueMaps< MapType, OutputType >:

Classes
struct	electron_config

struct	photon_config

Public Types
using	ValMapToken = edm::EDGetTokenT< edm::ValueMap< MapType > >

using	ValueMaps = std::unordered_map< std::string, ValMapToken >

Public Member Functions
	EGExtraInfoModifierFromValueMaps (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< MapType > > >	ele_vmaps

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

bool	overrideExistingValues_

photon_config	ph_conf

unsigned	pho_idx

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

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

Detailed Description

template<typename MapType, typename OutputType = MapType>
class EGExtraInfoModifierFromValueMaps< MapType, OutputType >

Definition at line 81 of file EGExtraInfoModifierFromValueMaps.h.

Member Typedef Documentation

◆ ValMapToken

template<typename MapType , typename OutputType = MapType>

using EGExtraInfoModifierFromValueMaps< MapType, OutputType >::ValMapToken = edm::EDGetTokenT<edm::ValueMap<MapType> >

Definition at line 83 of file EGExtraInfoModifierFromValueMaps.h.

◆ ValueMaps

template<typename MapType , typename OutputType = MapType>

using EGExtraInfoModifierFromValueMaps< MapType, OutputType >::ValueMaps = std::unordered_map<std::string, ValMapToken>

Definition at line 84 of file EGExtraInfoModifierFromValueMaps.h.

Constructor & Destructor Documentation

◆ EGExtraInfoModifierFromValueMaps()

template<typename MapType , typename OutputType >

EGExtraInfoModifierFromValueMaps< MapType, OutputType >::EGExtraInfoModifierFromValueMaps	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	cc
	)

Definition at line 115 of file EGExtraInfoModifierFromValueMaps.h.

     : ModifyObjectValueBase(conf) {
   constexpr char electronSrc[] = "electronSrc";
   constexpr char photonSrc[] = "photonSrc";
   overrideExistingValues_ =
       conf.exists("overrideExistingValues") ? conf.getParameter<bool>("overrideExistingValues") : false;
   if (conf.exists("electron_config")) {
     const edm::ParameterSet& electrons = conf.getParameter<edm::ParameterSet>("electron_config");
     if (electrons.exists(electronSrc))
       e_conf.tok_electron_src =
           cc.consumes<edm::View<pat::Electron>>(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.tok_valuemaps[name] = cc.consumes<edm::ValueMap<MapType>>(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.tok_photon_src = cc.consumes<edm::View<pat::Photon>>(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.tok_valuemaps[name] = cc.consumes<edm::ValueMap<MapType>>(photons.getParameter<edm::InputTag>(name));
       }
     }
   }
   ele_idx = pho_idx = 0;
 }

Member Function Documentation

◆ modifyObject() [1/2]

template<typename MapType , typename OutputType >

void EGExtraInfoModifierFromValueMaps< MapType, OutputType >::modifyObject ( pat::Electron & ele ) const

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 194 of file EGExtraInfoModifierFromValueMaps.h.

                                                                                                {
   // 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())
     ptr = eles_by_oop.at(ele_idx);
   //now we go through and modify the objects using the valuemaps we read in
   EGXtraModFromVMObjFiller<OutputType>::addValuesToObject(
       ele, ptr, e_conf.tok_valuemaps, ele_vmaps, overrideExistingValues_);
   ++ele_idx;
 }

References EGXtraModFromVMObjFiller< OutputType >::addValuesToObject(), and pat::PATObject< ObjectType >::originalObjectRef().

◆ modifyObject() [2/2]

template<typename MapType , typename OutputType >

void EGExtraInfoModifierFromValueMaps< MapType, OutputType >::modifyObject ( pat::Photon & pho ) const

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 208 of file EGExtraInfoModifierFromValueMaps.h.

                                                                                              {
   // 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())
     ptr = phos_by_oop.at(pho_idx);
   //now we go through and modify the objects using the valuemaps we read in
   EGXtraModFromVMObjFiller<OutputType>::addValuesToObject(
       pho, ptr, ph_conf.tok_valuemaps, pho_vmaps, overrideExistingValues_);
  
   ++pho_idx;
 }

References EGXtraModFromVMObjFiller< OutputType >::addValuesToObject(), and pat::PATObject< ObjectType >::originalObjectRef().

◆ setEvent()

template<typename MapType , typename OutputType >

void EGExtraInfoModifierFromValueMaps< MapType, OutputType >::setEvent ( const edm::Event & evt )

finalvirtual

Reimplemented from ModifyObjectValueBase.

Definition at line 154 of file EGExtraInfoModifierFromValueMaps.h.

                                                                                         {
   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);
  
     eles_by_oop.resize(eles->size());
     std::copy(eles->ptrs().begin(), eles->ptrs().end(), eles_by_oop.begin());
   }
  
   for (auto const& itr : e_conf.tok_valuemaps)
     evt.getByToken(itr.second, ele_vmaps[itr.second.index()]);
  
   if (!ph_conf.tok_photon_src.isUninitialized()) {
     edm::Handle<edm::View<pat::Photon>> phos;
     evt.getByToken(ph_conf.tok_photon_src, phos);
  
     phos_by_oop.resize(phos->size());
     std::copy(phos->ptrs().begin(), phos->ptrs().end(), phos_by_oop.begin());
   }
  
   for (auto const& itr : ph_conf.tok_valuemaps)
     evt.getByToken(itr.second, pho_vmaps[itr.second.index()]);
 }