CMS 3D CMS Logo
IsoValueMapProducer.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: PhysicsTools/NanoAOD
4 // Class: IsoValueMapProducer
5 //
13 //
14 // Original Author: Marco Peruzzi
15 // Created: Mon, 04 Sep 2017 22:43:53 GMT
16 //
17 //
18 
19 // system include files
20 #include <memory>
21 
22 // user include files
23 #include "FWCore/Framework/interface/Frameworkfwd.h"
24 #include "FWCore/Framework/interface/global/EDProducer.h"
25 
26 #include "FWCore/Framework/interface/Event.h"
27 #include "FWCore/Framework/interface/MakerMacros.h"
28 
29 #include "FWCore/ParameterSet/interface/ParameterSet.h"
30 #include "FWCore/Utilities/interface/StreamID.h"
31 
32 #include "CommonTools/Egamma/interface/EffectiveAreas.h"
33 
34 #include "DataFormats/PatCandidates/interface/Muon.h"
35 #include "DataFormats/PatCandidates/interface/Electron.h"
36 #include "DataFormats/PatCandidates/interface/Photon.h"
37 #include "DataFormats/PatCandidates/interface/IsolatedTrack.h"
38 
39 //
40 // class declaration
41 //
42 
43 template <typename T>
44 class IsoValueMapProducer : public edm::global::EDProducer<> {
45 public:
46  explicit IsoValueMapProducer(const edm::ParameterSet& iConfig)
47  : src_(consumes<edm::View<T>>(iConfig.getParameter<edm::InputTag>("src"))),
48  relative_(iConfig.getParameter<bool>("relative")) {
49  if ((typeid(T) == typeid(pat::Muon)) || (typeid(T) == typeid(pat::Electron)) ||
50  typeid(T) == typeid(pat::IsolatedTrack)) {
51  produces<edm::ValueMap<float>>("miniIsoChg");
52  produces<edm::ValueMap<float>>("miniIsoAll");
53  ea_miniiso_ =
54  std::make_unique<EffectiveAreas>((iConfig.getParameter<edm::FileInPath>("EAFile_MiniIso")).fullPath());
55  rho_miniiso_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho_MiniIso"));
56  }
57  if ((typeid(T) == typeid(pat::Electron))) {
58  produces<edm::ValueMap<float>>("PFIsoChg");
59  produces<edm::ValueMap<float>>("PFIsoAll");
60  produces<edm::ValueMap<float>>("PFIsoAll04");
61  ea_pfiso_ = std::make_unique<EffectiveAreas>((iConfig.getParameter<edm::FileInPath>("EAFile_PFIso")).fullPath());
62  rho_pfiso_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho_PFIso"));
63  } else if ((typeid(T) == typeid(pat::Photon))) {
64  produces<edm::ValueMap<float>>("PFIsoChg");
65  produces<edm::ValueMap<float>>("PFIsoAll");
66  ea_pfiso_chg_ =
67  std::make_unique<EffectiveAreas>((iConfig.getParameter<edm::FileInPath>("EAFile_PFIso_Chg")).fullPath());
68  ea_pfiso_neu_ =
69  std::make_unique<EffectiveAreas>((iConfig.getParameter<edm::FileInPath>("EAFile_PFIso_Neu")).fullPath());
70  ea_pfiso_pho_ =
71  std::make_unique<EffectiveAreas>((iConfig.getParameter<edm::FileInPath>("EAFile_PFIso_Pho")).fullPath());
72  rho_pfiso_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho_PFIso"));
73  }
74  }
75  ~IsoValueMapProducer() override {}
76 
77  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
78 
79 private:
80  void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override;
81 
82  // ----------member data ---------------------------
83 
84  edm::EDGetTokenT<edm::View<T>> src_;
85  bool relative_;
86  edm::EDGetTokenT<double> rho_miniiso_;
87  edm::EDGetTokenT<double> rho_pfiso_;
88  std::unique_ptr<EffectiveAreas> ea_miniiso_;
89  std::unique_ptr<EffectiveAreas> ea_pfiso_;
90  std::unique_ptr<EffectiveAreas> ea_pfiso_chg_;
91  std::unique_ptr<EffectiveAreas> ea_pfiso_neu_;
92  std::unique_ptr<EffectiveAreas> ea_pfiso_pho_;
93  float getEtaForEA(const T*) const;
94  void doMiniIso(edm::Event&) const;
95  void doPFIsoEle(edm::Event&) const;
96  void doPFIsoPho(edm::Event&) const;
97 };
98 
99 //
100 // constants, enums and typedefs
101 //
102 
103 //
104 // static data member definitions
105 //
106 
107 template <typename T>
108 float IsoValueMapProducer<T>::getEtaForEA(const T* obj) const {
109  return obj->eta();
110 }
111 template <>
112 float IsoValueMapProducer<pat::Electron>::getEtaForEA(const pat::Electron* el) const {
113  return el->superCluster()->eta();
114 }
115 template <>
116 float IsoValueMapProducer<pat::Photon>::getEtaForEA(const pat::Photon* ph) const {
117  return ph->superCluster()->eta();
118 }
119 
120 template <typename T>
121 void IsoValueMapProducer<T>::produce(edm::StreamID streamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const {
122  if ((typeid(T) == typeid(pat::Muon)) || (typeid(T) == typeid(pat::Electron)) ||
123  typeid(T) == typeid(pat::IsolatedTrack)) {
124  doMiniIso(iEvent);
125  };
126  if ((typeid(T) == typeid(pat::Electron))) {
127  doPFIsoEle(iEvent);
128  }
129  if ((typeid(T) == typeid(pat::Photon))) {
130  doPFIsoPho(iEvent);
131  }
132 }
133 
134 template <typename T>
135 void IsoValueMapProducer<T>::doMiniIso(edm::Event& iEvent) const {
136  edm::Handle<edm::View<T>> src;
137  iEvent.getByToken(src_, src);
138  edm::Handle<double> rho;
139  iEvent.getByToken(rho_miniiso_, rho);
140 
141  unsigned int nInput = src->size();
142 
143  std::vector<float> miniIsoChg, miniIsoAll;
144  miniIsoChg.reserve(nInput);
145  miniIsoAll.reserve(nInput);
146 
147  for (const auto& obj : *src) {
148  auto iso = obj.miniPFIsolation();
149  auto chg = iso.chargedHadronIso();
150  auto neu = iso.neutralHadronIso();
151  auto pho = iso.photonIso();
152  auto ea = ea_miniiso_->getEffectiveArea(fabs(getEtaForEA(&obj)));
153  float R = 10.0 / std::min(std::max(obj.pt(), 50.0), 200.0);
154  ea *= std::pow(R / 0.3, 2);
155  float scale = relative_ ? 1.0 / obj.pt() : 1;
156  miniIsoChg.push_back(scale * chg);
157  miniIsoAll.push_back(scale * (chg + std::max(0.0, neu + pho - (*rho) * ea)));
158  }
159 
160  std::unique_ptr<edm::ValueMap<float>> miniIsoChgV(new edm::ValueMap<float>());
161  edm::ValueMap<float>::Filler fillerChg(*miniIsoChgV);
162  fillerChg.insert(src, miniIsoChg.begin(), miniIsoChg.end());
163  fillerChg.fill();
164  std::unique_ptr<edm::ValueMap<float>> miniIsoAllV(new edm::ValueMap<float>());
165  edm::ValueMap<float>::Filler fillerAll(*miniIsoAllV);
166  fillerAll.insert(src, miniIsoAll.begin(), miniIsoAll.end());
167  fillerAll.fill();
168 
169  iEvent.put(std::move(miniIsoChgV), "miniIsoChg");
170  iEvent.put(std::move(miniIsoAllV), "miniIsoAll");
171 }
172 
173 template <>
174 void IsoValueMapProducer<pat::Photon>::doMiniIso(edm::Event& iEvent) const {}
175 
176 template <typename T>
177 void IsoValueMapProducer<T>::doPFIsoEle(edm::Event& iEvent) const {}
178 
179 template <>
180 void IsoValueMapProducer<pat::Electron>::doPFIsoEle(edm::Event& iEvent) const {
181  edm::Handle<edm::View<pat::Electron>> src;
182  iEvent.getByToken(src_, src);
183  edm::Handle<double> rho;
184  iEvent.getByToken(rho_pfiso_, rho);
185 
186  unsigned int nInput = src->size();
187 
188  std::vector<float> PFIsoChg, PFIsoAll, PFIsoAll04;
189  PFIsoChg.reserve(nInput);
190  PFIsoAll.reserve(nInput);
191  PFIsoAll04.reserve(nInput);
192 
193  for (const auto& obj : *src) {
194  auto iso = obj.pfIsolationVariables();
195  auto chg = iso.sumChargedHadronPt;
196  auto neu = iso.sumNeutralHadronEt;
197  auto pho = iso.sumPhotonEt;
198  auto ea = ea_pfiso_->getEffectiveArea(fabs(getEtaForEA(&obj)));
199  float scale = relative_ ? 1.0 / obj.pt() : 1;
200  PFIsoChg.push_back(scale * chg);
201  PFIsoAll.push_back(scale * (chg + std::max(0.0, neu + pho - (*rho) * ea)));
202  PFIsoAll04.push_back(scale * (obj.chargedHadronIso() +
203  std::max(0.0, obj.neutralHadronIso() + obj.photonIso() - (*rho) * ea * 16. / 9.)));
204  }
205 
206  std::unique_ptr<edm::ValueMap<float>> PFIsoChgV(new edm::ValueMap<float>());
207  edm::ValueMap<float>::Filler fillerChg(*PFIsoChgV);
208  fillerChg.insert(src, PFIsoChg.begin(), PFIsoChg.end());
209  fillerChg.fill();
210  std::unique_ptr<edm::ValueMap<float>> PFIsoAllV(new edm::ValueMap<float>());
211  edm::ValueMap<float>::Filler fillerAll(*PFIsoAllV);
212  fillerAll.insert(src, PFIsoAll.begin(), PFIsoAll.end());
213  fillerAll.fill();
214  std::unique_ptr<edm::ValueMap<float>> PFIsoAll04V(new edm::ValueMap<float>());
215  edm::ValueMap<float>::Filler fillerAll04(*PFIsoAll04V);
216  fillerAll04.insert(src, PFIsoAll04.begin(), PFIsoAll04.end());
217  fillerAll04.fill();
218 
219  iEvent.put(std::move(PFIsoChgV), "PFIsoChg");
220  iEvent.put(std::move(PFIsoAllV), "PFIsoAll");
221  iEvent.put(std::move(PFIsoAll04V), "PFIsoAll04");
222 }
223 
224 template <typename T>
225 void IsoValueMapProducer<T>::doPFIsoPho(edm::Event& iEvent) const {}
226 
227 template <>
228 void IsoValueMapProducer<pat::Photon>::doPFIsoPho(edm::Event& iEvent) const {
229  edm::Handle<edm::View<pat::Photon>> src;
230  iEvent.getByToken(src_, src);
231  edm::Handle<double> rho;
232  iEvent.getByToken(rho_pfiso_, rho);
233 
234  unsigned int nInput = src->size();
235 
236  std::vector<float> PFIsoChg, PFIsoAll;
237  PFIsoChg.reserve(nInput);
238  PFIsoAll.reserve(nInput);
239 
240  for (const auto& obj : *src) {
241  auto chg = obj.chargedHadronIso();
242  auto neu = obj.neutralHadronIso();
243  auto pho = obj.photonIso();
244  auto ea_chg = ea_pfiso_chg_->getEffectiveArea(fabs(getEtaForEA(&obj)));
245  auto ea_neu = ea_pfiso_neu_->getEffectiveArea(fabs(getEtaForEA(&obj)));
246  auto ea_pho = ea_pfiso_pho_->getEffectiveArea(fabs(getEtaForEA(&obj)));
247  float scale = relative_ ? 1.0 / obj.pt() : 1;
248  PFIsoChg.push_back(scale * std::max(0.0, chg - (*rho) * ea_chg));
249  PFIsoAll.push_back(PFIsoChg.back() +
250  scale * (std::max(0.0, neu - (*rho) * ea_neu) + std::max(0.0, pho - (*rho) * ea_pho)));
251  }
252 
253  std::unique_ptr<edm::ValueMap<float>> PFIsoChgV(new edm::ValueMap<float>());
254  edm::ValueMap<float>::Filler fillerChg(*PFIsoChgV);
255  fillerChg.insert(src, PFIsoChg.begin(), PFIsoChg.end());
256  fillerChg.fill();
257  std::unique_ptr<edm::ValueMap<float>> PFIsoAllV(new edm::ValueMap<float>());
258  edm::ValueMap<float>::Filler fillerAll(*PFIsoAllV);
259  fillerAll.insert(src, PFIsoAll.begin(), PFIsoAll.end());
260  fillerAll.fill();
261 
262  iEvent.put(std::move(PFIsoChgV), "PFIsoChg");
263  iEvent.put(std::move(PFIsoAllV), "PFIsoAll");
264 }
265 
266 // ------------ method fills 'descriptions' with the allowed parameters for the module ------------
267 template <typename T>
268 void IsoValueMapProducer<T>::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
269  edm::ParameterSetDescription desc;
270  desc.add<edm::InputTag>("src")->setComment("input physics object collection");
271  desc.add<bool>("relative")->setComment("compute relative isolation instead of absolute one");
272  if ((typeid(T) == typeid(pat::Muon)) || (typeid(T) == typeid(pat::Electron)) ||
273  typeid(T) == typeid(pat::IsolatedTrack)) {
274  desc.add<edm::FileInPath>("EAFile_MiniIso")
275  ->setComment("txt file containing effective areas to be used for mini-isolation pileup subtraction");
276  desc.add<edm::InputTag>("rho_MiniIso")
277  ->setComment("rho to be used for effective-area based mini-isolation pileup subtraction");
278  }
279  if ((typeid(T) == typeid(pat::Electron))) {
280  desc.add<edm::FileInPath>("EAFile_PFIso")
281  ->setComment(
282  "txt file containing effective areas to be used for PF-isolation pileup subtraction for electrons");
283  desc.add<edm::InputTag>("rho_PFIso")
284  ->setComment("rho to be used for effective-area based PF-isolation pileup subtraction for electrons");
285  }
286  if ((typeid(T) == typeid(pat::Photon))) {
287  desc.add<edm::InputTag>("mapIsoChg")->setComment("input charged PF isolation calculated in VID for photons");
288  desc.add<edm::InputTag>("mapIsoNeu")->setComment("input neutral PF isolation calculated in VID for photons");
289  desc.add<edm::InputTag>("mapIsoPho")->setComment("input photon PF isolation calculated in VID for photons");
290  desc.add<edm::FileInPath>("EAFile_PFIso_Chg")
291  ->setComment(
292  "txt file containing effective areas to be used for charged PF-isolation pileup subtraction for photons");
293  desc.add<edm::FileInPath>("EAFile_PFIso_Neu")
294  ->setComment(
295  "txt file containing effective areas to be used for neutral PF-isolation pileup subtraction for photons");
296  desc.add<edm::FileInPath>("EAFile_PFIso_Pho")
297  ->setComment(
298  "txt file containing effective areas to be used for photon PF-isolation pileup subtraction for photons");
299  desc.add<edm::InputTag>("rho_PFIso")
300  ->setComment("rho to be used for effective-area based PF-isolation pileup subtraction for photons");
301  }
302  std::string modname;
303  if (typeid(T) == typeid(pat::Muon))
304  modname += "Muon";
305  else if (typeid(T) == typeid(pat::Electron))
306  modname += "Ele";
307  else if (typeid(T) == typeid(pat::Photon))
308  modname += "Pho";
309  else if (typeid(T) == typeid(pat::IsolatedTrack))
310  modname += "IsoTrack";
311  modname += "IsoValueMapProducer";
312  descriptions.add(modname, desc);
313 }
314 
315 typedef IsoValueMapProducer<pat::Muon> MuonIsoValueMapProducer;
316 typedef IsoValueMapProducer<pat::Electron> EleIsoValueMapProducer;
317 typedef IsoValueMapProducer<pat::Photon> PhoIsoValueMapProducer;
318 typedef IsoValueMapProducer<pat::IsolatedTrack> IsoTrackIsoValueMapProducer;
319 
320 //define this as a plug-in
321 DEFINE_FWK_MODULE(MuonIsoValueMapProducer);
322 DEFINE_FWK_MODULE(EleIsoValueMapProducer);
323 DEFINE_FWK_MODULE(PhoIsoValueMapProducer);
324 DEFINE_FWK_MODULE(IsoTrackIsoValueMapProducer);
edm::StreamID
Definition: StreamID.h:30
IsoValueMapProducer::ea_miniiso_
std::unique_ptr< EffectiveAreas > ea_miniiso_
Definition: IsoValueMapProducer.cc:88
electrons_cff.PFIsoChg
PFIsoChg
Definition: electrons_cff.py:201
electrons_cff.bool
bool
Definition: electrons_cff.py:366
edm::helper::Filler::insert
void insert(const H &h, I begin, I end)
Definition: ValueMap.h:53
L1EGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: L1EGammaCrystalsEmulatorProducer_cfi.py:10
sistrip::View
View
Definition: ConstantsForView.h:26
min
T min(T a, T b)
Definition: MathUtil.h:58
edm::EDGetTokenT
Definition: EDGetToken.h:33
edm
HLT enums.
Definition: AlignableModifier.h:19
Muon.h
Photon.h
pat::Photon
Analysis-level Photon class.
Definition: Photon.h:46
IsoValueMapProducer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: IsoValueMapProducer.cc:268
ZElectronSkim_cff.rho
rho
Definition: ZElectronSkim_cff.py:38
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89281
edm::helper::Filler::fill
void fill()
Definition: ValueMap.h:65
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
IsoValueMapProducer::getEtaForEA
float getEtaForEA(const T *) const
Definition: IsoValueMapProducer.cc:108
PhoIsoValueMapProducer
IsoValueMapProducer< pat::Photon > PhoIsoValueMapProducer
Definition: IsoValueMapProducer.cc:317
pat::Muon
Analysis-level muon class.
Definition: Muon.h:51
EffectiveAreas.h
edm::Handle
Definition: AssociativeIterator.h:50
IsoValueMapProducer
Definition: IsoValueMapProducer.cc:44
chg
const float chg[109]
Definition: CoreSimTrack.cc:5
edm::FileInPath
Definition: FileInPath.h:64
MakerMacros.h
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
IsolatedTrack.h
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
IsoValueMapProducer::ea_pfiso_
std::unique_ptr< EffectiveAreas > ea_pfiso_
Definition: IsoValueMapProducer.cc:89
IsoValueMapProducer::IsoValueMapProducer
IsoValueMapProducer(const edm::ParameterSet &iConfig)
Definition: IsoValueMapProducer.cc:46
IsoTrackIsoValueMapProducer
IsoValueMapProducer< pat::IsolatedTrack > IsoTrackIsoValueMapProducer
Definition: IsoValueMapProducer.cc:318
IsoValueMapProducer::~IsoValueMapProducer
~IsoValueMapProducer() override
Definition: IsoValueMapProducer.cc:75
getGTfromDQMFile.obj
obj
Definition: getGTfromDQMFile.py:32
edm::global::EDProducer
Definition: EDProducer.h:32
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
electrons_cff.PFIsoAll
PFIsoAll
Definition: electrons_cff.py:202
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
IsoValueMapProducer::ea_pfiso_pho_
std::unique_ptr< EffectiveAreas > ea_pfiso_pho_
Definition: IsoValueMapProducer.cc:92
IsoValueMapProducer::doMiniIso
void doMiniIso(edm::Event &) const
Definition: IsoValueMapProducer.cc:135
IsoValueMapProducer::ea_pfiso_chg_
std::unique_ptr< EffectiveAreas > ea_pfiso_chg_
Definition: IsoValueMapProducer.cc:90
IsoValueMapProducer::relative_
bool relative_
Definition: IsoValueMapProducer.cc:85
electrons_cff.PFIsoAll04
PFIsoAll04
Definition: electrons_cff.py:203
edm::ParameterSet
Definition: ParameterSet.h:47
TrackRefitter_38T_cff.src
src
Definition: TrackRefitter_38T_cff.py:24
Event.h
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
EleIsoValueMapProducer
IsoValueMapProducer< pat::Electron > EleIsoValueMapProducer
Definition: IsoValueMapProducer.cc:316
IsoValueMapProducer::ea_pfiso_neu_
std::unique_ptr< EffectiveAreas > ea_pfiso_neu_
Definition: IsoValueMapProducer.cc:91
iEvent
int iEvent
Definition: GenABIO.cc:224
MuonIsoValueMapProducer
IsoValueMapProducer< pat::Muon > MuonIsoValueMapProducer
Definition: IsoValueMapProducer.cc:315
electrons_cff.miniIsoAll
miniIsoAll
Definition: electrons_cff.py:200
edm::EventSetup
Definition: EventSetup.h:58
IsoValueMapProducer::produce
void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override
Definition: IsoValueMapProducer.cc:121
pat::IsolatedTrack
Definition: IsolatedTrack.h:21
IsoValueMapProducer::src_
edm::EDGetTokenT< edm::View< T > > src_
Definition: IsoValueMapProducer.cc:84
electrons_cff.miniIsoChg
miniIsoChg
Definition: electrons_cff.py:199
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
eostools.move
def move(src, dest)
Definition: eostools.py:511
pat::Electron::superCluster
reco::SuperClusterRef superCluster() const override
override the reco::GsfElectron::superCluster method, to access the internal storage of the superclust...
Frameworkfwd.h
T
long double T
Definition: Basic3DVectorLD.h:48
edm::ValueMap< float >
IsoValueMapProducer::rho_miniiso_
edm::EDGetTokenT< double > rho_miniiso_
Definition: IsoValueMapProducer.cc:86
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
Electron.h
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
edm::helper::Filler
Definition: ValueMap.h:22
pat::Electron
Analysis-level electron class.
Definition: Electron.h:51
IsoValueMapProducer::doPFIsoEle
void doPFIsoEle(edm::Event &) const
Definition: IsoValueMapProducer.cc:177
ParameterSet.h
edm::EDConsumerBase::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: EDConsumerBase.h:155
IsoValueMapProducer::rho_pfiso_
edm::EDGetTokenT< double > rho_pfiso_
Definition: IsoValueMapProducer.cc:87
EDProducer.h
IsoValueMapProducer::doPFIsoPho
void doPFIsoPho(edm::Event &) const
Definition: IsoValueMapProducer.cc:225
edm::Event
Definition: Event.h:73
StreamID.h
dttmaxenums::R
Definition: DTTMax.h:29
timingPdfMaker.modname
modname
Definition: timingPdfMaker.py:218
edm::InputTag
Definition: InputTag.h:15
pat::Photon::superCluster
reco::SuperClusterRef superCluster() const override
override the superCluster method from CaloJet, to access the internal storage of the supercluster
Generated for CMSSW Reference Manual by doxygen 1.8.16