CMS 3D CMS Logo

HLTTauRefProducer.cc
Go to the documentation of this file.
2 #include "TLorentzVector.h"
3 // TAU includes
7 // ELECTRON includes
14 // MUON includes
17 #include "TLorentzVector.h"
19 //CaloTower includes
23 #include "Math/GenVector/VectorUtil.h"
24 
25 using namespace edm;
26 using namespace reco;
27 using namespace std;
28 
30  //One Parameter Set per Collection
31  {
32  auto const& pfTau = iConfig.getUntrackedParameter<edm::ParameterSet>("PFTaus");
33  PFTaus_ = consumes<reco::PFTauCollection>(pfTau.getUntrackedParameter<InputTag>("PFTauProducer"));
34  auto discs = pfTau.getUntrackedParameter<vector<InputTag>>("PFTauDiscriminators");
35  auto discConts = pfTau.getUntrackedParameter<vector<InputTag>>("PFTauDiscriminatorContainers");
36  PFTauDisContWPs_ = pfTau.getUntrackedParameter<vector<std::string>>("PFTauDiscriminatorContainerWPs");
37  if (discConts.size() != PFTauDisContWPs_.size())
38  throw cms::Exception("Configuration") << "HLTTauRefProducer: Input parameters PFTauDiscriminatorContainers and "
39  "PFTauDiscriminatorContainerWPs must have the same number of entries!\n";
40  for (auto const& tag : discs) {
41  PFTauDis_.push_back(consumes<reco::PFTauDiscriminator>(tag));
42  }
43  for (auto const& tag : discConts) {
44  PFTauDisCont_.push_back(consumes<reco::TauDiscriminatorContainer>(tag));
45  }
46  doPFTaus_ = pfTau.getUntrackedParameter<bool>("doPFTaus", false);
47  ptMinPFTau_ = pfTau.getUntrackedParameter<double>("ptMin", 15.);
48  etaMinPFTau_ = pfTau.getUntrackedParameter<double>("etaMin", -2.5);
49  etaMaxPFTau_ = pfTau.getUntrackedParameter<double>("etaMax", 2.5);
50  phiMinPFTau_ = pfTau.getUntrackedParameter<double>("phiMin", -3.15);
51  phiMaxPFTau_ = pfTau.getUntrackedParameter<double>("phiMax", 3.15);
52  }
53 
54  {
55  auto const& electrons = iConfig.getUntrackedParameter<edm::ParameterSet>("Electrons");
56  Electrons_ = consumes<reco::GsfElectronCollection>(electrons.getUntrackedParameter<InputTag>("ElectronCollection"));
57  doElectrons_ = electrons.getUntrackedParameter<bool>("doElectrons", false);
58  e_ctfTrackCollectionSrc_ = electrons.getUntrackedParameter<InputTag>("TrackCollection");
59  e_ctfTrackCollection_ = consumes<reco::TrackCollection>(e_ctfTrackCollectionSrc_);
60  ptMinElectron_ = electrons.getUntrackedParameter<double>("ptMin", 15.);
61  e_doTrackIso_ = electrons.getUntrackedParameter<bool>("doTrackIso", false);
62  e_trackMinPt_ = electrons.getUntrackedParameter<double>("ptMinTrack", 1.5);
63  e_lipCut_ = electrons.getUntrackedParameter<double>("lipMinTrack", 1.5);
64  e_minIsoDR_ = electrons.getUntrackedParameter<double>("InnerConeDR", 0.02);
65  e_maxIsoDR_ = electrons.getUntrackedParameter<double>("OuterConeDR", 0.6);
66  e_isoMaxSumPt_ = electrons.getUntrackedParameter<double>("MaxIsoVar", 0.02);
67  }
68 
69  {
70  auto const& muons = iConfig.getUntrackedParameter<edm::ParameterSet>("Muons");
71  Muons_ = consumes<reco::MuonCollection>(muons.getUntrackedParameter<InputTag>("MuonCollection"));
72  doMuons_ = muons.getUntrackedParameter<bool>("doMuons", false);
73  ptMinMuon_ = muons.getUntrackedParameter<double>("ptMin", 15.);
74  }
75 
76  {
77  auto const& jets = iConfig.getUntrackedParameter<edm::ParameterSet>("Jets");
78  Jets_ = consumes<reco::CaloJetCollection>(jets.getUntrackedParameter<InputTag>("JetCollection"));
79  doJets_ = jets.getUntrackedParameter<bool>("doJets");
80  ptMinJet_ = jets.getUntrackedParameter<double>("etMin");
81  }
82 
83  {
84  auto const& towers = iConfig.getUntrackedParameter<edm::ParameterSet>("Towers");
85  Towers_ = consumes<CaloTowerCollection>(towers.getUntrackedParameter<InputTag>("TowerCollection"));
86  doTowers_ = towers.getUntrackedParameter<bool>("doTowers");
87  ptMinTower_ = towers.getUntrackedParameter<double>("etMin");
88  towerIsol_ = towers.getUntrackedParameter<double>("towerIsolation");
89  }
90 
91  {
92  auto const& photons = iConfig.getUntrackedParameter<edm::ParameterSet>("Photons");
93  Photons_ = consumes<reco::PhotonCollection>(photons.getUntrackedParameter<InputTag>("PhotonCollection"));
94  doPhotons_ = photons.getUntrackedParameter<bool>("doPhotons");
95  ptMinPhoton_ = photons.getUntrackedParameter<double>("etMin");
96  photonEcalIso_ = photons.getUntrackedParameter<double>("ECALIso");
97  }
98 
99  {
100  auto const& met = iConfig.getUntrackedParameter<edm::ParameterSet>("MET");
101  MET_ = consumes<reco::CaloMETCollection>(met.getUntrackedParameter<InputTag>("METCollection"));
102  doMET_ = met.getUntrackedParameter<bool>("doMET", false);
103  ptMinMET_ = met.getUntrackedParameter<double>("ptMin", 15.);
104  }
105 
106  etaMin_ = iConfig.getUntrackedParameter<double>("EtaMin", -2.5);
107  etaMax_ = iConfig.getUntrackedParameter<double>("EtaMax", 2.5);
108  phiMin_ = iConfig.getUntrackedParameter<double>("PhiMin", -3.15);
109  phiMax_ = iConfig.getUntrackedParameter<double>("PhiMax", 3.15);
110 
111  //recoCollections
112  produces<LorentzVectorCollection>("PFTaus");
113  produces<LorentzVectorCollection>("Electrons");
114  produces<LorentzVectorCollection>("Muons");
115  produces<LorentzVectorCollection>("Jets");
116  produces<LorentzVectorCollection>("Photons");
117  produces<LorentzVectorCollection>("Towers");
118  produces<LorentzVectorCollection>("MET");
119 }
120 
122  if (doPFTaus_)
123  doPFTaus(iID, iEvent);
124  if (doElectrons_)
126  if (doMuons_)
127  doMuons(iEvent);
128  if (doJets_)
129  doJets(iEvent);
130  if (doPhotons_)
131  doPhotons(iEvent);
132  if (doTowers_)
133  doTowers(iEvent);
134  if (doMET_)
135  doMET(iEvent);
136 }
137 
139  auto product_PFTaus = make_unique<LorentzVectorCollection>();
140 
142  if (iEvent.getByToken(PFTaus_, pftaus)) {
143  // Retrieve ID container indices if config history changes, in particular for the first event.
144  if (streamCache(iID)->first != iEvent.processHistoryID()) {
145  streamCache(iID)->first = iEvent.processHistoryID();
146  streamCache(iID)->second.resize(PFTauDisContWPs_.size());
147  for (size_t i = 0; i < PFTauDisCont_.size(); ++i) {
148  auto const aHandle = iEvent.getHandle(PFTauDisCont_[i]);
149  auto const aProv = aHandle.provenance();
150  if (aProv == nullptr)
151  aHandle.whyFailed()->raise();
152  const auto& psetsFromProvenance = edm::parameterSet(aProv->stable(), iEvent.processHistory());
153  if (psetsFromProvenance.exists("workingPoints")) {
154  auto const idlist = psetsFromProvenance.getParameter<std::vector<std::string>>("workingPoints");
155  bool found = false;
156  for (size_t j = 0; j < idlist.size(); ++j) {
157  if (PFTauDisContWPs_[i] == idlist[j]) {
158  found = true;
159  streamCache(iID)->second[i] = j;
160  }
161  }
162  if (!found)
163  throw cms::Exception("Configuration")
164  << "HLTTauRefProducer: Requested working point '" << PFTauDisContWPs_[i] << "' not found!\n";
165  } else if (psetsFromProvenance.exists("IDWPdefinitions")) {
166  auto const idlist = psetsFromProvenance.getParameter<std::vector<edm::ParameterSet>>("IDWPdefinitions");
167  bool found = false;
168  for (size_t j = 0; j < idlist.size(); ++j) {
169  if (PFTauDisContWPs_[i] == idlist[j].getParameter<std::string>("IDname")) {
170  found = true;
171  streamCache(iID)->second[i] = j;
172  }
173  }
174  if (!found)
175  throw cms::Exception("Configuration")
176  << "HLTTauRefProducer: Requested working point '" << PFTauDisContWPs_[i] << "' not found!\n";
177  } else
178  throw cms::Exception("Configuration")
179  << "HLTTauRefProducer: No suitable ID list found in provenace config!\n";
180  }
181  }
182  for (unsigned int i = 0; i < pftaus->size(); ++i) {
183  auto const& pftau = (*pftaus)[i];
184  if (pftau.pt() > ptMinPFTau_ && pftau.eta() > etaMinPFTau_ && pftau.eta() < etaMaxPFTau_ &&
185  pftau.phi() > phiMinPFTau_ && pftau.phi() < phiMaxPFTau_) {
186  reco::PFTauRef thePFTau{pftaus, i};
187  bool passAll{true};
188 
189  for (auto const& token : PFTauDis_) {
191  if (iEvent.getByToken(token, pftaudis)) {
192  if ((*pftaudis)[thePFTau] < 0.5) {
193  passAll = false;
194  break;
195  }
196  } else {
197  passAll = false;
198  break;
199  }
200  }
201 
202  int idx = 0;
203  for (auto const& token : PFTauDisCont_) {
205  if (iEvent.getByToken(token, pftaudis)) {
206  //WP vector not filled if prediscriminator in RecoTauDiscriminator failed.
207  if ((*pftaudis)[thePFTau].workingPoints.empty() ||
208  !(*pftaudis)[thePFTau].workingPoints.at(streamCache(iID)->second[idx])) {
209  passAll = false;
210  break;
211  }
212  } else {
213  passAll = false;
214  break;
215  }
216  idx++;
217  }
218  if (passAll) {
219  product_PFTaus->emplace_back(pftau.px(), pftau.py(), pftau.pz(), pftau.energy());
220  }
221  }
222  }
223  }
224  iEvent.put(move(product_PFTaus), "PFTaus");
225 }
226 
228  auto product_Electrons = make_unique<LorentzVectorCollection>();
229 
231  if (!iEvent.getByToken(e_ctfTrackCollection_, pCtfTracks)) {
232  edm::LogInfo("") << "Error! Can't get " << e_ctfTrackCollectionSrc_.label() << " by label. ";
233  iEvent.put(move(product_Electrons), "Electrons");
234  return;
235  }
236 
238  if (iEvent.getByToken(Electrons_, electrons)) {
239  for (size_t i = 0; i < electrons->size(); ++i) {
241  auto const& electron = (*electrons)[i];
242  if (electron.pt() > ptMinElectron_ && fabs(electron.eta()) < etaMax_) {
243  if (e_doTrackIso_) {
244  double sum_of_pt_ele{};
245  for (auto const& tr : *pCtfTracks) {
246  double const lip{electron.gsfTrack()->dz() - tr.dz()};
247  if (tr.pt() > e_trackMinPt_ && fabs(lip) < e_lipCut_) {
248  double dphi{fabs(tr.phi() - electron.trackMomentumAtVtx().phi())};
249  if (dphi > acos(-1.)) {
250  dphi = 2 * acos(-1.) - dphi;
251  }
252  double const deta{fabs(tr.eta() - electron.trackMomentumAtVtx().eta())};
253  double const dr_ctf_ele{sqrt(deta * deta + dphi * dphi)};
254  if ((dr_ctf_ele > e_minIsoDR_) && (dr_ctf_ele < e_maxIsoDR_)) {
255  double const cft_pt_2{tr.pt() * tr.pt()};
256  sum_of_pt_ele += cft_pt_2;
257  }
258  }
259  }
260  double const isolation_value_ele{sum_of_pt_ele /
261  (electron.trackMomentumAtVtx().Rho() * electron.trackMomentumAtVtx().Rho())};
262  if (isolation_value_ele < e_isoMaxSumPt_) {
263  product_Electrons->emplace_back(electron.px(), electron.py(), electron.pz(), electron.energy());
264  }
265  } else {
266  product_Electrons->emplace_back(electron.px(), electron.py(), electron.pz(), electron.energy());
267  }
268  }
269  }
270  }
271  iEvent.put(move(product_Electrons), "Electrons");
272 }
273 
275  auto product_Muons = make_unique<LorentzVectorCollection>();
276 
278  if (iEvent.getByToken(Muons_, muons)) {
279  for (auto const& muon : *muons) {
280  if (muon.pt() > ptMinMuon_ && muon.eta() > etaMin_ && muon.eta() < etaMax_ && muon.phi() > phiMin_ &&
281  muon.phi() < phiMax_) {
282  product_Muons->emplace_back(muon.px(), muon.py(), muon.pz(), muon.energy());
283  }
284  }
285  }
286  iEvent.put(move(product_Muons), "Muons");
287 }
288 
290  auto product_Jets = make_unique<LorentzVectorCollection>();
291 
293  if (iEvent.getByToken(Jets_, jets)) {
294  for (auto const& jet : *jets) {
295  if (jet.et() > ptMinJet_ && jet.eta() > etaMin_ && jet.eta() < etaMax_ && jet.phi() > phiMin_ &&
296  jet.phi() < phiMax_) {
297  product_Jets->emplace_back(jet.px(), jet.py(), jet.pz(), jet.energy());
298  }
299  }
300  }
301  iEvent.put(move(product_Jets), "Jets");
302 }
303 
305  auto product_Towers = make_unique<LorentzVectorCollection>();
306 
308  if (iEvent.getByToken(Towers_, towers)) {
309  for (auto const& tower1 : *towers) {
310  if (tower1.pt() > ptMinTower_ && tower1.eta() > etaMin_ && tower1.eta() < etaMax_ && tower1.phi() > phiMin_ &&
311  tower1.phi() < phiMax_) {
312  //calculate isolation
313  double isolET{};
314  for (auto const& tower2 : *towers) {
315  if (ROOT::Math::VectorUtil::DeltaR(tower1.p4(), tower2.p4()) < 0.5) {
316  isolET += tower2.pt();
317  }
318  isolET -= tower1.pt();
319  }
320  if (isolET < towerIsol_) {
321  product_Towers->emplace_back(tower1.px(), tower1.py(), tower1.pz(), tower1.energy());
322  }
323  }
324  }
325  }
326  iEvent.put(move(product_Towers), "Towers");
327 }
328 
330  auto product_Gammas = make_unique<LorentzVectorCollection>();
331 
333  if (iEvent.getByToken(Photons_, photons)) {
334  for (auto const& photon : *photons) {
335  if (photon.ecalRecHitSumEtConeDR04() < photonEcalIso_ && photon.et() > ptMinPhoton_ && photon.eta() > etaMin_ &&
336  photon.eta() < etaMax_ && photon.phi() > phiMin_ && photon.phi() < phiMax_) {
337  product_Gammas->emplace_back(photon.px(), photon.py(), photon.pz(), photon.energy());
338  }
339  }
340  }
341  iEvent.put(move(product_Gammas), "Photons");
342 }
343 
345  auto product_MET = make_unique<LorentzVectorCollection>();
346 
348  if (iEvent.getByToken(MET_, met) && !met->empty()) {
349  auto const& metMom = met->front().p4();
350  product_MET->emplace_back(metMom.Px(), metMom.Py(), 0, metMom.Pt());
351  }
352  iEvent.put(move(product_MET), "MET");
353 }
354 
T getParameter(std::string const &) const
Definition: ParameterSet.h:307
void doPhotons(edm::Event &) const
void doTowers(edm::Event &) const
void doElectrons(edm::Event &) const
HLTTauRefProducer(const edm::ParameterSet &)
void produce(edm::StreamID, edm::Event &, edm::EventSetup const &) const override
ParameterSet const & parameterSet(StableProvenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:11
T getUntrackedParameter(std::string const &, T const &) const
U second(std::pair< T, U > const &p)
int iEvent
Definition: GenABIO.cc:224
T sqrt(T t)
Definition: SSEVec.h:19
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
void doMuons(edm::Event &) const
Log< level::Info, false > LogInfo
void doMET(edm::Event &) const
fixed size matrix
HLT enums.
void doPFTaus(edm::StreamID, edm::Event &) const
void doJets(edm::Event &) const
def move(src, dest)
Definition: eostools.py:511