CMS 3D CMS Logo
TriggerMatcherToHLTDebug.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: MuonAnalysis/MuonAssociators
4 // Class: TriggerMatcherToHLTDebug
5 //
13 //
14 // Original Author: Cristina Botta (Torino), Giovanni Petrucciani (UCSD)
15 // Created: Fri 30 Apr 2010
16 //
17 
18 #include "FWCore/Framework/interface/Frameworkfwd.h"
19 
20 #include "DataFormats/Math/interface/deltaR.h"
21 
22 #include "DataFormats/Common/interface/ValueMap.h"
23 #include "DataFormats/Common/interface/View.h"
24 #include "DataFormats/Common/interface/Ptr.h"
25 
26 #include "DataFormats/L1Trigger/interface/L1MuonParticleFwd.h"
27 #include "DataFormats/L1Trigger/interface/L1MuonParticle.h"
28 
29 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
30 #include "DataFormats/TrackReco/interface/TrackFwd.h"
31 #include "DataFormats/TrackReco/interface/Track.h"
32 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
33 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
34 #include "DataFormats/MuonReco/interface/MuonFwd.h"
35 #include "DataFormats/MuonReco/interface/Muon.h"
36 #include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
37 
38 //new for association map
39 #include "DataFormats/L1Trigger/interface/L1MuonParticleFwd.h"
40 #include "DataFormats/TrackReco/interface/Track.h"
41 #include "DataFormats/TrackReco/interface/TrackFwd.h"
42 #include "DataFormats/Common/interface/AssociationMap.h"
43 #include "DataFormats/Common/interface/OneToMany.h"
44 #include "DataFormats/Common/interface/Handle.h"
45 #include "DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h"
46 
47 #include "DataFormats/MuonSeed/interface/L2MuonTrajectorySeed.h"
48 #include "DataFormats/MuonSeed/interface/L2MuonTrajectorySeedCollection.h"
49 #include "DataFormats/MuonSeed/interface/L3MuonTrajectorySeed.h"
50 #include "DataFormats/MuonSeed/interface/L3MuonTrajectorySeedCollection.h"
51 
52 #include "FWCore/Framework/interface/EDProducer.h"
53 #include "FWCore/Framework/interface/ESHandle.h"
54 #include "FWCore/Framework/interface/Event.h"
55 #include "FWCore/Framework/interface/MakerMacros.h"
56 #include "FWCore/Common/interface/TriggerNames.h"
57 #include "FWCore/MessageService/interface/MessageLogger.h"
58 #include "FWCore/Utilities/interface/InputTag.h"
59 #include "FWCore/ParameterSet/interface/ParameterSet.h"
60 
61 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
62 #include "MuonAnalysis/MuonAssociators/interface/PropagateToMuon.h"
63 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
64 
65 class TriggerMatcherToHLTDebug : public edm::EDProducer {
66 public:
67  // Constructor
68  explicit TriggerMatcherToHLTDebug(const edm::ParameterSet &pset);
69 
71  ~TriggerMatcherToHLTDebug() override;
72 
73  // Operations
74  void produce(edm::Event &event, const edm::EventSetup &eventSetup) override;
75  void beginRun(const edm::Run &run, const edm::EventSetup &eventSetup) override;
76 
77 private:
78  typedef edm::AssociationMap<edm::OneToMany<std::vector<L2MuonTrajectorySeed>, std::vector<L2MuonTrajectorySeed> > >
79  SeedMap;
80 
81  edm::EDGetTokenT<edm::View<reco::Muon> > tagToken_;
82  edm::EDGetTokenT<l1extra::L1MuonParticleCollection> l1Token_;
83  PropagateToMuon l1matcher_;
84 
85  std::string metname;
86 
87  //ForL1Assoc
88  double deltaR_;
89 
90  //ForL1Quality
91  int minL1Quality_;
92 
93  //ForL2Filter
94  edm::EDGetTokenT<reco::BeamSpot> beamspotToken_;
95  int min_N_L2;
96  double max_Eta_L2;
97  int min_Nhits_L2;
98  double max_Dr_L2;
99  double max_Dz_L2;
100  double min_Pt_L2;
101  double nsigma_Pt_L2;
102 
103  //ForL3Filter
104  int min_N_L3;
105  double max_Eta_L3;
106  int min_Nhits_L3;
107  double max_Dr_L3;
108  double max_Dz_L3;
109  double min_Pt_L3;
110  double nsigma_Pt_L3;
111 
112  edm::EDGetTokenT<L2MuonTrajectorySeedCollection> theL2SeedsToken_;
113  edm::EDGetTokenT<reco::RecoChargedCandidateCollection> theL2MuonsToken_;
114  edm::EDGetTokenT<L3MuonTrajectorySeedCollection> theL3SeedsToken_;
115  edm::EDGetTokenT<reco::TrackCollection> theL3TkTracksToken_;
116  edm::EDGetTokenT<reco::RecoChargedCandidateCollection> theL3MuonsToken_;
117  edm::EDGetTokenT<SeedMap> seedMapToken_;
118 
120  template <typename T>
121  void storeValueMap(edm::Event &iEvent,
122  const edm::Handle<edm::View<reco::Muon> > &handle,
123  const std::vector<T> &values,
124  const std::string &label) const;
125 };
126 
127 using namespace std;
128 using namespace edm;
129 using namespace l1extra;
130 using namespace reco;
131 
132 // Constructor
133 TriggerMatcherToHLTDebug::TriggerMatcherToHLTDebug(const edm::ParameterSet &pset)
134  : tagToken_(consumes<View<reco::Muon> >(pset.getParameter<edm::InputTag>("tags"))),
135  l1Token_(consumes<L1MuonParticleCollection>(pset.getParameter<edm::InputTag>("l1s"))),
136  l1matcher_(pset.getParameter<edm::ParameterSet>("l1matcherConfig")),
137  deltaR_(pset.getParameter<double>("deltaR")),
138  minL1Quality_(pset.getParameter<int32_t>("MinL1Quality")),
139  beamspotToken_(consumes<BeamSpot>(pset.getParameter<edm::InputTag>("BeamSpotTag"))),
140  min_N_L2(pset.getParameter<int>("MinN_L2")),
141  max_Eta_L2(pset.getParameter<double>("MaxEta_L2")),
142  min_Nhits_L2(pset.getParameter<int>("MinNhits_L2")),
143  max_Dr_L2(pset.getParameter<double>("MaxDr_L2")),
144  max_Dz_L2(pset.getParameter<double>("MaxDz_L2")),
145  min_Pt_L2(pset.getParameter<double>("MinPt_L2")),
146  nsigma_Pt_L2(pset.getParameter<double>("NSigmaPt_L2")),
147  min_N_L3(pset.getParameter<int>("MinN_L3")),
148  max_Eta_L3(pset.getParameter<double>("MaxEta_L3")),
149  min_Nhits_L3(pset.getParameter<int>("MinNhits_L3")),
150  max_Dr_L3(pset.getParameter<double>("MaxDr_L3")),
151  max_Dz_L3(pset.getParameter<double>("MaxDz_L3")),
152  min_Pt_L3(pset.getParameter<double>("MinPt_L3")),
153  nsigma_Pt_L3(pset.getParameter<double>("NSigmaPt_L3")),
154  seedMapToken_(consumes<SeedMap>(pset.getParameter<edm::InputTag>("SeedMapTag"))) {
155  theL2SeedsToken_ = consumes<L2MuonTrajectorySeedCollection>(pset.getParameter<InputTag>("L2Seeds_Collection"));
156  theL2MuonsToken_ = consumes<RecoChargedCandidateCollection>(pset.getParameter<InputTag>("L2Muons_Collection"));
157  theL3SeedsToken_ = consumes<L3MuonTrajectorySeedCollection>(pset.getParameter<InputTag>("L3Seeds_Collection"));
158  theL3TkTracksToken_ = consumes<TrackCollection>(pset.getParameter<InputTag>("L3TkTracks_Collection"));
159  theL3MuonsToken_ = consumes<RecoChargedCandidateCollection>(pset.getParameter<InputTag>("L3Muons_Collection"));
160 
161  metname = "TriggerMatcherToHLTDebug";
162 
163  produces<edm::ValueMap<int> >("propagatesToM2");
164  produces<edm::ValueMap<int> >("hasL1Particle");
165  produces<edm::ValueMap<int> >("hasL1Filtered");
166  produces<edm::ValueMap<int> >("hasL2Seed");
167  produces<edm::ValueMap<int> >("hasL2Muon");
168  produces<edm::ValueMap<int> >("hasL2MuonFiltered");
169  produces<edm::ValueMap<int> >("hasL3Seed");
170  produces<edm::ValueMap<int> >("hasL3Track");
171  produces<edm::ValueMap<int> >("hasL3Muon");
172  produces<edm::ValueMap<int> >("hasL3MuonFiltered");
173 
174  produces<edm::ValueMap<reco::CandidatePtr> >("l1Candidate");
175  produces<edm::ValueMap<reco::CandidatePtr> >("l2Candidate");
176  produces<edm::ValueMap<reco::CandidatePtr> >("l3Candidate");
177 }
178 
179 // Destructor
180 TriggerMatcherToHLTDebug::~TriggerMatcherToHLTDebug() {}
181 
182 // Analyzer
183 void TriggerMatcherToHLTDebug::produce(Event &event, const EventSetup &eventSetup) {
184  Handle<View<reco::Muon> > muons;
185  event.getByToken(tagToken_, muons);
186 
187  Handle<l1extra::L1MuonParticleCollection> L1Muons;
188  event.getByToken(l1Token_, L1Muons);
189 
190  Handle<L2MuonTrajectorySeedCollection> L2Seeds;
191  event.getByToken(theL2SeedsToken_, L2Seeds);
192 
193  Handle<RecoChargedCandidateCollection> L2Muons;
194  event.getByToken(theL2MuonsToken_, L2Muons);
195 
196  Handle<L3MuonTrajectorySeedCollection> L3Seeds;
197  event.getByToken(theL3SeedsToken_, L3Seeds);
198 
199  Handle<reco::TrackCollection> L3TkTracks;
200  event.getByToken(theL3TkTracksToken_, L3TkTracks);
201 
202  Handle<RecoChargedCandidateCollection> L3Muons;
203  event.getByToken(theL3MuonsToken_, L3Muons);
204 
205  //beam spot
206  BeamSpot beamSpot;
207  Handle<BeamSpot> recoBeamSpotHandle;
208  event.getByToken(beamspotToken_, recoBeamSpotHandle);
209  beamSpot = *recoBeamSpotHandle;
210 
211  //new for the MAP!!!!
212  edm::Handle<SeedMap> seedMapHandle;
213  event.getByToken(seedMapToken_, seedMapHandle);
214 
215  size_t nmu = muons->size();
216  std::vector<int> propagatesToM2(nmu), hasL1Particle(nmu), hasL1Filtered(nmu);
217  std::vector<int> hasL2Seed(nmu), hasL2Muon(nmu), hasL2MuonFiltered(nmu);
218  std::vector<int> hasL3Seed(nmu), hasL3Track(nmu), hasL3TrackFiltered(nmu), hasL3Muon(nmu), hasL3MuonFiltered(nmu);
219  std::vector<reco::CandidatePtr> l1ptr(nmu), l2ptr(nmu), l3ptr(nmu);
220 
221  for (size_t i = 0; i < nmu; ++i) {
222  const reco::Muon &mu = (*muons)[i];
223 
224  // Propagate to muon station (using the L1 tool)
225  TrajectoryStateOnSurface stateAtMB2 = l1matcher_.extrapolate(mu);
226  if (!stateAtMB2.isValid())
227  continue;
228  propagatesToM2[i] = 1;
229 
230  double etaTk = stateAtMB2.globalPosition().eta();
231  double phiTk = stateAtMB2.globalPosition().phi();
232  l1extra::L1MuonParticleCollection::const_iterator it;
233  L2MuonTrajectorySeedCollection::const_iterator iSeed;
234  L3MuonTrajectorySeedCollection::const_iterator iSeedL3;
235  RecoChargedCandidateCollection::const_iterator iL2Muon;
236  reco::TrackCollection::const_iterator tktrackL3;
237  RecoChargedCandidateCollection::const_iterator iL3Muon;
238 
239  reco::CandidatePtr thisL1, thisL2, thisL3;
240  for (it = L1Muons->begin(); it != L1Muons->end(); ++it) {
241  const L1MuGMTExtendedCand muonCand = (*it).gmtMuonCand();
242  unsigned int quality = muonCand.quality();
243 
244  double L1phi = (*it).phi();
245  double L1eta = (*it).eta();
246  double L1pt = (*it).pt();
247  double dR = deltaR(etaTk, phiTk, L1eta, L1phi);
248 
249  //CONDIZIONE-> CE NE E' UNA ASSOCIATA?
250  if (dR >= deltaR_)
251  continue;
252  thisL1 = reco::CandidatePtr(L1Muons, it - L1Muons->begin());
253  if (!hasL1Particle[i])
254  l1ptr[i] = thisL1; // if nobody reached L1 before, then we're the best L1 found up to now.
255  hasL1Particle[i]++;
256 
257  if ((quality <= 3) || (L1pt < 7))
258  continue;
259  if (!hasL1Filtered[i])
260  l1ptr[i] = thisL1; // if nobody reached L1 before, then we're the best L1 found up to now.
261  hasL1Filtered[i]++;
262 
263  if (!L2Seeds.isValid())
264  continue;
265  //LOOP SULLA COLLEZIONE DEI SEED
266  for (iSeed = L2Seeds->begin(); iSeed != L2Seeds->end(); ++iSeed) {
267  l1extra::L1MuonParticleRef l1FromSeed = iSeed->l1Particle();
268  if (l1FromSeed.id() != L1Muons.id())
269  throw cms::Exception("CorruptData")
270  << "You're using a different L1 collection than the one used by L2 seeds.\n";
271  if (l1FromSeed.key() != thisL1.key())
272  continue;
273  if (!hasL2Seed[i])
274  l1ptr[i] = thisL1; // if nobody reached here before, we're the best L1
275  hasL2Seed[i]++;
276 
277  if (!L2Muons.isValid())
278  continue;
279  //LOOP SULLA COLLEZIONE L2MUON
280  for (iL2Muon = L2Muons->begin(); iL2Muon != L2Muons->end(); ++iL2Muon) {
281  //MI FACCIO DARE REF E GUARDO SE E' UGUALE AL L2SEED ASSOCIATO
282  //BEFORE THE ASSOCIATION MAP!!!!!
283  //edm::Ref<L2MuonTrajectorySeedCollection> l2seedRef = iL2Muon->track()->seedRef().castTo<edm::Ref<L2MuonTrajectorySeedCollection> >();
284  //l1extra::L1MuonParticleRef l1FromL2 = l2seedRef->l1Particle();
285 
286  //if (l1FromL2.id() != l1FromSeed.id()) throw cms::Exception("CorruptData") << "You're using L2s with a different L1 collection than the one used by L2 seeds.\n";
287  //if (l1FromL2 != l1FromSeed) continue;
288 
289  //AFTER THE ASSOCIATION MAP
290  const edm::RefVector<L2MuonTrajectorySeedCollection> &seeds =
291  (*seedMapHandle)[iL2Muon->track()->seedRef().castTo<edm::Ref<L2MuonTrajectorySeedCollection> >()];
292  // bool isTriggered = false;
293  for (size_t jjj = 0; jjj < seeds.size(); jjj++) {
294  if (seeds[jjj]->l1Particle() != l1FromSeed)
295  continue;
296  }
297 
298  thisL2 = reco::CandidatePtr(L2Muons, iL2Muon - L2Muons->begin());
299  if (!hasL2Muon[i]) {
300  l1ptr[i] = thisL1;
301  l2ptr[i] = thisL2;
302  } // if nobody reached here before, we're the best L1 and L2)
303  hasL2Muon[i]++;
304 
305  LogTrace(metname) << "L2MUON TROVATO!" << endl;
306  const reco::Track &L2Track = *iL2Muon->track();
307  double Eta_L2 = L2Track.eta();
308  double Pt_L2 = L2Track.pt();
309  int nValidHits_L2 = L2Track.numberOfValidHits();
310  double BSPos_L2 = L2Track.dxy(beamSpot.position());
311  double dz_L2 = L2Track.dz();
312  double err0_L2 = L2Track.error(0);
313  double abspar0_L2 = fabs(L2Track.parameter(0));
314  double ptLx_L2 = Pt_L2;
315  if (abspar0_L2 > 0)
316  ptLx_L2 += nsigma_Pt_L2 * err0_L2 / abspar0_L2 * Pt_L2;
317 
318  //GUARDO SE L2MUON ASSOCIATO AVREBBE PASSATO IL FILTRO
319  bool passFilter = (((fabs(Eta_L2)) <= max_Eta_L2) && (nValidHits_L2 >= min_Nhits_L2) &&
320  ((fabs(BSPos_L2)) <= max_Dr_L2) && ((fabs(dz_L2)) <= max_Dz_L2) && (ptLx_L2 >= min_Pt_L2));
321  if (!passFilter)
322  continue;
323  if (!hasL2MuonFiltered[i]) {
324  l1ptr[i] = thisL1;
325  l2ptr[i] = thisL2;
326  } // if nobody reached here before, we're the best L1 and L2)
327  hasL2MuonFiltered[i]++;
328 
329  const reco::TrackRef L2FilteredRef = iL2Muon->track();
330 
331  //########L3 PART##############
332  if (!L3Seeds.isValid())
333  continue;
334  for (iSeedL3 = L3Seeds->begin(); iSeedL3 != L3Seeds->end(); ++iSeedL3) {
335  TrackRef staTrack = iSeedL3->l2Track();
336  if (staTrack != L2FilteredRef)
337  continue;
338  if (!hasL3Seed[i]) {
339  l1ptr[i] = thisL1;
340  l2ptr[i] = thisL2;
341  } // if nobody reached here before, we're the best L1 and L2)
342  hasL3Seed[i]++;
343 
344  if (!L3TkTracks.isValid())
345  continue;
346  for (tktrackL3 = L3TkTracks->begin(); tktrackL3 != L3TkTracks->end(); ++tktrackL3) {
347  edm::Ref<L3MuonTrajectorySeedCollection> l3seedRef =
348  tktrackL3->seedRef().castTo<edm::Ref<L3MuonTrajectorySeedCollection> >();
349  TrackRef staTrack2 = l3seedRef->l2Track();
350 
351  if (staTrack2 != L2FilteredRef)
352  continue;
353  if (!hasL3Track[i]) {
354  l1ptr[i] = thisL1;
355  l2ptr[i] = thisL2;
356  } // if nobody reached here before, we're the best L1 and L2)
357  hasL3Track[i]++;
358 
359  if (!L3Muons.isValid())
360  continue;
361  for (iL3Muon = L3Muons->begin(); iL3Muon != L3Muons->end(); ++iL3Muon) {
362  edm::Ref<L3MuonTrajectorySeedCollection> l3seedRef2 =
363  iL3Muon->track()->seedRef().castTo<edm::Ref<L3MuonTrajectorySeedCollection> >();
364  TrackRef staTrack3 = l3seedRef2->l2Track();
365 
366  if (staTrack3 != L2FilteredRef)
367  continue;
368  thisL3 = reco::CandidatePtr(L3Muons, iL3Muon - L3Muons->begin());
369 
370  if (!hasL3Muon[i]) {
371  l1ptr[i] = thisL1;
372  l2ptr[i] = thisL2;
373  l3ptr[i] = thisL3;
374  } // if nobody reached here before, we're the best L1, L2, L3
375  hasL3Muon[i]++;
376 
377  const reco::Track &L3Track = *iL3Muon->track();
378  double Eta_L3 = L3Track.eta();
379  double Pt_L3 = L3Track.pt();
380  int nValidHits_L3 = L3Track.numberOfValidHits();
381  double BSPos_L3 = L3Track.dxy(beamSpot.position());
382  double dz_L3 = L3Track.dz();
383  double err0_L3 = L3Track.error(0);
384  double abspar0_L3 = fabs(L3Track.parameter(0));
385  double ptLx_L3 = Pt_L3;
386 
387  if (abspar0_L3 > 0)
388  ptLx_L3 += nsigma_Pt_L3 * err0_L3 / abspar0_L3 * Pt_L3;
389 
390  if (((fabs(Eta_L3)) <= max_Eta_L3) && (nValidHits_L3 >= min_Nhits_L3) &&
391  ((fabs(BSPos_L3)) <= max_Dr_L3) && ((fabs(dz_L3)) <= max_Dz_L3) && (ptLx_L3 >= min_Pt_L3)) {
392  if (!hasL3MuonFiltered[i]) {
393  l1ptr[i] = thisL1;
394  l2ptr[i] = thisL2;
395  l3ptr[i] = thisL3;
396  } // if nobody reached here before, we're the best L1, L2, L3
397  hasL3MuonFiltered[i]++;
398 
399  } //L3MUON FILTERED ASSOCIATO TROVATO
400  } //L3MUON LOOP
401  } // L3 TRACKS
402  } // L3 SEEDS
403  } //T L2 MUONS
404  } // L2 SEEDS
405  } //L1 MUONS
406  } // RECO MUONS
407  storeValueMap<int>(event, muons, propagatesToM2, "propagatesToM2");
408  storeValueMap<int>(event, muons, hasL1Particle, "hasL1Particle");
409  storeValueMap<int>(event, muons, hasL1Filtered, "hasL1Filtered");
410  storeValueMap<int>(event, muons, hasL2Seed, "hasL2Seed");
411  storeValueMap<int>(event, muons, hasL2Muon, "hasL2Muon");
412  storeValueMap<int>(event, muons, hasL2MuonFiltered, "hasL2MuonFiltered");
413  storeValueMap<int>(event, muons, hasL3Seed, "hasL3Seed");
414  storeValueMap<int>(event, muons, hasL3Track, "hasL3Track");
415  storeValueMap<int>(event, muons, hasL3Muon, "hasL3Muon");
416  storeValueMap<int>(event, muons, hasL3MuonFiltered, "hasL3MuonFiltered");
417  storeValueMap<reco::CandidatePtr>(event, muons, l1ptr, "l1Candidate");
418  storeValueMap<reco::CandidatePtr>(event, muons, l2ptr, "l2Candidate");
419  storeValueMap<reco::CandidatePtr>(event, muons, l3ptr, "l3Candidate");
420 } // METHOD
421 
422 void TriggerMatcherToHLTDebug::beginRun(const edm::Run &iRun, const edm::EventSetup &iSetup) {
423  l1matcher_.init(iSetup);
424 }
425 
426 template <typename T>
427 void TriggerMatcherToHLTDebug::storeValueMap(edm::Event &iEvent,
428  const edm::Handle<edm::View<reco::Muon> > &handle,
429  const std::vector<T> &values,
430  const std::string &label) const {
431  using namespace edm;
432  using namespace std;
433  unique_ptr<ValueMap<T> > valMap(new ValueMap<T>());
434  typename edm::ValueMap<T>::Filler filler(*valMap);
435  filler.insert(handle, values.begin(), values.end());
436  filler.fill();
437  iEvent.put(std::move(valMap), label);
438 }
439 
440 DEFINE_FWK_MODULE(TriggerMatcherToHLTDebug);
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
TriggerMatcherToHLTDebug::seedMapToken_
edm::EDGetTokenT< SeedMap > seedMapToken_
Definition: TriggerMatcherToHLTDebug.cc:117
TrajectoryStateOnSurface.h
Handle.h
TriggerMatcherToHLTDebug::max_Dr_L2
double max_Dr_L2
Definition: TriggerMatcherToHLTDebug.cc:98
PropagateToMuon.h
mps_fire.i
i
Definition: mps_fire.py:428
L1MuonParticleCollection
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
Muon.h
L1MuGMTExtendedCand
Definition: L1MuGMTExtendedCand.h:46
L3MuonTrajectorySeedCollection.h
L1MuonParticleFwd.h
EDProducer.h
ESHandle.h
TriggerMatcherToHLTDebug::beamspotToken_
edm::EDGetTokenT< reco::BeamSpot > beamspotToken_
Definition: TriggerMatcherToHLTDebug.cc:94
TriggerMatcherToHLTDebug::nsigma_Pt_L3
double nsigma_Pt_L3
Definition: TriggerMatcherToHLTDebug.cc:110
amptDefaultParameters_cff.mu
mu
Definition: amptDefaultParameters_cff.py:16
TriggerMatcherToHLTDebug::minL1Quality_
int minL1Quality_
Definition: TriggerMatcherToHLTDebug.cc:91
patZpeak.handle
handle
Definition: patZpeak.py:23
edm::Run
Definition: Run.h:45
PropagateToMuon::init
void init(const edm::EventSetup &iSetup)
Definition: PropagateToMuon.cc:56
edm::EDGetTokenT
Definition: EDGetToken.h:33
edm
HLT enums.
Definition: AlignableModifier.h:19
AssociationMap.h
TrajectoryStateOnSurface::globalPosition
GlobalPoint globalPosition() const
Definition: TrajectoryStateOnSurface.h:65
TriggerMatcherToHLTDebug::min_Pt_L2
double min_Pt_L2
Definition: TriggerMatcherToHLTDebug.cc:100
TriggerMatcherToHLTDebug::theL2MuonsToken_
edm::EDGetTokenT< reco::RecoChargedCandidateCollection > theL2MuonsToken_
Definition: TriggerMatcherToHLTDebug.cc:113
TriggerMatcherToHLTDebug::SeedMap
edm::AssociationMap< edm::OneToMany< std::vector< L2MuonTrajectorySeed >, std::vector< L2MuonTrajectorySeed > > > SeedMap
Definition: TriggerMatcherToHLTDebug.cc:79
TriggerFilterObjectWithRefs.h
TriggerMatcherToHLTDebug::min_Nhits_L3
int min_Nhits_L3
Definition: TriggerMatcherToHLTDebug.cc:106
edm::RefVector
Definition: EDProductfwd.h:27
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
TriggerMatcherToHLTDebug::storeValueMap
void storeValueMap(edm::Event &iEvent, const edm::Handle< edm::View< reco::Muon > > &handle, const std::vector< T > &values, const std::string &label) const
Store extra information in a ValueMap.
Definition: TriggerMatcherToHLTDebug.cc:427
edm::Ptr::key
key_type key() const
Definition: Ptr.h:163
L3Muons_cfi.L3Muons
L3Muons
Definition: L3Muons_cfi.py:8
edm::Handle
Definition: AssociativeIterator.h:50
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:798
Muon
Definition: Muon.py:1
reco::Muon
Definition: Muon.h:27
edm::Ref< L1MuonParticleCollection >
TriggerMatcherToHLTDebug::~TriggerMatcherToHLTDebug
~TriggerMatcherToHLTDebug() override
Destructor.
Definition: TriggerMatcherToHLTDebug.cc:180
quality
const uint32_t *__restrict__ Quality * quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:109
TriggerMatcherToHLTDebug::min_Pt_L3
double min_Pt_L3
Definition: TriggerMatcherToHLTDebug.cc:109
TriggerMatcherToHLTDebug
Definition: TriggerMatcherToHLTDebug.cc:65
HLTMonTau_cfi.L1Muons
L1Muons
Definition: HLTMonTau_cfi.py:44
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
MessageLogger.h
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
L2MuonTrajectorySeedCollection.h
MakerMacros.h
reco::TrackBase::parameter
double parameter(int i) const
i-th parameter ( i = 0, ... 4 )
Definition: TrackBase.h:723
TriggerMatcherToHLTDebug::metname
std::string metname
Definition: TriggerMatcherToHLTDebug.cc:85
Track.h
TrackFwd.h
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
BeamSpot.h
TriggerMatcherToHLTDebug::l1Token_
edm::EDGetTokenT< l1extra::L1MuonParticleCollection > l1Token_
Definition: TriggerMatcherToHLTDebug.cc:82
contentValuesCheck.values
values
Definition: contentValuesCheck.py:38
MuonFwd.h
L1MuGMTCand::quality
unsigned int quality() const
get quality
Definition: L1MuGMTCand.h:90
reco::BeamSpot
Definition: BeamSpot.h:21
reco::Track
Definition: Track.h:27
TriggerMatcherToHLTDebug::max_Eta_L3
double max_Eta_L3
Definition: TriggerMatcherToHLTDebug.cc:105
OneToMany.h
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:622
PropagateToMuon
Propagate an object (usually a track) to the second muon station. Support for other muon stations wil...
Definition: PropagateToMuon.h:29
TrajectorySeed.h
L3MuonTrajectorySeed.h
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
InitialStep_cff.seeds
seeds
Definition: InitialStep_cff.py:231
edm::View
Definition: CaloClusterFwd.h:14
TriggerMatcherToHLTDebug::min_N_L3
int min_N_L3
Definition: TriggerMatcherToHLTDebug.cc:104
edm::ParameterSet
Definition: ParameterSet.h:47
Event.h
TriggerMatcherToHLTDebug::max_Dr_L3
double max_Dr_L3
Definition: TriggerMatcherToHLTDebug.cc:107
deltaR.h
TriggerMatcherToHLTDebug::theL3SeedsToken_
edm::EDGetTokenT< L3MuonTrajectorySeedCollection > theL3SeedsToken_
Definition: TriggerMatcherToHLTDebug.cc:114
edm::AssociationMap
Definition: AssociationMap.h:48
trigObjTnPSource_cfi.filler
filler
Definition: trigObjTnPSource_cfi.py:21
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:652
TriggerMatcherToHLTDebug::nsigma_Pt_L2
double nsigma_Pt_L2
Definition: TriggerMatcherToHLTDebug.cc:101
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
Ptr.h
createfilelist.int
int
Definition: createfilelist.py:10
TriggerNames.h
iEvent
int iEvent
Definition: GenABIO.cc:224
TriggerMatcherToHLTDebug::min_N_L2
int min_N_L2
Definition: TriggerMatcherToHLTDebug.cc:95
edm::EventSetup
Definition: EventSetup.h:58
TriggerMatcherToHLTDebug::beginRun
void beginRun(const edm::Run &run, const edm::EventSetup &eventSetup) override
Definition: TriggerMatcherToHLTDebug.cc:422
TriggerMatcherToHLTDebug::theL3MuonsToken_
edm::EDGetTokenT< reco::RecoChargedCandidateCollection > theL3MuonsToken_
Definition: TriggerMatcherToHLTDebug.cc:116
reco::TrackBase::error
double error(int i) const
error on specified element
Definition: TrackBase.h:729
InputTag.h
edm::Ptr< Candidate >
ValueMap.h
TriggerMatcherToHLTDebug::deltaR_
double deltaR_
Definition: TriggerMatcherToHLTDebug.cc:88
TriggerMatcherToHLTDebug::produce
void produce(edm::Event &event, const edm::EventSetup &eventSetup) override
Definition: TriggerMatcherToHLTDebug.cc:183
edm::Ref::id
ProductID id() const
Accessor for product ID.
Definition: Ref.h:244
eostools.move
def move(src, dest)
Definition: eostools.py:511
std
Definition: JetResolutionObject.h:76
writedatasetfile.run
run
Definition: writedatasetfile.py:27
StringCutObjectSelector.h
L1MuonParticle.h
RecoChargedCandidate.h
Frameworkfwd.h
edm::ValueMap
Definition: ValueMap.h:107
TriggerMatcherToHLTDebug::min_Nhits_L2
int min_Nhits_L2
Definition: TriggerMatcherToHLTDebug.cc:97
TriggerMatcherToHLTDebug::theL3TkTracksToken_
edm::EDGetTokenT< reco::TrackCollection > theL3TkTracksToken_
Definition: TriggerMatcherToHLTDebug.cc:115
TriggerMatcherToHLTDebug::max_Dz_L2
double max_Dz_L2
Definition: TriggerMatcherToHLTDebug.cc:99
TriggerMatcherToHLTDebug::theL2SeedsToken_
edm::EDGetTokenT< L2MuonTrajectorySeedCollection > theL2SeedsToken_
Definition: TriggerMatcherToHLTDebug.cc:112
edm::EDProducer
Definition: EDProducer.h:35
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
TriggerMatcherToHLTDebug::TriggerMatcherToHLTDebug
TriggerMatcherToHLTDebug(const edm::ParameterSet &pset)
Definition: TriggerMatcherToHLTDebug.cc:133
PropagateToMuon::extrapolate
TrajectoryStateOnSurface extrapolate(const reco::Track &tk) const
Definition: PropagateToMuon.h:40
cms::Exception
Definition: Exception.h:70
reco::CandidatePtr
edm::Ptr< Candidate > CandidatePtr
persistent reference to an object in a collection of Candidate objects
Definition: CandidateFwd.h:25
edm::helper::Filler
Definition: ValueMap.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
View.h
HGC3DClusterGenMatchSelector_cfi.dR
dR
Definition: HGC3DClusterGenMatchSelector_cfi.py:7
L2Muons_cfi.L2Muons
L2Muons
Definition: L2Muons_cfi.py:6
ParameterSet.h
TriggerMatcherToHLTDebug::tagToken_
edm::EDGetTokenT< edm::View< reco::Muon > > tagToken_
Definition: TriggerMatcherToHLTDebug.cc:81
TriggerMatcherToHLTDebug::max_Dz_L3
double max_Dz_L3
Definition: TriggerMatcherToHLTDebug.cc:108
l1extra
Definition: L1EmParticle.h:26
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
event
Definition: event.py:1
L2MuonTrajectorySeed.h
edm::Event
Definition: Event.h:73
RecoChargedCandidateFwd.h
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:608
edm::InputTag
Definition: InputTag.h:15
label
const char * label
Definition: PFTauDecayModeTools.cc:11
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
TriggerMatcherToHLTDebug::l1matcher_
PropagateToMuon l1matcher_
Definition: TriggerMatcherToHLTDebug.cc:83
TriggerMatcherToHLTDebug::max_Eta_L2
double max_Eta_L2
Definition: TriggerMatcherToHLTDebug.cc:96
TrajectoryStateOnSurface::isValid
bool isValid() const
Definition: TrajectoryStateOnSurface.h:54
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
Generated for CMSSW Reference Manual by doxygen 1.8.16