Skip to content

Commit

Permalink
reduce copy/pasta in IsolationModifier
Browse files Browse the repository at this point in the history
  • Loading branch information
@lgray
lgray committed Aug 13, 2015
1 parent 6a6336a commit 6b8b134
Showing 1 changed file with 89 additions and 103 deletions.
192 changes: 89 additions & 103 deletions RecoEgamma/EgammaTools/plugins/EGPfIsolationModifier.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,55 +7,49 @@
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"

#include <tuple>
#include <array>

namespace {
const edm::EDGetTokenT<edm::ValueMap<float> > empty_token;
const static edm::InputTag empty_tag("");

const static std::array<std::string,7> electron_vars = { { "sumChargedHadronPt",
"sumNeutralHadronEt",
"sumPhotonEt",
"sumChargedParticlePt",
"sumNeutralHadronEtHighThreshold",
"sumPhotonEtHighThreshold",
"sumPUPt" } };

const static std::array<std::string,9> photon_vars = { { "chargedHadronIso",
"chargedHadronIsoWrongVtx",
"neutralHadronIso",
"photonIso",
"modFrixione",
"sumChargedParticlePt",
"sumNeutralHadronEtHighThreshold",
"sumPhotonEtHighThreshold",
"sumPUPt" } };
}

#include <unordered_map>

class EGPfIsolationModifierFromValueMaps : public ModifyObjectValueBase {
public:
typedef std::tuple<edm::InputTag,edm::EDGetTokenT<edm::ValueMap<float> > > tag_and_token;
typedef std::unordered_map<std::string,tag_and_token> input_map;

struct electron_config {
edm::InputTag electron_src;
edm::InputTag sumChargedHadronPt;
edm::InputTag sumNeutralHadronEt;
edm::InputTag sumPhotonEt;
edm::InputTag sumChargedParticlePt;
edm::InputTag sumNeutralHadronEtHighThreshold;
edm::InputTag sumPhotonEtHighThreshold;
edm::InputTag sumPUPt;
edm::InputTag electron_src;
edm::EDGetTokenT<edm::View<pat::Electron> > tok_electron_src;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumChargedHadronPt;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumNeutralHadronEt;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumPhotonEt;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumChargedParticlePt;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumNeutralHadronEtHighThreshold;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumPhotonEtHighThreshold;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumPUPt;
input_map electron_inputs;
};

struct photon_config {
edm::InputTag photon_src ;
edm::InputTag chargedHadronIso;
edm::InputTag chargedHadronIsoWrongVtx;
edm::InputTag neutralHadronIso;
edm::InputTag photonIso ;
edm::InputTag modFrixione ;
edm::InputTag sumChargedParticlePt;
edm::InputTag sumNeutralHadronEtHighThreshold;
edm::InputTag sumPhotonEtHighThreshold;
edm::InputTag sumPUPt;
edm::InputTag photon_src;
edm::EDGetTokenT<edm::View<pat::Photon> > tok_photon_src;
edm::EDGetTokenT<edm::ValueMap<float> > tok_chargedHadronIso;
edm::EDGetTokenT<edm::ValueMap<float> > tok_chargedHadronIsoWrongVtx;
edm::EDGetTokenT<edm::ValueMap<float> > tok_neutralHadronIso;
edm::EDGetTokenT<edm::ValueMap<float> > tok_photonIso ;
edm::EDGetTokenT<edm::ValueMap<float> > tok_modFrixione ;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumChargedParticlePt;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumNeutralHadronEtHighThreshold;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumPhotonEtHighThreshold;
edm::EDGetTokenT<edm::ValueMap<float> > tok_sumPUPt;
input_map photon_inputs;
};

EGPfIsolationModifierFromValueMaps(const edm::ParameterSet& conf);
Expand Down Expand Up @@ -87,27 +81,20 @@ EGPfIsolationModifierFromValueMaps(const edm::ParameterSet& 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("sumChargedHadronPt") ) e_conf.sumChargedHadronPt = electrons.getParameter<edm::InputTag>("sumChargedHadronPt");
if( electrons.exists("sumNeutralHadronEt") ) e_conf.sumNeutralHadronEt = electrons.getParameter<edm::InputTag>("sumNeutralHadronPt");
if( electrons.exists("sumPhotonEt") ) e_conf.sumPhotonEt = electrons.getParameter<edm::InputTag>("sumPhotonEt");
if( electrons.exists("sumChargedParticlePt") ) e_conf.sumChargedParticlePt = electrons.getParameter<edm::InputTag>("sumChargedParticlePt");
if( electrons.exists("sumNeutralHadronEtHighThreshold") ) e_conf.sumNeutralHadronEtHighThreshold = electrons.getParameter<edm::InputTag>("sumNeutralHadronEtHighThreshold");
if( electrons.exists("sumPhotonEtHighThreshold") ) e_conf.sumPhotonEtHighThreshold = electrons.getParameter<edm::InputTag>("sumPhotonEtHighThreshold");
if( electrons.exists("sumPUPt") ) e_conf.sumPUPt = electrons.getParameter<edm::InputTag>("sumPUPt");
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");
if( photons.exists("chargedHadronIso") ) ph_conf.chargedHadronIso = photons.getParameter<edm::InputTag>("chargedHadronIso");
if( photons.exists("chargedHadronIsoWrongVtx") ) ph_conf.chargedHadronIsoWrongVtx = photons.getParameter<edm::InputTag>("chargedHadronIsoWrongVtx");
if( photons.exists("neutralHadronIso") ) ph_conf.neutralHadronIso = photons.getParameter<edm::InputTag>("neutralHadronIso");
if( photons.exists("photonIso") ) ph_conf.photonIso = photons.getParameter<edm::InputTag>("photonIso");
if( photons.exists("modFrixione") ) ph_conf.modFrixione = photons.getParameter<edm::InputTag>("modFrixione");
if( photons.exists("sumChargedParticlePt") ) ph_conf.sumChargedParticlePt = photons.getParameter<edm::InputTag>("sumChargedParticlePt");
if( photons.exists("sumNeutralHadronEtHighThreshold") ) ph_conf.sumNeutralHadronEtHighThreshold = photons.getParameter<edm::InputTag>("sumNeutralHadronEtHighThreshold");
if( photons.exists("sumPhotonEtHighThreshold") ) ph_conf.sumPhotonEtHighThreshold = photons.getParameter<edm::InputTag>("sumPhotonEtHighThreshold");
if( photons.exists("sumPUPt") ) ph_conf.sumPUPt = photons.getParameter<edm::InputTag>("sumPUPt");

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;
Expand Down Expand Up @@ -138,14 +125,11 @@ setEvent(const edm::Event& evt) {
}
}

get_product(evt,e_conf.tok_sumChargedHadronPt,ele_vmaps);
get_product(evt,e_conf.tok_sumNeutralHadronEt,ele_vmaps);
get_product(evt,e_conf.tok_sumPhotonEt,ele_vmaps);
get_product(evt,e_conf.tok_sumChargedParticlePt,ele_vmaps);
get_product(evt,e_conf.tok_sumNeutralHadronEtHighThreshold,ele_vmaps);
get_product(evt,e_conf.tok_sumPhotonEtHighThreshold,ele_vmaps);
get_product(evt,e_conf.tok_sumPUPt,ele_vmaps);

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;
Expand All @@ -157,15 +141,11 @@ setEvent(const edm::Event& evt) {
}
}

get_product(evt,ph_conf.tok_chargedHadronIso,pho_vmaps);
get_product(evt,ph_conf.tok_chargedHadronIsoWrongVtx,pho_vmaps);
get_product(evt,ph_conf.tok_neutralHadronIso,pho_vmaps);
get_product(evt,ph_conf.tok_photonIso,pho_vmaps);
get_product(evt,ph_conf.tok_modFrixione,pho_vmaps);
get_product(evt,ph_conf.tok_sumChargedParticlePt,pho_vmaps);
get_product(evt,ph_conf.tok_sumNeutralHadronEtHighThreshold,pho_vmaps);
get_product(evt,ph_conf.tok_sumPhotonEtHighThreshold,pho_vmaps);
get_product(evt,ph_conf.tok_sumPUPt,pho_vmaps);
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);
}
}

void EGPfIsolationModifierFromValueMaps::
Expand All @@ -179,29 +159,30 @@ void EGPfIsolationModifierFromValueMaps::
setConsumes(edm::ConsumesCollector& sumes) {
//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.sumChargedHadronPt,e_conf.tok_sumChargedHadronPt,sumes);
make_consumes(e_conf.sumNeutralHadronEt,e_conf.tok_sumNeutralHadronEt,sumes);
make_consumes(e_conf.sumPhotonEt,e_conf.tok_sumPhotonEt,sumes);
make_consumes(e_conf.sumChargedParticlePt,e_conf.tok_sumChargedParticlePt,sumes);
make_consumes(e_conf.sumNeutralHadronEtHighThreshold,e_conf.tok_sumNeutralHadronEtHighThreshold,sumes);
make_consumes(e_conf.sumPhotonEtHighThreshold,e_conf.tok_sumPhotonEtHighThreshold,sumes);
make_consumes(e_conf.sumPUPt,e_conf.tok_sumPUPt,sumes);

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);
make_consumes(ph_conf.chargedHadronIso,ph_conf.tok_chargedHadronIso,sumes);
make_consumes(ph_conf.chargedHadronIsoWrongVtx,ph_conf.tok_chargedHadronIsoWrongVtx,sumes);
make_consumes(ph_conf.neutralHadronIso,ph_conf.tok_neutralHadronIso,sumes);
make_consumes(ph_conf.photonIso,ph_conf.tok_photonIso,sumes);
make_consumes(ph_conf.modFrixione,ph_conf.tok_modFrixione,sumes);
make_consumes(ph_conf.sumChargedParticlePt,ph_conf.tok_sumChargedParticlePt,sumes);
make_consumes(ph_conf.sumNeutralHadronEtHighThreshold,ph_conf.tok_sumNeutralHadronEtHighThreshold,sumes);
make_consumes(ph_conf.sumPhotonEtHighThreshold,ph_conf.tok_sumPhotonEtHighThreshold,sumes);
make_consumes(ph_conf.sumPUPt,ph_conf.tok_sumPUPt,sumes);

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);
}
}

template<typename T, typename U, typename V>
inline void assignValue(const T& ptr, const U& tok, const V& map, float& value) {
inline void assignValue(const T& ptr, const U& input_map, const std::string& name, const V& map, float& value) {
auto itr = input_map.find(name);
if( itr == input_map.end() ) return;
const auto& tok = std::get<1>(itr->second);
if( !tok.isUninitialized() ) value = map.find(tok.index())->second->get(ptr.id(),ptr.key());
}

Expand All @@ -223,13 +204,15 @@ modifyObject(pat::Electron& ele) const {
//now we go through and modify the objects using the valuemaps we read in
auto pfIso = ele.pfIsolationVariables();

assignValue(ptr,e_conf.tok_sumChargedHadronPt,ele_vmaps,pfIso.sumChargedHadronPt);
assignValue(ptr,e_conf.tok_sumNeutralHadronEt,ele_vmaps,pfIso.sumNeutralHadronEt);
assignValue(ptr,e_conf.tok_sumPhotonEt,ele_vmaps,pfIso.sumPhotonEt);
assignValue(ptr,e_conf.tok_sumChargedParticlePt,ele_vmaps,pfIso.sumChargedParticlePt);
assignValue(ptr,e_conf.tok_sumNeutralHadronEtHighThreshold,ele_vmaps,pfIso.sumNeutralHadronEtHighThreshold);
assignValue(ptr,e_conf.tok_sumPhotonEtHighThreshold,ele_vmaps,pfIso.sumPhotonEtHighThreshold);
assignValue(ptr,e_conf.tok_sumPUPt,ele_vmaps,pfIso.sumPUPt);
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;
Expand All @@ -254,15 +237,18 @@ modifyObject(pat::Photon& pho) const {

//now we go through and modify the objects using the valuemaps we read in
auto pfIso = pho.getPflowIsolationVariables();
assignValue(ptr,ph_conf.tok_chargedHadronIso,pho_vmaps,pfIso.chargedHadronIso);
assignValue(ptr,ph_conf.tok_chargedHadronIsoWrongVtx,pho_vmaps,pfIso.chargedHadronIsoWrongVtx);
assignValue(ptr,ph_conf.tok_neutralHadronIso,pho_vmaps,pfIso.neutralHadronIso);
assignValue(ptr,ph_conf.tok_photonIso,pho_vmaps,pfIso.photonIso);
assignValue(ptr,ph_conf.tok_modFrixione,pho_vmaps,pfIso.modFrixione);
assignValue(ptr,ph_conf.tok_sumChargedParticlePt,pho_vmaps,pfIso.sumChargedParticlePt);
assignValue(ptr,ph_conf.tok_sumNeutralHadronEtHighThreshold,pho_vmaps,pfIso.sumNeutralHadronEtHighThreshold);
assignValue(ptr,ph_conf.tok_sumPhotonEtHighThreshold,pho_vmaps,pfIso.sumPhotonEtHighThreshold);
assignValue(ptr,ph_conf.tok_sumPUPt,pho_vmaps,pfIso.sumPUPt);

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;
Expand Down

0 comments on commit 6b8b134

Please sign in to comment.