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/Utilities/interface/InputTag.h"
58 #include "FWCore/ParameterSet/interface/ParameterSet.h"
59 
60 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
61 #include "MuonAnalysis/MuonAssociators/interface/PropagateToMuon.h"
62 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
63 
64 class TriggerMatcherToHLTDebug : public edm::EDProducer {
65 public:
66  // Constructor
67  explicit TriggerMatcherToHLTDebug(const edm::ParameterSet &pset);
68 
70  ~TriggerMatcherToHLTDebug() override;
71 
72  // Operations
73  void produce(edm::Event &event, const edm::EventSetup &eventSetup) override;
74  void beginRun(const edm::Run &run, const edm::EventSetup &eventSetup) override;
75 
76 private:
77  typedef edm::AssociationMap<edm::OneToMany<std::vector<L2MuonTrajectorySeed>, std::vector<L2MuonTrajectorySeed> > >
78  SeedMap;
79 
80  edm::EDGetTokenT<edm::View<reco::Muon> > tagToken_;
81  edm::EDGetTokenT<l1extra::L1MuonParticleCollection> l1Token_;
82  PropagateToMuon l1matcher_;
83 
84  std::string metname;
85 
86  //ForL1Assoc
87  double deltaR_;
88 
89  //ForL1Quality
90  int minL1Quality_;
91 
92  //ForL2Filter
93  edm::EDGetTokenT<reco::BeamSpot> beamspotToken_;
94  int min_N_L2;
95  double max_Eta_L2;
96  int min_Nhits_L2;
97  double max_Dr_L2;
98  double max_Dz_L2;
99  double min_Pt_L2;
100  double nsigma_Pt_L2;
101 
102  //ForL3Filter
103  int min_N_L3;
104  double max_Eta_L3;
105  int min_Nhits_L3;
106  double max_Dr_L3;
107  double max_Dz_L3;
108  double min_Pt_L3;
109  double nsigma_Pt_L3;
110 
111  edm::EDGetTokenT<L2MuonTrajectorySeedCollection> theL2SeedsToken_;
112  edm::EDGetTokenT<reco::RecoChargedCandidateCollection> theL2MuonsToken_;
113  edm::EDGetTokenT<L3MuonTrajectorySeedCollection> theL3SeedsToken_;
114  edm::EDGetTokenT<reco::TrackCollection> theL3TkTracksToken_;
115  edm::EDGetTokenT<reco::RecoChargedCandidateCollection> theL3MuonsToken_;
116  edm::EDGetTokenT<SeedMap> seedMapToken_;
117 
119  template <typename T>
120  void storeValueMap(edm::Event &iEvent,
121  const edm::Handle<edm::View<reco::Muon> > &handle,
122  const std::vector<T> &values,
123  const std::string &label) const;
124 };
125 
126 using namespace std;
127 using namespace edm;
128 using namespace l1extra;
129 using namespace reco;
130 
131 // Constructor
132 TriggerMatcherToHLTDebug::TriggerMatcherToHLTDebug(const edm::ParameterSet &pset)
133  : tagToken_(consumes<View<reco::Muon> >(pset.getParameter<edm::InputTag>("tags"))),
134  l1Token_(consumes<L1MuonParticleCollection>(pset.getParameter<edm::InputTag>("l1s"))),
135  l1matcher_(pset.getParameter<edm::ParameterSet>("l1matcherConfig")),
136  deltaR_(pset.getParameter<double>("deltaR")),
137  minL1Quality_(pset.getParameter<int32_t>("MinL1Quality")),
138  beamspotToken_(consumes<BeamSpot>(pset.getParameter<edm::InputTag>("BeamSpotTag"))),
139  min_N_L2(pset.getParameter<int>("MinN_L2")),
140  max_Eta_L2(pset.getParameter<double>("MaxEta_L2")),
141  min_Nhits_L2(pset.getParameter<int>("MinNhits_L2")),
142  max_Dr_L2(pset.getParameter<double>("MaxDr_L2")),
143  max_Dz_L2(pset.getParameter<double>("MaxDz_L2")),
144  min_Pt_L2(pset.getParameter<double>("MinPt_L2")),
145  nsigma_Pt_L2(pset.getParameter<double>("NSigmaPt_L2")),
146  min_N_L3(pset.getParameter<int>("MinN_L3")),
147  max_Eta_L3(pset.getParameter<double>("MaxEta_L3")),
148  min_Nhits_L3(pset.getParameter<int>("MinNhits_L3")),
149  max_Dr_L3(pset.getParameter<double>("MaxDr_L3")),
150  max_Dz_L3(pset.getParameter<double>("MaxDz_L3")),
151  min_Pt_L3(pset.getParameter<double>("MinPt_L3")),
152  nsigma_Pt_L3(pset.getParameter<double>("NSigmaPt_L3")),
153  seedMapToken_(consumes<SeedMap>(pset.getParameter<edm::InputTag>("SeedMapTag"))) {
154  theL2SeedsToken_ = consumes<L2MuonTrajectorySeedCollection>(pset.getParameter<InputTag>("L2Seeds_Collection"));
155  theL2MuonsToken_ = consumes<RecoChargedCandidateCollection>(pset.getParameter<InputTag>("L2Muons_Collection"));
156  theL3SeedsToken_ = consumes<L3MuonTrajectorySeedCollection>(pset.getParameter<InputTag>("L3Seeds_Collection"));
157  theL3TkTracksToken_ = consumes<TrackCollection>(pset.getParameter<InputTag>("L3TkTracks_Collection"));
158  theL3MuonsToken_ = consumes<RecoChargedCandidateCollection>(pset.getParameter<InputTag>("L3Muons_Collection"));
159 
160  metname = "TriggerMatcherToHLTDebug";
161 
162  produces<edm::ValueMap<int> >("propagatesToM2");
163  produces<edm::ValueMap<int> >("hasL1Particle");
164  produces<edm::ValueMap<int> >("hasL1Filtered");
165  produces<edm::ValueMap<int> >("hasL2Seed");
166  produces<edm::ValueMap<int> >("hasL2Muon");
167  produces<edm::ValueMap<int> >("hasL2MuonFiltered");
168  produces<edm::ValueMap<int> >("hasL3Seed");
169  produces<edm::ValueMap<int> >("hasL3Track");
170  produces<edm::ValueMap<int> >("hasL3Muon");
171  produces<edm::ValueMap<int> >("hasL3MuonFiltered");
172 
173  produces<edm::ValueMap<reco::CandidatePtr> >("l1Candidate");
174  produces<edm::ValueMap<reco::CandidatePtr> >("l2Candidate");
175  produces<edm::ValueMap<reco::CandidatePtr> >("l3Candidate");
176 }
177 
178 // Destructor
179 TriggerMatcherToHLTDebug::~TriggerMatcherToHLTDebug() {}
180 
181 // Analyzer
182 void TriggerMatcherToHLTDebug::produce(Event &event, const EventSetup &eventSetup) {
183  Handle<View<reco::Muon> > muons;
184  event.getByToken(tagToken_, muons);
185 
186  Handle<l1extra::L1MuonParticleCollection> L1Muons;
187  event.getByToken(l1Token_, L1Muons);
188 
189  Handle<L2MuonTrajectorySeedCollection> L2Seeds;
190  event.getByToken(theL2SeedsToken_, L2Seeds);
191 
192  Handle<RecoChargedCandidateCollection> L2Muons;
193  event.getByToken(theL2MuonsToken_, L2Muons);
194 
195  Handle<L3MuonTrajectorySeedCollection> L3Seeds;
196  event.getByToken(theL3SeedsToken_, L3Seeds);
197 
198  Handle<reco::TrackCollection> L3TkTracks;
199  event.getByToken(theL3TkTracksToken_, L3TkTracks);
200 
201  Handle<RecoChargedCandidateCollection> L3Muons;
202  event.getByToken(theL3MuonsToken_, L3Muons);
203 
204  //beam spot
205  BeamSpot beamSpot;
206  Handle<BeamSpot> recoBeamSpotHandle;
207  event.getByToken(beamspotToken_, recoBeamSpotHandle);
208  beamSpot = *recoBeamSpotHandle;
209 
210  //new for the MAP!!!!
211  edm::Handle<SeedMap> seedMapHandle;
212  event.getByToken(seedMapToken_, seedMapHandle);
213 
214  size_t nmu = muons->size();
215  std::vector<int> propagatesToM2(nmu), hasL1Particle(nmu), hasL1Filtered(nmu);
216  std::vector<int> hasL2Seed(nmu), hasL2Muon(nmu), hasL2MuonFiltered(nmu);
217  std::vector<int> hasL3Seed(nmu), hasL3Track(nmu), hasL3TrackFiltered(nmu), hasL3Muon(nmu), hasL3MuonFiltered(nmu);
218  std::vector<reco::CandidatePtr> l1ptr(nmu), l2ptr(nmu), l3ptr(nmu);
219 
220  for (size_t i = 0; i < nmu; ++i) {
221  const reco::Muon &mu = (*muons)[i];
222 
223  // Propagate to muon station (using the L1 tool)
224  TrajectoryStateOnSurface stateAtMB2 = l1matcher_.extrapolate(mu);
225  if (!stateAtMB2.isValid())
226  continue;
227  propagatesToM2[i] = 1;
228 
229  double etaTk = stateAtMB2.globalPosition().eta();
230  double phiTk = stateAtMB2.globalPosition().phi();
231  l1extra::L1MuonParticleCollection::const_iterator it;
232  L2MuonTrajectorySeedCollection::const_iterator iSeed;
233  L3MuonTrajectorySeedCollection::const_iterator iSeedL3;
234  RecoChargedCandidateCollection::const_iterator iL2Muon;
235  reco::TrackCollection::const_iterator tktrackL3;
236  RecoChargedCandidateCollection::const_iterator iL3Muon;
237 
238  reco::CandidatePtr thisL1, thisL2, thisL3;
239  for (it = L1Muons->begin(); it != L1Muons->end(); ++it) {
240  const L1MuGMTExtendedCand muonCand = (*it).gmtMuonCand();
241  unsigned int quality = muonCand.quality();
242 
243  double L1phi = (*it).phi();
244  double L1eta = (*it).eta();
245  double L1pt = (*it).pt();
246  double dR = deltaR(etaTk, phiTk, L1eta, L1phi);
247 
248  //CONDIZIONE-> CE NE E' UNA ASSOCIATA?
249  if (dR >= deltaR_)
250  continue;
251  thisL1 = reco::CandidatePtr(L1Muons, it - L1Muons->begin());
252  if (!hasL1Particle[i])
253  l1ptr[i] = thisL1; // if nobody reached L1 before, then we're the best L1 found up to now.
254  hasL1Particle[i]++;
255 
256  if ((quality <= 3) || (L1pt < 7))
257  continue;
258  if (!hasL1Filtered[i])
259  l1ptr[i] = thisL1; // if nobody reached L1 before, then we're the best L1 found up to now.
260  hasL1Filtered[i]++;
261 
262  if (!L2Seeds.isValid())
263  continue;
264  //LOOP SULLA COLLEZIONE DEI SEED
265  for (iSeed = L2Seeds->begin(); iSeed != L2Seeds->end(); ++iSeed) {
266  l1extra::L1MuonParticleRef l1FromSeed = iSeed->l1Particle();
267  if (l1FromSeed.id() != L1Muons.id())
268  throw cms::Exception("CorruptData")
269  << "You're using a different L1 collection than the one used by L2 seeds.\n";
270  if (l1FromSeed.key() != thisL1.key())
271  continue;
272  if (!hasL2Seed[i])
273  l1ptr[i] = thisL1; // if nobody reached here before, we're the best L1
274  hasL2Seed[i]++;
275 
276  if (!L2Muons.isValid())
277  continue;
278  //LOOP SULLA COLLEZIONE L2MUON
279  for (iL2Muon = L2Muons->begin(); iL2Muon != L2Muons->end(); ++iL2Muon) {
280  //MI FACCIO DARE REF E GUARDO SE E' UGUALE AL L2SEED ASSOCIATO
281  //BEFORE THE ASSOCIATION MAP!!!!!
282  //edm::Ref<L2MuonTrajectorySeedCollection> l2seedRef = iL2Muon->track()->seedRef().castTo<edm::Ref<L2MuonTrajectorySeedCollection> >();
283  //l1extra::L1MuonParticleRef l1FromL2 = l2seedRef->l1Particle();
284 
285  //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";
286  //if (l1FromL2 != l1FromSeed) continue;
287 
288  //AFTER THE ASSOCIATION MAP
289  const edm::RefVector<L2MuonTrajectorySeedCollection> &seeds =
290  (*seedMapHandle)[iL2Muon->track()->seedRef().castTo<edm::Ref<L2MuonTrajectorySeedCollection> >()];
291  // bool isTriggered = false;
292  for (size_t jjj = 0; jjj < seeds.size(); jjj++) {
293  if (seeds[jjj]->l1Particle() != l1FromSeed)
294  continue;
295  }
296 
297  thisL2 = reco::CandidatePtr(L2Muons, iL2Muon - L2Muons->begin());
298  if (!hasL2Muon[i]) {
299  l1ptr[i] = thisL1;
300  l2ptr[i] = thisL2;
301  } // if nobody reached here before, we're the best L1 and L2)
302  hasL2Muon[i]++;
303 
304  LogTrace(metname) << "L2MUON TROVATO!" << endl;
305  const reco::Track &L2Track = *iL2Muon->track();
306  double Eta_L2 = L2Track.eta();
307  double Pt_L2 = L2Track.pt();
308  int nValidHits_L2 = L2Track.numberOfValidHits();
309  double BSPos_L2 = L2Track.dxy(beamSpot.position());
310  double dz_L2 = L2Track.dz();
311  double err0_L2 = L2Track.error(0);
312  double abspar0_L2 = fabs(L2Track.parameter(0));
313  double ptLx_L2 = Pt_L2;
314  if (abspar0_L2 > 0)
315  ptLx_L2 += nsigma_Pt_L2 * err0_L2 / abspar0_L2 * Pt_L2;
316 
317  //GUARDO SE L2MUON ASSOCIATO AVREBBE PASSATO IL FILTRO
318  bool passFilter = (((fabs(Eta_L2)) <= max_Eta_L2) && (nValidHits_L2 >= min_Nhits_L2) &&
319  ((fabs(BSPos_L2)) <= max_Dr_L2) && ((fabs(dz_L2)) <= max_Dz_L2) && (ptLx_L2 >= min_Pt_L2));
320  if (!passFilter)
321  continue;
322  if (!hasL2MuonFiltered[i]) {
323  l1ptr[i] = thisL1;
324  l2ptr[i] = thisL2;
325  } // if nobody reached here before, we're the best L1 and L2)
326  hasL2MuonFiltered[i]++;
327 
328  const reco::TrackRef L2FilteredRef = iL2Muon->track();
329 
330  //########L3 PART##############
331  if (!L3Seeds.isValid())
332  continue;
333  for (iSeedL3 = L3Seeds->begin(); iSeedL3 != L3Seeds->end(); ++iSeedL3) {
334  TrackRef staTrack = iSeedL3->l2Track();
335  if (staTrack != L2FilteredRef)
336  continue;
337  if (!hasL3Seed[i]) {
338  l1ptr[i] = thisL1;
339  l2ptr[i] = thisL2;
340  } // if nobody reached here before, we're the best L1 and L2)
341  hasL3Seed[i]++;
342 
343  if (!L3TkTracks.isValid())
344  continue;
345  for (tktrackL3 = L3TkTracks->begin(); tktrackL3 != L3TkTracks->end(); ++tktrackL3) {
346  edm::Ref<L3MuonTrajectorySeedCollection> l3seedRef =
347  tktrackL3->seedRef().castTo<edm::Ref<L3MuonTrajectorySeedCollection> >();
348  TrackRef staTrack2 = l3seedRef->l2Track();
349 
350  if (staTrack2 != L2FilteredRef)
351  continue;
352  if (!hasL3Track[i]) {
353  l1ptr[i] = thisL1;
354  l2ptr[i] = thisL2;
355  } // if nobody reached here before, we're the best L1 and L2)
356  hasL3Track[i]++;
357 
358  if (!L3Muons.isValid())
359  continue;
360  for (iL3Muon = L3Muons->begin(); iL3Muon != L3Muons->end(); ++iL3Muon) {
361  edm::Ref<L3MuonTrajectorySeedCollection> l3seedRef2 =
362  iL3Muon->track()->seedRef().castTo<edm::Ref<L3MuonTrajectorySeedCollection> >();
363  TrackRef staTrack3 = l3seedRef2->l2Track();
364 
365  if (staTrack3 != L2FilteredRef)
366  continue;
367  thisL3 = reco::CandidatePtr(L3Muons, iL3Muon - L3Muons->begin());
368 
369  if (!hasL3Muon[i]) {
370  l1ptr[i] = thisL1;
371  l2ptr[i] = thisL2;
372  l3ptr[i] = thisL3;
373  } // if nobody reached here before, we're the best L1, L2, L3
374  hasL3Muon[i]++;
375 
376  const reco::Track &L3Track = *iL3Muon->track();
377  double Eta_L3 = L3Track.eta();
378  double Pt_L3 = L3Track.pt();
379  int nValidHits_L3 = L3Track.numberOfValidHits();
380  double BSPos_L3 = L3Track.dxy(beamSpot.position());
381  double dz_L3 = L3Track.dz();
382  double err0_L3 = L3Track.error(0);
383  double abspar0_L3 = fabs(L3Track.parameter(0));
384  double ptLx_L3 = Pt_L3;
385 
386  if (abspar0_L3 > 0)
387  ptLx_L3 += nsigma_Pt_L3 * err0_L3 / abspar0_L3 * Pt_L3;
388 
389  if (((fabs(Eta_L3)) <= max_Eta_L3) && (nValidHits_L3 >= min_Nhits_L3) &&
390  ((fabs(BSPos_L3)) <= max_Dr_L3) && ((fabs(dz_L3)) <= max_Dz_L3) && (ptLx_L3 >= min_Pt_L3)) {
391  if (!hasL3MuonFiltered[i]) {
392  l1ptr[i] = thisL1;
393  l2ptr[i] = thisL2;
394  l3ptr[i] = thisL3;
395  } // if nobody reached here before, we're the best L1, L2, L3
396  hasL3MuonFiltered[i]++;
397 
398  } //L3MUON FILTERED ASSOCIATO TROVATO
399  } //L3MUON LOOP
400  } // L3 TRACKS
401  } // L3 SEEDS
402  } //T L2 MUONS
403  } // L2 SEEDS
404  } //L1 MUONS
405  } // RECO MUONS
406  storeValueMap<int>(event, muons, propagatesToM2, "propagatesToM2");
407  storeValueMap<int>(event, muons, hasL1Particle, "hasL1Particle");
408  storeValueMap<int>(event, muons, hasL1Filtered, "hasL1Filtered");
409  storeValueMap<int>(event, muons, hasL2Seed, "hasL2Seed");
410  storeValueMap<int>(event, muons, hasL2Muon, "hasL2Muon");
411  storeValueMap<int>(event, muons, hasL2MuonFiltered, "hasL2MuonFiltered");
412  storeValueMap<int>(event, muons, hasL3Seed, "hasL3Seed");
413  storeValueMap<int>(event, muons, hasL3Track, "hasL3Track");
414  storeValueMap<int>(event, muons, hasL3Muon, "hasL3Muon");
415  storeValueMap<int>(event, muons, hasL3MuonFiltered, "hasL3MuonFiltered");
416  storeValueMap<reco::CandidatePtr>(event, muons, l1ptr, "l1Candidate");
417  storeValueMap<reco::CandidatePtr>(event, muons, l2ptr, "l2Candidate");
418  storeValueMap<reco::CandidatePtr>(event, muons, l3ptr, "l3Candidate");
419 } // METHOD
420 
421 void TriggerMatcherToHLTDebug::beginRun(const edm::Run &iRun, const edm::EventSetup &iSetup) {
422  l1matcher_.init(iSetup);
423 }
424 
425 template <typename T>
426 void TriggerMatcherToHLTDebug::storeValueMap(edm::Event &iEvent,
427  const edm::Handle<edm::View<reco::Muon> > &handle,
428  const std::vector<T> &values,
429  const std::string &label) const {
430  using namespace edm;
431  using namespace std;
432  unique_ptr<ValueMap<T> > valMap(new ValueMap<T>());
433  typename edm::ValueMap<T>::Filler filler(*valMap);
434  filler.insert(handle, values.begin(), values.end());
435  filler.fill();
436  iEvent.put(std::move(valMap), label);
437 }
438 
439 DEFINE_FWK_MODULE(TriggerMatcherToHLTDebug);
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
TriggerMatcherToHLTDebug::seedMapToken_
edm::EDGetTokenT< SeedMap > seedMapToken_
Definition: TriggerMatcherToHLTDebug.cc:116
TrajectoryStateOnSurface.h
Handle.h
TriggerMatcherToHLTDebug::max_Dr_L2
double max_Dr_L2
Definition: TriggerMatcherToHLTDebug.cc:97
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:93
TriggerMatcherToHLTDebug::nsigma_Pt_L3
double nsigma_Pt_L3
Definition: TriggerMatcherToHLTDebug.cc:109
amptDefaultParameters_cff.mu
mu
Definition: amptDefaultParameters_cff.py:16
TriggerMatcherToHLTDebug::minL1Quality_
int minL1Quality_
Definition: TriggerMatcherToHLTDebug.cc:90
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:99
TriggerMatcherToHLTDebug::theL2MuonsToken_
edm::EDGetTokenT< reco::RecoChargedCandidateCollection > theL2MuonsToken_
Definition: TriggerMatcherToHLTDebug.cc:112
TriggerMatcherToHLTDebug::SeedMap
edm::AssociationMap< edm::OneToMany< std::vector< L2MuonTrajectorySeed >, std::vector< L2MuonTrajectorySeed > > > SeedMap
Definition: TriggerMatcherToHLTDebug.cc:78
TriggerFilterObjectWithRefs.h
TriggerMatcherToHLTDebug::min_Nhits_L3
int min_Nhits_L3
Definition: TriggerMatcherToHLTDebug.cc:105
edm::RefVector
Definition: EDProductfwd.h:27
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:46
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:426
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:179
quality
const uint32_t *__restrict__ Quality * quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:122
TriggerMatcherToHLTDebug::min_Pt_L3
double min_Pt_L3
Definition: TriggerMatcherToHLTDebug.cc:108
TriggerMatcherToHLTDebug
Definition: TriggerMatcherToHLTDebug.cc:64
HLTMonTau_cfi.L1Muons
L1Muons
Definition: HLTMonTau_cfi.py:44
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
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:84
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:81
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:104
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
edm::View
Definition: CaloClusterFwd.h:14
TriggerMatcherToHLTDebug::min_N_L3
int min_N_L3
Definition: TriggerMatcherToHLTDebug.cc:103
edm::ParameterSet
Definition: ParameterSet.h:47
Event.h
TriggerMatcherToHLTDebug::max_Dr_L3
double max_Dr_L3
Definition: TriggerMatcherToHLTDebug.cc:106
deltaR.h
TriggerMatcherToHLTDebug::theL3SeedsToken_
edm::EDGetTokenT< L3MuonTrajectorySeedCollection > theL3SeedsToken_
Definition: TriggerMatcherToHLTDebug.cc:113
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:100
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:94
edm::EventSetup
Definition: EventSetup.h:58
TriggerMatcherToHLTDebug::beginRun
void beginRun(const edm::Run &run, const edm::EventSetup &eventSetup) override
Definition: TriggerMatcherToHLTDebug.cc:421
TriggerMatcherToHLTDebug::theL3MuonsToken_
edm::EDGetTokenT< reco::RecoChargedCandidateCollection > theL3MuonsToken_
Definition: TriggerMatcherToHLTDebug.cc:115
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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:87
TriggerMatcherToHLTDebug::produce
void produce(edm::Event &event, const edm::EventSetup &eventSetup) override
Definition: TriggerMatcherToHLTDebug.cc:182
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
DetachedQuadStep_cff.seeds
seeds
Definition: DetachedQuadStep_cff.py:195
L1MuonParticle.h
RecoChargedCandidate.h
Frameworkfwd.h
edm::ValueMap
Definition: ValueMap.h:107
TriggerMatcherToHLTDebug::min_Nhits_L2
int min_Nhits_L2
Definition: TriggerMatcherToHLTDebug.cc:96
TriggerMatcherToHLTDebug::theL3TkTracksToken_
edm::EDGetTokenT< reco::TrackCollection > theL3TkTracksToken_
Definition: TriggerMatcherToHLTDebug.cc:114
TriggerMatcherToHLTDebug::max_Dz_L2
double max_Dz_L2
Definition: TriggerMatcherToHLTDebug.cc:98
TriggerMatcherToHLTDebug::theL2SeedsToken_
edm::EDGetTokenT< L2MuonTrajectorySeedCollection > theL2SeedsToken_
Definition: TriggerMatcherToHLTDebug.cc:111
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:132
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:7
ParameterSet.h
TriggerMatcherToHLTDebug::tagToken_
edm::EDGetTokenT< edm::View< reco::Muon > > tagToken_
Definition: TriggerMatcherToHLTDebug.cc:80
TriggerMatcherToHLTDebug::max_Dz_L3
double max_Dz_L3
Definition: TriggerMatcherToHLTDebug.cc:107
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:82
TriggerMatcherToHLTDebug::max_Eta_L2
double max_Eta_L2
Definition: TriggerMatcherToHLTDebug.cc:95
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