CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Private Attributes
TrackEfficiencyMonitor Class Reference

#include <DQM/TrackerMonitorTrack/src/TrackEfficiencyMonitor.cc>

Inheritance diagram for TrackEfficiencyMonitor:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

Public Types

enum  SemiCylinder { Up, Down }
 
typedef reco::Track Track
 
typedef reco::TrackCollection TrackCollection
 
- Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 

Public Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 
void bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 
SemiCylinder checkSemiCylinder (const Track &)
 
int compatibleLayers (const NavigationSchool &navigationSchool, TrajectoryStateOnSurface theTSOS)
 
std::pair< TrajectoryStateOnSurface, const DetLayer * > findNextLayer (TrajectoryStateOnSurface startTSOS, const std::vector< const DetLayer * > &trackCompatibleLayers, bool isUpMuon)
 
void testSTATracks (edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks)
 
void testTrackerTracks (edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks, const NavigationSchool &navigationSchool)
 
 TrackEfficiencyMonitor (const edm::ParameterSet &)
 
bool trackerAcceptance (TrajectoryStateOnSurface theTSOS, double theRadius, double theMaxZ)
 
 ~TrackEfficiencyMonitor () override
 
- Public Member Functions inherited from DQMEDAnalyzer
void accumulate (edm::Event const &event, edm::EventSetup const &setup) final
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
void beginStream (edm::StreamID id) final
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
void endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

Private Attributes

edm::ESHandle< MagneticField > bField
 
edm::ParameterSet conf_
 
MonitorElement * deltaX
 
MonitorElement * deltaY
 
DQMStore * dqmStore_
 
int failedToPropagate
 
bool findDetLayer
 
MonitorElement * GlobalMuonPtEtaPhiHighPt
 
MonitorElement * GlobalMuonPtEtaPhiLowPt
 
std::string histname
 
bool isBFieldOff_
 
edm::ESHandle< MeasurementTracker > measurementTrackerHandle
 
MonitorElement * muonCompatibleLayers
 
MonitorElement * muonD0
 
MonitorElement * muonEta
 
MonitorElement * muonPhi
 
edm::EDGetTokenT< edm::View< reco::Muon > > muonToken_
 
MonitorElement * muonX
 
MonitorElement * muonY
 
MonitorElement * muonZ
 
int nCompatibleLayers
 
MonitorElement * signDeltaX
 
MonitorElement * signDeltaY
 
MonitorElement * StandaloneMuonPtEtaPhiHighPt
 
MonitorElement * StandaloneMuonPtEtaPhiLowPt
 
edm::ESHandle< GeometricSearchTracker > theGeometricSearchTracker
 
double theMaxZ_
 
MuonServiceProxy * theMuonServiceProxy
 
const DirectTrackerNavigation * theNavigation
 
edm::ESHandle< Propagator > thePropagator
 
edm::ESHandle< Propagator > thePropagatorCyl
 
double theRadius_
 
edm::InputTag theSTATracksLabel_
 
edm::EDGetTokenT< reco::TrackCollection > theSTATracksToken_
 
edm::InputTag theTKTracksLabel_
 
edm::EDGetTokenT< reco::TrackCollection > theTKTracksToken_
 
edm::ESHandle< GeometricSearchTracker > theTracker
 
edm::ESHandle< TransientTrackBuilder > theTTrackBuilder
 
MonitorElement * trackCompatibleLayers
 
MonitorElement * trackD0
 
bool trackEfficiency_
 
MonitorElement * trackEta
 
MonitorElement * trackPhi
 
MonitorElement * trackX
 
MonitorElement * trackY
 
MonitorElement * trackZ
 

Additional Inherited Members

- Static Public Member Functions inherited from DQMEDAnalyzer
static void globalEndJob (DQMEDAnalyzerGlobalCache const *)
 
static void globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
 
static void globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
 
static std::unique_ptr< DQMEDAnalyzerGlobalCache > initializeGlobalCache (edm::ParameterSet const &)
 
- Protected Member Functions inherited from DQMEDAnalyzer
uint64_t meId () const
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken > lumiToken_
 
edm::EDPutTokenT< DQMToken > runToken_
 
unsigned int streamId_
 

Detailed Description

Monitoring source to measure the track efficiency

Definition at line 40 of file TrackEfficiencyMonitor.h.

Member Typedef Documentation

◆ Track

typedef reco::Track TrackEfficiencyMonitor::Track

Definition at line 42 of file TrackEfficiencyMonitor.h.

◆ TrackCollection

typedef reco::TrackCollection TrackEfficiencyMonitor::TrackCollection

Definition at line 43 of file TrackEfficiencyMonitor.h.

Member Enumeration Documentation

◆ SemiCylinder

enum TrackEfficiencyMonitor::SemiCylinder
Enumerator
Up 
Down 

Definition at line 50 of file TrackEfficiencyMonitor.h.

50 { Up, Down };

Constructor & Destructor Documentation

◆ TrackEfficiencyMonitor()

TrackEfficiencyMonitor::TrackEfficiencyMonitor ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 47 of file TrackEfficiencyMonitor.cc.

49 {
50  dqmStore_ = edm::Service<DQMStore>().operator->();
51 
52  theRadius_ = iConfig.getParameter<double>("theRadius");
53  theMaxZ_ = iConfig.getParameter<double>("theMaxZ");
54  isBFieldOff_ = iConfig.getParameter<bool>("isBFieldOff");
55  trackEfficiency_ = iConfig.getParameter<bool>("trackEfficiency");
56  theTKTracksLabel_ = iConfig.getParameter<edm::InputTag>("TKTrackCollection");
57  theSTATracksLabel_ = iConfig.getParameter<edm::InputTag>("STATrackCollection");
58  muonToken_ = consumes<edm::View<reco::Muon> >(iConfig.getParameter<edm::InputTag>("muoncoll"));
59 
60  theTKTracksToken_ = consumes<reco::TrackCollection>(theTKTracksLabel_);
61  theSTATracksToken_ = consumes<reco::TrackCollection>(theSTATracksLabel_);
62 
63  conf_ = iConfig;
64 }

References conf_, dqmStore_, edm::ParameterSet::getParameter(), isBFieldOff_, muonToken_, theMaxZ_, theRadius_, theSTATracksLabel_, theSTATracksToken_, theTKTracksLabel_, theTKTracksToken_, and trackEfficiency_.

◆ ~TrackEfficiencyMonitor()

TrackEfficiencyMonitor::~TrackEfficiencyMonitor ( )
override

Definition at line 67 of file TrackEfficiencyMonitor.cc.

69 {}

Member Function Documentation

◆ analyze()

void TrackEfficiencyMonitor::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 276 of file TrackEfficiencyMonitor.cc.

278 {
279  edm::Handle<reco::TrackCollection> tkTracks;
280  iEvent.getByToken(theTKTracksToken_, tkTracks);
281  edm::Handle<reco::TrackCollection> staTracks;
282  iEvent.getByToken(theSTATracksToken_, staTracks);
283  edm::ESHandle<NavigationSchool> nav;
284  iSetup.get<NavigationSchoolRecord>().get("CosmicNavigationSchool", nav);
285  iSetup.get<CkfComponentsRecord>().get(measurementTrackerHandle);
286 
287  //initialize values
288  failedToPropagate = 0;
289  nCompatibleLayers = 0;
290  findDetLayer = false;
291 
292  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", theTTrackBuilder);
293  iSetup.get<TrackingComponentsRecord>().get("SteppingHelixPropagatorAny", thePropagator);
294  iSetup.get<IdealMagneticFieldRecord>().get(bField);
295  iSetup.get<TrackerRecoGeometryRecord>().get(theTracker);
296  theNavigation = new DirectTrackerNavigation(theTracker);
297 
298  edm::Handle<edm::View<reco::Muon> > muons;
299  iEvent.getByToken(muonToken_, muons);
300  if (!muons.isValid())
301  return;
302  for (edm::View<reco::Muon>::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
303  if ((*muon).pt() < 5)
304  continue;
305  if (fabs((*muon).eta()) > 2.4)
306  continue;
307  if ((*muon).vertexNormalizedChi2() > 10)
308  continue;
309  if ((*muon).isStandAloneMuon() and (*muon).isGlobalMuon()) {
310  if ((*muon).pt() < 20)
311  GlobalMuonPtEtaPhiLowPt->Fill((*muon).eta(), (*muon).phi());
312  else
313  GlobalMuonPtEtaPhiHighPt->Fill((*muon).eta(), (*muon).phi());
314  }
315  if ((*muon).isStandAloneMuon()) {
316  if ((*muon).pt() < 20)
317  StandaloneMuonPtEtaPhiLowPt->Fill((*muon).eta(), (*muon).phi());
318  else
319  StandaloneMuonPtEtaPhiHighPt->Fill((*muon).eta(), (*muon).phi());
320  }
321  }
322  if (trackEfficiency_) {
323  //---------------------------------------------------
324  // Select muons with good quality
325  // If B field is on, no up-down matching between the muons
326  //---------------------------------------------------
327  bool isGoodMuon = false;
328  double mudd0 = 0., mudphi = 0., muddsz = 0., mudeta = 0.;
329  if (isBFieldOff_) {
330  if (staTracks->size() == 2) {
331  for (unsigned int bindex = 0; bindex < staTracks->size(); ++bindex) {
332  if (0 == bindex) {
333  mudd0 += (*staTracks)[bindex].d0();
334  mudphi += (*staTracks)[bindex].phi();
335  muddsz += (*staTracks)[bindex].dsz();
336  mudeta += (*staTracks)[bindex].eta();
337  }
338  if (1 == bindex) {
339  mudd0 -= (*staTracks)[bindex].d0();
340  mudphi -= (*staTracks)[bindex].phi();
341  muddsz -= (*staTracks)[bindex].dsz();
342  mudeta -= (*staTracks)[bindex].eta();
343  }
344  }
345  if ((fabs(mudd0) < 15.0) && (fabs(mudphi) < 0.045) && (fabs(muddsz) < 20.0) && (fabs(mudeta) < 0.060))
346  isGoodMuon = true;
347  }
348 
349  if (isGoodMuon)
350  testTrackerTracks(tkTracks, staTracks, *nav.product());
351 
352  } else if (staTracks->size() == 1 || staTracks->size() == 2)
353  testTrackerTracks(tkTracks, staTracks, *nav.product());
354  }
355 
356  if (!trackEfficiency_ && tkTracks->size() == 1) {
357  if ((tkTracks->front()).normalizedChi2() < 5 && (tkTracks->front()).hitPattern().numberOfValidHits() > 8)
358  testSTATracks(tkTracks, staTracks);
359  }
360 
361  delete theNavigation;
362 }

References bField, failedToPropagate, dqm::impl::MonitorElement::Fill(), findDetLayer, edm::EventSetup::get(), get, GlobalMuonPtEtaPhiHighPt, GlobalMuonPtEtaPhiLowPt, iEvent, isBFieldOff_, muon::isGoodMuon(), measurementTrackerHandle, HLT_FULL_cff::muon, PDWG_BPHSkim_cff::muons, muonToken_, nCompatibleLayers, TrackCollections2monitor_cff::normalizedChi2, edm::ESHandle< T >::product(), StandaloneMuonPtEtaPhiHighPt, StandaloneMuonPtEtaPhiLowPt, muonTagProbeFilters_cff::staTracks, testSTATracks(), testTrackerTracks(), theNavigation, thePropagator, theSTATracksToken_, theTKTracksToken_, theTracker, theTTrackBuilder, and trackEfficiency_.

◆ bookHistograms()

void TrackEfficiencyMonitor::bookHistograms ( DQMStore::IBooker &  ibooker,
edm::Run const &  ,
edm::EventSetup const &   
)
overridevirtual

Implements DQMEDAnalyzer.

Definition at line 72 of file TrackEfficiencyMonitor.cc.

76 {
77  std::string MEFolderName = conf_.getParameter<std::string>("FolderName");
78  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
79 
80  ibooker.setCurrentFolder(MEFolderName);
81 
82  //
83  int muonXBin = conf_.getParameter<int>("muonXBin");
84  double muonXMin = conf_.getParameter<double>("muonXMin");
85  double muonXMax = conf_.getParameter<double>("muonXMax");
86 
87  histname = "muonX_";
88  muonX = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonXBin, muonXMin, muonXMax);
89  muonX->setAxisTitle("");
90 
91  //
92  int muonYBin = conf_.getParameter<int>("muonYBin");
93  double muonYMin = conf_.getParameter<double>("muonYMin");
94  double muonYMax = conf_.getParameter<double>("muonYMax");
95 
96  histname = "muonY_";
97  muonY = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonYBin, muonYMin, muonYMax);
98  muonY->setAxisTitle("");
99 
100  //
101  int muonZBin = conf_.getParameter<int>("muonZBin");
102  double muonZMin = conf_.getParameter<double>("muonZMin");
103  double muonZMax = conf_.getParameter<double>("muonZMax");
104 
105  histname = "muonZ_";
106  muonZ = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonZBin, muonZMin, muonZMax);
107  muonZ->setAxisTitle("");
108 
109  //
110  int muonEtaBin = conf_.getParameter<int>("muonEtaBin");
111  double muonEtaMin = conf_.getParameter<double>("muonEtaMin");
112  double muonEtaMax = conf_.getParameter<double>("muonEtaMax");
113 
114  histname = "muonEta_";
115  muonEta = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonEtaBin, muonEtaMin, muonEtaMax);
116  muonEta->setAxisTitle("");
117 
118  //
119  int muonPhiBin = conf_.getParameter<int>("muonPhiBin");
120  double muonPhiMin = conf_.getParameter<double>("muonPhiMin");
121  double muonPhiMax = conf_.getParameter<double>("muonPhiMax");
122 
123  histname = "muonPhi_";
124  muonPhi = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonPhiBin, muonPhiMin, muonPhiMax);
125  muonPhi->setAxisTitle("");
126 
127  //
128  int muonD0Bin = conf_.getParameter<int>("muonD0Bin");
129  double muonD0Min = conf_.getParameter<double>("muonD0Min");
130  double muonD0Max = conf_.getParameter<double>("muonD0Max");
131 
132  histname = "muonD0_";
133  muonD0 = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonD0Bin, muonD0Min, muonD0Max);
134  muonD0->setAxisTitle("");
135 
136  //
137  int muonCompatibleLayersBin = conf_.getParameter<int>("muonCompatibleLayersBin");
138  double muonCompatibleLayersMin = conf_.getParameter<double>("muonCompatibleLayersMin");
139  double muonCompatibleLayersMax = conf_.getParameter<double>("muonCompatibleLayersMax");
140 
141  histname = "muonCompatibleLayers_";
142  muonCompatibleLayers = ibooker.book1D(histname + AlgoName,
143  histname + AlgoName,
144  muonCompatibleLayersBin,
145  muonCompatibleLayersMin,
146  muonCompatibleLayersMax);
147  muonCompatibleLayers->setAxisTitle("");
148 
149  //------------------------------------------------------------------------------------
150 
151  //
152  int trackXBin = conf_.getParameter<int>("trackXBin");
153  double trackXMin = conf_.getParameter<double>("trackXMin");
154  double trackXMax = conf_.getParameter<double>("trackXMax");
155 
156  histname = "trackX_";
157  trackX = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackXBin, trackXMin, trackXMax);
158  trackX->setAxisTitle("");
159 
160  //
161  int trackYBin = conf_.getParameter<int>("trackYBin");
162  double trackYMin = conf_.getParameter<double>("trackYMin");
163  double trackYMax = conf_.getParameter<double>("trackYMax");
164 
165  histname = "trackY_";
166  trackY = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackYBin, trackYMin, trackYMax);
167  trackY->setAxisTitle("");
168 
169  //
170  int trackZBin = conf_.getParameter<int>("trackZBin");
171  double trackZMin = conf_.getParameter<double>("trackZMin");
172  double trackZMax = conf_.getParameter<double>("trackZMax");
173 
174  histname = "trackZ_";
175  trackZ = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackZBin, trackZMin, trackZMax);
176  trackZ->setAxisTitle("");
177 
178  //
179  int trackEtaBin = conf_.getParameter<int>("trackEtaBin");
180  double trackEtaMin = conf_.getParameter<double>("trackEtaMin");
181  double trackEtaMax = conf_.getParameter<double>("trackEtaMax");
182 
183  histname = "trackEta_";
184  trackEta = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackEtaBin, trackEtaMin, trackEtaMax);
185  trackEta->setAxisTitle("");
186 
187  //
188  int trackPhiBin = conf_.getParameter<int>("trackPhiBin");
189  double trackPhiMin = conf_.getParameter<double>("trackPhiMin");
190  double trackPhiMax = conf_.getParameter<double>("trackPhiMax");
191 
192  histname = "trackPhi_";
193  trackPhi = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackPhiBin, trackPhiMin, trackPhiMax);
194  trackPhi->setAxisTitle("");
195 
196  //
197  int trackD0Bin = conf_.getParameter<int>("trackD0Bin");
198  double trackD0Min = conf_.getParameter<double>("trackD0Min");
199  double trackD0Max = conf_.getParameter<double>("trackD0Max");
200 
201  histname = "trackD0_";
202  trackD0 = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackD0Bin, trackD0Min, trackD0Max);
203  trackD0->setAxisTitle("");
204 
205  //
206  int trackCompatibleLayersBin = conf_.getParameter<int>("trackCompatibleLayersBin");
207  double trackCompatibleLayersMin = conf_.getParameter<double>("trackCompatibleLayersMin");
208  double trackCompatibleLayersMax = conf_.getParameter<double>("trackCompatibleLayersMax");
209 
210  histname = "trackCompatibleLayers_";
211  trackCompatibleLayers = ibooker.book1D(histname + AlgoName,
212  histname + AlgoName,
213  trackCompatibleLayersBin,
214  trackCompatibleLayersMin,
215  trackCompatibleLayersMax);
216  trackCompatibleLayers->setAxisTitle("");
217 
218  //------------------------------------------------------------------------------------
219 
220  //
221  int deltaXBin = conf_.getParameter<int>("deltaXBin");
222  double deltaXMin = conf_.getParameter<double>("deltaXMin");
223  double deltaXMax = conf_.getParameter<double>("deltaXMax");
224 
225  histname = "deltaX_";
226  deltaX = ibooker.book1D(histname + AlgoName, histname + AlgoName, deltaXBin, deltaXMin, deltaXMax);
227  deltaX->setAxisTitle("");
228 
229  //
230  int deltaYBin = conf_.getParameter<int>("deltaYBin");
231  double deltaYMin = conf_.getParameter<double>("deltaYMin");
232  double deltaYMax = conf_.getParameter<double>("deltaYMax");
233 
234  histname = "deltaY_";
235  deltaY = ibooker.book1D(histname + AlgoName, histname + AlgoName, deltaYBin, deltaYMin, deltaYMax);
236  deltaY->setAxisTitle("");
237 
238  //
239  int signDeltaXBin = conf_.getParameter<int>("signDeltaXBin");
240  double signDeltaXMin = conf_.getParameter<double>("signDeltaXMin");
241  double signDeltaXMax = conf_.getParameter<double>("signDeltaXMax");
242 
243  histname = "signDeltaX_";
244  signDeltaX = ibooker.book1D(histname + AlgoName, histname + AlgoName, signDeltaXBin, signDeltaXMin, signDeltaXMax);
245  signDeltaX->setAxisTitle("");
246 
247  //
248  int signDeltaYBin = conf_.getParameter<int>("signDeltaYBin");
249  double signDeltaYMin = conf_.getParameter<double>("signDeltaYMin");
250  double signDeltaYMax = conf_.getParameter<double>("signDeltaYMax");
251 
252  histname = "signDeltaY_";
253  signDeltaY = ibooker.book1D(histname + AlgoName, histname + AlgoName, signDeltaYBin, signDeltaYMin, signDeltaYMax);
254  signDeltaY->setAxisTitle("");
255 
256  histname = "GlobalMuonPtEtaPhi_LowPt_";
257  GlobalMuonPtEtaPhiLowPt = ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
258  GlobalMuonPtEtaPhiLowPt->setAxisTitle("");
259 
260  histname = "StandaloneMuonPtEtaPhi_LowPt_";
261  StandaloneMuonPtEtaPhiLowPt =
262  ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
263  StandaloneMuonPtEtaPhiLowPt->setAxisTitle("");
264 
265  histname = "GlobalMuonPtEtaPhi_HighPt_";
266  GlobalMuonPtEtaPhiHighPt = ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
267  GlobalMuonPtEtaPhiHighPt->setAxisTitle("");
268 
269  histname = "StandaloneMuonPtEtaPhi_HighPt_";
270  StandaloneMuonPtEtaPhiHighPt =
271  ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
272  StandaloneMuonPtEtaPhiHighPt->setAxisTitle("");
273 }

References HLTSiStripMonitoring_cff::AlgoName, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), conf_, deltaX, TrackEfficiencyMonitor_cfi::deltaXBin, TrackEfficiencyMonitor_cfi::deltaXMax, TrackEfficiencyMonitor_cfi::deltaXMin, deltaY, TrackEfficiencyMonitor_cfi::deltaYBin, TrackEfficiencyMonitor_cfi::deltaYMax, TrackEfficiencyMonitor_cfi::deltaYMin, edm::ParameterSet::getParameter(), GlobalMuonPtEtaPhiHighPt, GlobalMuonPtEtaPhiLowPt, histname, muonCompatibleLayers, TrackEfficiencyMonitor_cfi::muonCompatibleLayersBin, TrackEfficiencyMonitor_cfi::muonCompatibleLayersMax, TrackEfficiencyMonitor_cfi::muonCompatibleLayersMin, muonD0, TrackEfficiencyMonitor_cfi::muonD0Bin, TrackEfficiencyMonitor_cfi::muonD0Max, TrackEfficiencyMonitor_cfi::muonD0Min, muonEta, TrackEfficiencyMonitor_cfi::muonEtaBin, TrackEfficiencyMonitor_cfi::muonEtaMax, TrackEfficiencyMonitor_cfi::muonEtaMin, muonPhi, TrackEfficiencyMonitor_cfi::muonPhiBin, TrackEfficiencyMonitor_cfi::muonPhiMax, TrackEfficiencyMonitor_cfi::muonPhiMin, muonX, TrackEfficiencyMonitor_cfi::muonXBin, TrackEfficiencyMonitor_cfi::muonXMax, TrackEfficiencyMonitor_cfi::muonXMin, muonY, TrackEfficiencyMonitor_cfi::muonYBin, TrackEfficiencyMonitor_cfi::muonYMax, TrackEfficiencyMonitor_cfi::muonYMin, muonZ, TrackEfficiencyMonitor_cfi::muonZBin, TrackEfficiencyMonitor_cfi::muonZMax, TrackEfficiencyMonitor_cfi::muonZMin, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), signDeltaX, TrackEfficiencyMonitor_cfi::signDeltaXBin, TrackEfficiencyMonitor_cfi::signDeltaXMax, TrackEfficiencyMonitor_cfi::signDeltaXMin, signDeltaY, TrackEfficiencyMonitor_cfi::signDeltaYBin, TrackEfficiencyMonitor_cfi::signDeltaYMax, TrackEfficiencyMonitor_cfi::signDeltaYMin, StandaloneMuonPtEtaPhiHighPt, StandaloneMuonPtEtaPhiLowPt, AlCaHLTBitMon_QueryRunRegistry::string, trackCompatibleLayers, TrackEfficiencyMonitor_cfi::trackCompatibleLayersBin, TrackEfficiencyMonitor_cfi::trackCompatibleLayersMax, TrackEfficiencyMonitor_cfi::trackCompatibleLayersMin, trackD0, TrackEfficiencyMonitor_cfi::trackD0Bin, TrackEfficiencyMonitor_cfi::trackD0Max, TrackEfficiencyMonitor_cfi::trackD0Min, trackEta, TrackEfficiencyMonitor_cfi::trackEtaBin, TrackEfficiencyMonitor_cfi::trackEtaMax, TrackEfficiencyMonitor_cfi::trackEtaMin, trackPhi, TrackEfficiencyMonitor_cfi::trackPhiBin, TrackEfficiencyMonitor_cfi::trackPhiMax, TrackEfficiencyMonitor_cfi::trackPhiMin, trackX, TrackEfficiencyMonitor_cfi::trackXBin, TrackEfficiencyMonitor_cfi::trackXMax, TrackEfficiencyMonitor_cfi::trackXMin, trackY, TrackEfficiencyMonitor_cfi::trackYBin, TrackEfficiencyMonitor_cfi::trackYMax, TrackEfficiencyMonitor_cfi::trackYMin, trackZ, TrackEfficiencyMonitor_cfi::trackZBin, TrackEfficiencyMonitor_cfi::trackZMax, and TrackEfficiencyMonitor_cfi::trackZMin.

◆ checkSemiCylinder()

TrackEfficiencyMonitor::SemiCylinder TrackEfficiencyMonitor::checkSemiCylinder ( const Track &  tk)

Definition at line 553 of file TrackEfficiencyMonitor.cc.

555 {
556  return tk.innerPosition().phi() > 0 ? TrackEfficiencyMonitor::Up : TrackEfficiencyMonitor::Down;
557 }

References Down, reco::Track::innerPosition(), and Up.

Referenced by testSTATracks(), and testTrackerTracks().

◆ compatibleLayers()

int TrackEfficiencyMonitor::compatibleLayers ( const NavigationSchool &  navigationSchool,
TrajectoryStateOnSurface  theTSOS 
)

Definition at line 606 of file TrackEfficiencyMonitor.cc.

608 {
609  //---------------------------------------------------
610  // check the number of compatible layers
611  //---------------------------------------------------
612 
613  std::vector<const BarrelDetLayer*> barrelTOBLayers = measurementTrackerHandle->geometricSearchTracker()->tobLayers();
614 
615  unsigned int layers = 0;
616  for (unsigned int k = 0; k < barrelTOBLayers.size(); k++) {
617  const DetLayer* firstLay = barrelTOBLayers[barrelTOBLayers.size() - 1 - k];
618 
619  //Propagator* theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
620 
621  Propagator* theTmpPropagator = &*thePropagator->clone();
622  theTmpPropagator->setPropagationDirection(alongMomentum);
623 
624  TrajectoryStateOnSurface startTSOS = theTmpPropagator->propagate(*theTSOS.freeState(), firstLay->surface());
625 
626  std::vector<const DetLayer*> trackCompatibleLayers;
627 
628  findDetLayer = true;
629  bool isUpMuon = false;
630  bool firstdtep = true;
631 
632  if (startTSOS.isValid()) {
633  if (firstdtep)
634  layers++;
635 
636  int nwhile = 0;
637 
638  //for other compatible layers
639  while (startTSOS.isValid() && firstLay && findDetLayer) {
640  if (firstdtep && startTSOS.globalPosition().y() > 0)
641  isUpMuon = true;
642 
643  if (firstdtep) {
644  std::vector<const DetLayer*> firstCompatibleLayers;
645  firstCompatibleLayers.push_back(firstLay);
646  std::pair<TrajectoryStateOnSurface, const DetLayer*> nextLayer =
647  findNextLayer(theTSOS, firstCompatibleLayers, isUpMuon);
648  firstdtep = false;
649  } else {
650  trackCompatibleLayers = navigationSchool.nextLayers(*firstLay, *(startTSOS.freeState()), alongMomentum);
651  if (!trackCompatibleLayers.empty()) {
652  std::pair<TrajectoryStateOnSurface, const DetLayer*> nextLayer =
653  findNextLayer(startTSOS, trackCompatibleLayers, isUpMuon);
654  if (firstLay != nextLayer.second) {
655  firstLay = nextLayer.second;
656  startTSOS = nextLayer.first;
657  layers++;
658  } else
659  firstLay = nullptr;
660  }
661  }
662  nwhile++;
663  if (nwhile > 100)
664  break;
665  }
666  delete theTmpPropagator;
667  break;
668  }
669  delete theTmpPropagator;
670  }
671  return layers;
672 }

References alongMomentum, Propagator::clone(), findDetLayer, findNextLayer(), TrajectoryStateOnSurface::freeState(), MeasurementTracker::geometricSearchTracker(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), dqmdumpme::k, hgcalTopologyTester_cfi::layers, measurementTrackerHandle, NavigationSchool::nextLayers(), Propagator::propagate(), Propagator::setPropagationDirection(), GeometricSearchDet::surface(), thePropagator, GeometricSearchTracker::tobLayers(), trackCompatibleLayers, and PV3DBase< T, PVType, FrameType >::y().

Referenced by testTrackerTracks().

◆ findNextLayer()

std::pair< TrajectoryStateOnSurface, const DetLayer * > TrackEfficiencyMonitor::findNextLayer ( TrajectoryStateOnSurface  startTSOS,
const std::vector< const DetLayer * > &  trackCompatibleLayers,
bool  isUpMuon 
)

Definition at line 675 of file TrackEfficiencyMonitor.cc.

678 {
679  //Propagator* theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
680 
681  Propagator* theTmpPropagator = &*thePropagator->clone();
682  theTmpPropagator->setPropagationDirection(alongMomentum);
683 
684  std::vector<const DetLayer*>::const_iterator itl;
685  findDetLayer = false;
686  for (itl = trackCompatibleLayers.begin(); itl != trackCompatibleLayers.end(); ++itl) {
687  TrajectoryStateOnSurface tsos = theTmpPropagator->propagate(*(sTSOS.freeState()), (**itl).surface());
688  if (tsos.isValid()) {
689  sTSOS = tsos;
690  findDetLayer = true;
691 
692  break;
693  }
694  }
695  std::pair<TrajectoryStateOnSurface, const DetLayer*> blabla;
696  blabla.first = sTSOS;
697  blabla.second = &**itl;
698  delete theTmpPropagator;
699  return blabla;
700 }

References alongMomentum, Propagator::clone(), findDetLayer, TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::isValid(), Propagator::propagate(), Propagator::setPropagationDirection(), thePropagator, and trackCompatibleLayers.

Referenced by compatibleLayers().

◆ testSTATracks()

void TrackEfficiencyMonitor::testSTATracks ( edm::Handle< TrackCollection >  tkTracks,
edm::Handle< TrackCollection >  staTracks 
)

Definition at line 485 of file TrackEfficiencyMonitor.cc.

488 {
489  reco::TransientTrack tkTT = theTTrackBuilder->build(tkTracks->front());
490  double ipX = tkTT.impactPointState().globalPosition().x();
491  double ipY = tkTT.impactPointState().globalPosition().y();
492  double ipZ = tkTT.impactPointState().globalPosition().z();
493  double eta = tkTT.impactPointState().globalDirection().eta();
494  double phi = tkTT.impactPointState().globalDirection().phi();
495  double d0 = (*tkTracks)[0].d0();
496 
497  TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
498  LocalVector diffLocal;
499  TrajectoryStateOnSurface staState;
500  bool isTrack = false;
501 
502  if (!staTracks->empty()) {
503  //---------------------------------------------------
504  //look for associated muons
505  //---------------------------------------------------
506 
507  float DR2min = 1000;
508  reco::TrackCollection::const_iterator closestTrk = staTracks->end();
509  //----------------------loop on tracker tracks:
510  for (reco::TrackCollection::const_iterator staTrack = staTracks->begin(); staTrack != staTracks->end();
511  ++staTrack) {
512  if (checkSemiCylinder(*staTrack) == TrackEfficiencyMonitor::Up) {
513  reco::TransientTrack staTT = theTTrackBuilder->build(*staTrack);
514  failedToPropagate = 1;
515  staState = thePropagator->propagate(staTT.outermostMeasurementState(), tkInner.surface());
516 
517  if (staState.isValid()) {
518  failedToPropagate = 0;
519  diffLocal = tkInner.localPosition() - staState.localPosition();
520 
521  double DR2 = diffLocal.x() * diffLocal.x() + diffLocal.y() * diffLocal.y();
522  if (DR2 < DR2min) {
523  DR2min = DR2;
524  closestTrk = staTrack;
525  }
526  if (pow(DR2, 0.5) < 100.)
527  isTrack = true;
528  }
529  }
530  }
531  }
532 
533  if (failedToPropagate == 0) {
534  trackX->Fill(ipX);
535  trackY->Fill(ipY);
536  trackZ->Fill(ipZ);
537  trackEta->Fill(eta);
538  trackPhi->Fill(phi);
539  trackD0->Fill(d0);
540 
541  if (isTrack) {
542  muonX->Fill(ipX);
543  muonY->Fill(ipY);
544  muonZ->Fill(ipZ);
545  muonEta->Fill(eta);
546  muonPhi->Fill(phi);
547  muonD0->Fill(d0);
548  }
549  }
550 }

References TransientTrackBuilder::build(), checkSemiCylinder(), d0, PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), failedToPropagate, dqm::impl::MonitorElement::Fill(), TrajectoryStateOnSurface::globalDirection(), TrajectoryStateOnSurface::globalPosition(), reco::TransientTrack::impactPointState(), reco::TransientTrack::innermostMeasurementState(), PFRecoTauChargedHadronQualityPlugins_cfi::isTrack, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localPosition(), muonD0, muonEta, muonPhi, muonX, muonY, muonZ, reco::TransientTrack::outermostMeasurementState(), phi, PV3DBase< T, PVType, FrameType >::phi(), funct::pow(), Propagator::propagate(), muonTagProbeFilters_cff::staTracks, TrajectoryStateOnSurface::surface(), thePropagator, theTTrackBuilder, trackD0, trackEta, trackPhi, trackX, trackY, trackZ, Up, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

◆ testTrackerTracks()

void TrackEfficiencyMonitor::testTrackerTracks ( edm::Handle< TrackCollection >  tkTracks,
edm::Handle< TrackCollection >  staTracks,
const NavigationSchool &  navigationSchool 
)

Definition at line 365 of file TrackEfficiencyMonitor.cc.

369 {
370  const std::string metname = "testStandAloneMuonTracks";
371 
372  //---------------------------------------------------
373  // get the index of the "up" muon
374  // histograms will only be computed for the "up" muon
375  //---------------------------------------------------
376 
377  int nUpMuon = 0;
378  int idxUpMuon = -1;
379  for (unsigned int i = 0; i < staTracks->size(); i++) {
380  if (checkSemiCylinder((*staTracks)[i]) == TrackEfficiencyMonitor::Up) {
381  nUpMuon++;
382  idxUpMuon = i;
383  }
384  }
385 
386  if (nUpMuon == 1) {
387  //---------------------------------------------------
388  //get the muon informations
389  //---------------------------------------------------
390 
391  reco::TransientTrack staTT = theTTrackBuilder->build((*staTracks)[idxUpMuon]);
392  double ipX = staTT.impactPointState().globalPosition().x();
393  double ipY = staTT.impactPointState().globalPosition().y();
394  double ipZ = staTT.impactPointState().globalPosition().z();
395  double eta = staTT.impactPointState().globalDirection().eta();
396  double phi = staTT.impactPointState().globalDirection().phi();
397  double d0 = (*staTracks)[idxUpMuon].d0();
398 
399  TrajectoryStateOnSurface theTSOS = staTT.outermostMeasurementState();
400  TrajectoryStateOnSurface theTSOSCompLayers = staTT.outermostMeasurementState();
401 
402  //---------------------------------------------------
403  //check if the muon is in the tracker acceptance
404  //---------------------------------------------------
405  bool isInTrackerAcceptance = false;
406  isInTrackerAcceptance = trackerAcceptance(theTSOS, theRadius_, theMaxZ_);
407 
408  //---------------------------------------------------st
409  //count the number of compatible layers
410  //---------------------------------------------------
411  nCompatibleLayers = compatibleLayers(navigationSchool, theTSOSCompLayers);
412 
413  if (isInTrackerAcceptance && (*staTracks)[idxUpMuon].hitPattern().numberOfValidHits() > 28) {
414  //---------------------------------------------------
415  //count the number of good muon candidates
416  //---------------------------------------------------
417 
418  TrajectoryStateOnSurface staState;
419  LocalVector diffLocal;
420 
421  bool isTrack = false;
422  if (!tkTracks->empty()) {
423  //---------------------------------------------------
424  //look for associated tracks
425  //---------------------------------------------------
426  float DR2min = 1000;
427  reco::TrackCollection::const_iterator closestTrk = tkTracks->end();
428 
429  for (reco::TrackCollection::const_iterator tkTrack = tkTracks->begin(); tkTrack != tkTracks->end(); ++tkTrack) {
430  reco::TransientTrack tkTT = theTTrackBuilder->build(*tkTrack);
431  TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
432  staState = thePropagator->propagate(staTT.outermostMeasurementState(), tkInner.surface());
433  failedToPropagate = 1;
434 
435  if (staState.isValid()) {
436  failedToPropagate = 0;
437  diffLocal = tkInner.localPosition() - staState.localPosition();
438  double DR2 = diffLocal.x() * diffLocal.x() + diffLocal.y() * diffLocal.y();
439  if (DR2 < DR2min) {
440  DR2min = DR2;
441  closestTrk = tkTrack;
442  }
443  if (pow(DR2, 0.5) < 100.)
444  isTrack = true;
445  }
446  }
447 
448  if (DR2min != 1000) {
449  reco::TransientTrack tkTT = theTTrackBuilder->build(*closestTrk);
450  TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
451  staState = thePropagator->propagate(staTT.outermostMeasurementState(), tkInner.surface());
452  deltaX->Fill(diffLocal.x());
453  deltaY->Fill(diffLocal.y());
454  signDeltaX->Fill(diffLocal.x() /
455  (tkInner.localError().positionError().xx() + staState.localError().positionError().xx()));
456  signDeltaY->Fill(diffLocal.y() /
457  (tkInner.localError().positionError().yy() + staState.localError().positionError().yy()));
458  }
459  }
460 
461  if (failedToPropagate == 0) {
462  muonX->Fill(ipX);
463  muonY->Fill(ipY);
464  muonZ->Fill(ipZ);
465  muonEta->Fill(eta);
466  muonPhi->Fill(phi);
467  muonD0->Fill(d0);
468  muonCompatibleLayers->Fill(nCompatibleLayers);
469 
470  if (isTrack) {
471  trackX->Fill(ipX);
472  trackY->Fill(ipY);
473  trackZ->Fill(ipZ);
474  trackEta->Fill(eta);
475  trackPhi->Fill(phi);
476  trackD0->Fill(d0);
477  trackCompatibleLayers->Fill(nCompatibleLayers);
478  }
479  }
480  }
481  }
482 }

References TransientTrackBuilder::build(), checkSemiCylinder(), compatibleLayers(), d0, deltaX, deltaY, PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), failedToPropagate, dqm::impl::MonitorElement::Fill(), TrajectoryStateOnSurface::globalDirection(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, reco::TransientTrack::impactPointState(), reco::TransientTrack::innermostMeasurementState(), PFRecoTauChargedHadronQualityPlugins_cfi::isTrack, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), metname, muonCompatibleLayers, muonD0, muonEta, muonPhi, muonX, muonY, muonZ, nCompatibleLayers, TrackCollections2monitor_cff::numberOfValidHits, reco::TransientTrack::outermostMeasurementState(), phi, PV3DBase< T, PVType, FrameType >::phi(), LocalTrajectoryError::positionError(), funct::pow(), Propagator::propagate(), signDeltaX, signDeltaY, muonTagProbeFilters_cff::staTracks, AlCaHLTBitMon_QueryRunRegistry::string, TrajectoryStateOnSurface::surface(), theMaxZ_, thePropagator, theRadius_, theTTrackBuilder, trackCompatibleLayers, trackD0, trackerAcceptance(), trackEta, trackPhi, trackX, trackY, trackZ, Up, PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), PV3DBase< T, PVType, FrameType >::y(), LocalError::yy(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

◆ trackerAcceptance()

bool TrackEfficiencyMonitor::trackerAcceptance ( TrajectoryStateOnSurface  theTSOS,
double  theRadius,
double  theMaxZ 
)

Definition at line 560 of file TrackEfficiencyMonitor.cc.

562 {
563  //---------------------------------------------------
564  // check if the muon is in the tracker acceptance
565  // check the compatibility with a cylinder of radius "theRadius"
566  //---------------------------------------------------
567 
568  //Propagator* theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
569 
570  //Propagator* theTmpPropagator = &*thePropagator;
571  Propagator* theTmpPropagator = &*thePropagator->clone();
572 
573  if (theTSOS.globalPosition().y() < 0)
574  theTmpPropagator->setPropagationDirection(oppositeToMomentum);
575  else
576  theTmpPropagator->setPropagationDirection(alongMomentum);
577 
578  Cylinder::PositionType pos0;
579  Cylinder::RotationType rot0;
580  const Cylinder::CylinderPointer cyl = Cylinder::build(pos0, rot0, theRadius);
581  TrajectoryStateOnSurface tsosAtCyl = theTmpPropagator->propagate(*theTSOS.freeState(), *cyl);
582  double accept = false;
583  if (tsosAtCyl.isValid()) {
584  if (fabs(tsosAtCyl.globalPosition().z()) < theMaxZ) {
585  Cylinder::PositionType pos02;
586  Cylinder::RotationType rot02;
587  const Cylinder::CylinderPointer cyl2 = Cylinder::build(pos02, rot02, theRadius - 10);
588  TrajectoryStateOnSurface tsosAtCyl2 = theTmpPropagator->propagate(*tsosAtCyl.freeState(), *cyl2);
589  if (tsosAtCyl2.isValid()) {
590  Cylinder::PositionType pos03;
591  Cylinder::RotationType rot03;
592  const Cylinder::CylinderPointer cyl3 = Cylinder::build(pos03, rot03, theRadius);
593  TrajectoryStateOnSurface tsosAtCyl3 = theTmpPropagator->propagate(*tsosAtCyl2.freeState(), *cyl3);
594  if (tsosAtCyl3.isValid()) {
595  accept = true;
596  }
597  }
598  }
599  }
600  delete theTmpPropagator;
601  //muon propagated to the barrel cylinder
602  return accept;
603 }

References accept(), alongMomentum, Cylinder::build(), Propagator::clone(), TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), oppositeToMomentum, Propagator::propagate(), Propagator::setPropagationDirection(), TrackEfficiencyMonitor_cfi::theMaxZ, thePropagator, TrackEfficiencyMonitor_cfi::theRadius, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by testTrackerTracks().

Member Data Documentation

◆ bField

edm::ESHandle<MagneticField> TrackEfficiencyMonitor::bField
private

Definition at line 116 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ conf_

edm::ParameterSet TrackEfficiencyMonitor::conf_
private

Definition at line 67 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and TrackEfficiencyMonitor().

◆ deltaX

MonitorElement* TrackEfficiencyMonitor::deltaX
private

Definition at line 100 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ deltaY

MonitorElement* TrackEfficiencyMonitor::deltaY
private

Definition at line 101 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ dqmStore_

DQMStore* TrackEfficiencyMonitor::dqmStore_
private

Definition at line 66 of file TrackEfficiencyMonitor.h.

Referenced by TrackEfficiencyMonitor().

◆ failedToPropagate

int TrackEfficiencyMonitor::failedToPropagate
private

Definition at line 80 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), testSTATracks(), and testTrackerTracks().

◆ findDetLayer

bool TrackEfficiencyMonitor::findDetLayer
private

Definition at line 82 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), compatibleLayers(), and findNextLayer().

◆ GlobalMuonPtEtaPhiHighPt

MonitorElement* TrackEfficiencyMonitor::GlobalMuonPtEtaPhiHighPt
private

Definition at line 106 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ GlobalMuonPtEtaPhiLowPt

MonitorElement* TrackEfficiencyMonitor::GlobalMuonPtEtaPhiLowPt
private

Definition at line 104 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ histname

std::string TrackEfficiencyMonitor::histname
private

Definition at line 64 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms().

◆ isBFieldOff_

bool TrackEfficiencyMonitor::isBFieldOff_
private

Definition at line 71 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ measurementTrackerHandle

edm::ESHandle<MeasurementTracker> TrackEfficiencyMonitor::measurementTrackerHandle
private

Definition at line 118 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and compatibleLayers().

◆ muonCompatibleLayers

MonitorElement* TrackEfficiencyMonitor::muonCompatibleLayers
private

Definition at line 90 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ muonD0

MonitorElement* TrackEfficiencyMonitor::muonD0
private

Definition at line 89 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonEta

MonitorElement* TrackEfficiencyMonitor::muonEta
private

Definition at line 87 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonPhi

MonitorElement* TrackEfficiencyMonitor::muonPhi
private

Definition at line 88 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonToken_

edm::EDGetTokenT<edm::View<reco::Muon> > TrackEfficiencyMonitor::muonToken_
private

Definition at line 110 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ muonX

MonitorElement* TrackEfficiencyMonitor::muonX
private

Definition at line 84 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonY

MonitorElement* TrackEfficiencyMonitor::muonY
private

Definition at line 85 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonZ

MonitorElement* TrackEfficiencyMonitor::muonZ
private

Definition at line 86 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ nCompatibleLayers

int TrackEfficiencyMonitor::nCompatibleLayers
private

Definition at line 81 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and testTrackerTracks().

◆ signDeltaX

MonitorElement* TrackEfficiencyMonitor::signDeltaX
private

Definition at line 102 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ signDeltaY

MonitorElement* TrackEfficiencyMonitor::signDeltaY
private

Definition at line 103 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ StandaloneMuonPtEtaPhiHighPt

MonitorElement* TrackEfficiencyMonitor::StandaloneMuonPtEtaPhiHighPt
private

Definition at line 107 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ StandaloneMuonPtEtaPhiLowPt

MonitorElement* TrackEfficiencyMonitor::StandaloneMuonPtEtaPhiLowPt
private

Definition at line 105 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ theGeometricSearchTracker

edm::ESHandle<GeometricSearchTracker> TrackEfficiencyMonitor::theGeometricSearchTracker
private

Definition at line 111 of file TrackEfficiencyMonitor.h.

◆ theMaxZ_

double TrackEfficiencyMonitor::theMaxZ_
private

Definition at line 70 of file TrackEfficiencyMonitor.h.

Referenced by testTrackerTracks(), and TrackEfficiencyMonitor().

◆ theMuonServiceProxy

MuonServiceProxy* TrackEfficiencyMonitor::theMuonServiceProxy
private

Definition at line 109 of file TrackEfficiencyMonitor.h.

◆ theNavigation

const DirectTrackerNavigation* TrackEfficiencyMonitor::theNavigation
private

Definition at line 108 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ thePropagator

edm::ESHandle<Propagator> TrackEfficiencyMonitor::thePropagator
private

Definition at line 112 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), compatibleLayers(), findNextLayer(), testSTATracks(), testTrackerTracks(), and trackerAcceptance().

◆ thePropagatorCyl

edm::ESHandle<Propagator> TrackEfficiencyMonitor::thePropagatorCyl
private

Definition at line 113 of file TrackEfficiencyMonitor.h.

◆ theRadius_

double TrackEfficiencyMonitor::theRadius_
private

Definition at line 69 of file TrackEfficiencyMonitor.h.

Referenced by testTrackerTracks(), and TrackEfficiencyMonitor().

◆ theSTATracksLabel_

edm::InputTag TrackEfficiencyMonitor::theSTATracksLabel_
private

Definition at line 76 of file TrackEfficiencyMonitor.h.

Referenced by TrackEfficiencyMonitor().

◆ theSTATracksToken_

edm::EDGetTokenT<reco::TrackCollection> TrackEfficiencyMonitor::theSTATracksToken_
private

Definition at line 78 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ theTKTracksLabel_

edm::InputTag TrackEfficiencyMonitor::theTKTracksLabel_
private

Definition at line 75 of file TrackEfficiencyMonitor.h.

Referenced by TrackEfficiencyMonitor().

◆ theTKTracksToken_

edm::EDGetTokenT<reco::TrackCollection> TrackEfficiencyMonitor::theTKTracksToken_
private

Definition at line 77 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ theTracker

edm::ESHandle<GeometricSearchTracker> TrackEfficiencyMonitor::theTracker
private

Definition at line 115 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ theTTrackBuilder

edm::ESHandle<TransientTrackBuilder> TrackEfficiencyMonitor::theTTrackBuilder
private

Definition at line 114 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), testSTATracks(), and testTrackerTracks().

◆ trackCompatibleLayers

MonitorElement* TrackEfficiencyMonitor::trackCompatibleLayers
private

Definition at line 98 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), compatibleLayers(), findNextLayer(), and testTrackerTracks().

◆ trackD0

MonitorElement* TrackEfficiencyMonitor::trackD0
private

Definition at line 97 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackEfficiency_

bool TrackEfficiencyMonitor::trackEfficiency_
private

Definition at line 72 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ trackEta

MonitorElement* TrackEfficiencyMonitor::trackEta
private

Definition at line 95 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackPhi

MonitorElement* TrackEfficiencyMonitor::trackPhi
private

Definition at line 96 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackX

MonitorElement* TrackEfficiencyMonitor::trackX
private

Definition at line 92 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackY

MonitorElement* TrackEfficiencyMonitor::trackY
private

Definition at line 93 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackZ

MonitorElement* TrackEfficiencyMonitor::trackZ
private

Definition at line 94 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

Vector3DBase< float, LocalTag >
TrajectoryStateOnSurface::globalDirection
GlobalVector globalDirection() const
Definition: TrajectoryStateOnSurface.h:67
TrackEfficiencyMonitor_cfi.muonCompatibleLayersMin
muonCompatibleLayersMin
Definition: TrackEfficiencyMonitor_cfi.py:47
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
TrackEfficiencyMonitor::muonZ
MonitorElement * muonZ
Definition: TrackEfficiencyMonitor.h:86
TrackEfficiencyMonitor::muonX
MonitorElement * muonX
Definition: TrackEfficiencyMonitor.h:84
TrackEfficiencyMonitor::trackPhi
MonitorElement * trackPhi
Definition: TrackEfficiencyMonitor.h:96
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
TkRotation< float >
TrackEfficiencyMonitor::muonPhi
MonitorElement * muonPhi
Definition: TrackEfficiencyMonitor.h:88
TrackEfficiencyMonitor::GlobalMuonPtEtaPhiLowPt
MonitorElement * GlobalMuonPtEtaPhiLowPt
Definition: TrackEfficiencyMonitor.h:104
TrackEfficiencyMonitor_cfi.trackZMax
trackZMax
Definition: TrackEfficiencyMonitor_cfi.py:60
TrackEfficiencyMonitor_cfi.muonCompatibleLayersBin
muonCompatibleLayersBin
Definition: TrackEfficiencyMonitor_cfi.py:46
NavigationSchoolRecord
Definition: NavigationSchoolRecord.h:12
mps_fire.i
i
Definition: mps_fire.py:428
TrackEfficiencyMonitor::compatibleLayers
int compatibleLayers(const NavigationSchool &navigationSchool, TrajectoryStateOnSurface theTSOS)
Definition: TrackEfficiencyMonitor.cc:606
GeometricSearchTracker::tobLayers
std::vector< BarrelDetLayer const * > const & tobLayers() const
Definition: GeometricSearchTracker.h:46
TrackEfficiencyMonitor::theTKTracksToken_
edm::EDGetTokenT< reco::TrackCollection > theTKTracksToken_
Definition: TrackEfficiencyMonitor.h:77
LocalTrajectoryError::positionError
LocalError positionError() const
Definition: LocalTrajectoryError.h:81
DetLayer
Definition: DetLayer.h:21
muon
Definition: MuonCocktails.h:17
TrackEfficiencyMonitor::trackY
MonitorElement * trackY
Definition: TrackEfficiencyMonitor.h:93
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
TrackEfficiencyMonitor::theSTATracksToken_
edm::EDGetTokenT< reco::TrackCollection > theSTATracksToken_
Definition: TrackEfficiencyMonitor.h:78
TrackEfficiencyMonitor::checkSemiCylinder
SemiCylinder checkSemiCylinder(const Track &)
Definition: TrackEfficiencyMonitor.cc:553
TrackEfficiencyMonitor::histname
std::string histname
Definition: TrackEfficiencyMonitor.h:64
TrajectoryStateOnSurface::globalPosition
GlobalPoint globalPosition() const
Definition: TrajectoryStateOnSurface.h:65
TrackEfficiencyMonitor_cfi.muonZMin
muonZMin
Definition: TrackEfficiencyMonitor_cfi.py:31
TrackEfficiencyMonitor_cfi.muonYMin
muonYMin
Definition: TrackEfficiencyMonitor_cfi.py:27
TrackCollections2monitor_cff.numberOfValidHits
numberOfValidHits
Definition: TrackCollections2monitor_cff.py:248
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
TrackEfficiencyMonitor::trackX
MonitorElement * trackX
Definition: TrackEfficiencyMonitor.h:92
TrackEfficiencyMonitor_cfi.muonPhiBin
muonPhiBin
Definition: TrackEfficiencyMonitor_cfi.py:38
MeasurementTracker::geometricSearchTracker
const GeometricSearchTracker * geometricSearchTracker() const
Definition: MeasurementTracker.h:38
oppositeToMomentum
Definition: PropagationDirection.h:4
TrackEfficiencyMonitor_cfi.muonPhiMax
muonPhiMax
Definition: TrackEfficiencyMonitor_cfi.py:40
TrackEfficiencyMonitor_cfi.muonD0Min
muonD0Min
Definition: TrackEfficiencyMonitor_cfi.py:43
TrackerRecoGeometryRecord
Definition: TrackerRecoGeometryRecord.h:14
ReferenceCountingPointer< Cylinder >
TrackEfficiencyMonitor_cfi.trackXBin
trackXBin
Definition: TrackEfficiencyMonitor_cfi.py:50
TrackEfficiencyMonitor::theTracker
edm::ESHandle< GeometricSearchTracker > theTracker
Definition: TrackEfficiencyMonitor.h:115
TrackEfficiencyMonitor::theMaxZ_
double theMaxZ_
Definition: TrackEfficiencyMonitor.h:70
TrackEfficiencyMonitor_cfi.trackEtaBin
trackEtaBin
Definition: TrackEfficiencyMonitor_cfi.py:62
edm::Handle< reco::TrackCollection >
HLTSiStripMonitoring_cff.AlgoName
AlgoName
Definition: HLTSiStripMonitoring_cff.py:232
TrackEfficiencyMonitor::trackD0
MonitorElement * trackD0
Definition: TrackEfficiencyMonitor.h:97
TrackEfficiencyMonitor_cfi.trackYMax
trackYMax
Definition: TrackEfficiencyMonitor_cfi.py:56
TrackEfficiencyMonitor::signDeltaY
MonitorElement * signDeltaY
Definition: TrackEfficiencyMonitor.h:103
TrackEfficiencyMonitor_cfi.muonEtaMin
muonEtaMin
Definition: TrackEfficiencyMonitor_cfi.py:35
TrackEfficiencyMonitor::bField
edm::ESHandle< MagneticField > bField
Definition: TrackEfficiencyMonitor.h:116
TrackEfficiencyMonitor_cfi.muonXMin
muonXMin
Definition: TrackEfficiencyMonitor_cfi.py:23
TrackEfficiencyMonitor::muonY
MonitorElement * muonY
Definition: TrackEfficiencyMonitor.h:85
TrackEfficiencyMonitor_cfi.deltaYMax
deltaYMax
Definition: TrackEfficiencyMonitor_cfi.py:84
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
PFRecoTauChargedHadronQualityPlugins_cfi.isTrack
isTrack
Definition: PFRecoTauChargedHadronQualityPlugins_cfi.py:20
TrackEfficiencyMonitor_cfi.signDeltaYBin
signDeltaYBin
Definition: TrackEfficiencyMonitor_cfi.py:90
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
TrackEfficiencyMonitor_cfi.deltaXMin
deltaXMin
Definition: TrackEfficiencyMonitor_cfi.py:79
Propagator
Definition: Propagator.h:44
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:31
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
TrackEfficiencyMonitor::trackZ
MonitorElement * trackZ
Definition: TrackEfficiencyMonitor.h:94
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:649
NavigationSchool::nextLayers
std::vector< const DetLayer * > nextLayers(const DetLayer &detLayer, Args &&... args) const
Definition: NavigationSchool.h:33
TrajectoryStateOnSurface::freeState
FreeTrajectoryState const * freeState(bool withErrors=true) const
Definition: TrajectoryStateOnSurface.h:58
edm::EventSetup::get
T get() const
Definition: EventSetup.h:87
TrackEfficiencyMonitor_cfi.trackPhiMax
trackPhiMax
Definition: TrackEfficiencyMonitor_cfi.py:68
CkfComponentsRecord
Definition: CkfComponentsRecord.h:22
LocalError::xx
float xx() const
Definition: LocalError.h:22
HLT_FULL_cff.muon
muon
Definition: HLT_FULL_cff.py:11710
TrackEfficiencyMonitor_cfi.trackCompatibleLayersBin
trackCompatibleLayersBin
Definition: TrackEfficiencyMonitor_cfi.py:74
PVValHelper::eta
Definition: PVValidationHelpers.h:70
TrackEfficiencyMonitor::testTrackerTracks
void testTrackerTracks(edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks, const NavigationSchool &navigationSchool)
Definition: TrackEfficiencyMonitor.cc:365
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
TrackEfficiencyMonitor_cfi.trackZBin
trackZBin
Definition: TrackEfficiencyMonitor_cfi.py:58
TrackEfficiencyMonitor::signDeltaX
MonitorElement * signDeltaX
Definition: TrackEfficiencyMonitor.h:102
TrackEfficiencyMonitor_cfi.signDeltaXBin
signDeltaXBin
Definition: TrackEfficiencyMonitor_cfi.py:86
TransientTrackRecord
Definition: TransientTrackRecord.h:11
edm::ESHandle< NavigationSchool >
TrackEfficiencyMonitor_cfi.muonEtaMax
muonEtaMax
Definition: TrackEfficiencyMonitor_cfi.py:36
TrackEfficiencyMonitor::StandaloneMuonPtEtaPhiHighPt
MonitorElement * StandaloneMuonPtEtaPhiHighPt
Definition: TrackEfficiencyMonitor.h:107
TrackEfficiencyMonitor_cfi.signDeltaXMax
signDeltaXMax
Definition: TrackEfficiencyMonitor_cfi.py:88
TrackEfficiencyMonitor::findNextLayer
std::pair< TrajectoryStateOnSurface, const DetLayer * > findNextLayer(TrajectoryStateOnSurface startTSOS, const std::vector< const DetLayer * > &trackCompatibleLayers, bool isUpMuon)
Definition: TrackEfficiencyMonitor.cc:675
dqmdumpme.k
k
Definition: dqmdumpme.py:60
Point3DBase< float, GlobalTag >
TrackEfficiencyMonitor_cfi.trackPhiBin
trackPhiBin
Definition: TrackEfficiencyMonitor_cfi.py:66
TrackEfficiencyMonitor_cfi.signDeltaYMin
signDeltaYMin
Definition: TrackEfficiencyMonitor_cfi.py:91
TrackEfficiencyMonitor_cfi.trackPhiMin
trackPhiMin
Definition: TrackEfficiencyMonitor_cfi.py:67
TrackEfficiencyMonitor_cfi.signDeltaXMin
signDeltaXMin
Definition: TrackEfficiencyMonitor_cfi.py:87
Propagator::setPropagationDirection
virtual void setPropagationDirection(PropagationDirection dir)
Definition: Propagator.h:130
TrackEfficiencyMonitor_cfi.trackZMin
trackZMin
Definition: TrackEfficiencyMonitor_cfi.py:59
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
TrackEfficiencyMonitor::thePropagator
edm::ESHandle< Propagator > thePropagator
Definition: TrackEfficiencyMonitor.h:112
TrackEfficiencyMonitor::testSTATracks
void testSTATracks(edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks)
Definition: TrackEfficiencyMonitor.cc:485
TrackEfficiencyMonitor_cfi.trackYBin
trackYBin
Definition: TrackEfficiencyMonitor_cfi.py:54
TrackEfficiencyMonitor_cfi.trackXMin
trackXMin
Definition: TrackEfficiencyMonitor_cfi.py:51
TrackEfficiencyMonitor_cfi.trackCompatibleLayersMin
trackCompatibleLayersMin
Definition: TrackEfficiencyMonitor_cfi.py:75
TrackEfficiencyMonitor::deltaX
MonitorElement * deltaX
Definition: TrackEfficiencyMonitor.h:100
TrackEfficiencyMonitor::muonToken_
edm::EDGetTokenT< edm::View< reco::Muon > > muonToken_
Definition: TrackEfficiencyMonitor.h:110
TrajectoryStateOnSurface::localPosition
LocalPoint localPosition() const
Definition: TrajectoryStateOnSurface.h:74
TrackEfficiencyMonitor::theRadius_
double theRadius_
Definition: TrackEfficiencyMonitor.h:69
TrackEfficiencyMonitor::dqmStore_
DQMStore * dqmStore_
Definition: TrackEfficiencyMonitor.h:66
TrackEfficiencyMonitor_cfi.muonZMax
muonZMax
Definition: TrackEfficiencyMonitor_cfi.py:32
TrackEfficiencyMonitor_cfi.trackEtaMax
trackEtaMax
Definition: TrackEfficiencyMonitor_cfi.py:64
TrackEfficiencyMonitor_cfi.deltaYBin
deltaYBin
Definition: TrackEfficiencyMonitor_cfi.py:82
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
reco::TransientTrack::impactPointState
TrajectoryStateOnSurface impactPointState() const
Definition: TransientTrack.h:98
TrackEfficiencyMonitor::theSTATracksLabel_
edm::InputTag theSTATracksLabel_
Definition: TrackEfficiencyMonitor.h:76
Cylinder::build
static CylinderPointer build(const PositionType &pos, const RotationType &rot, Scalar radius, Bounds *bounds=nullptr)
Definition: Cylinder.h:45
TrackEfficiencyMonitor_cfi.muonXMax
muonXMax
Definition: TrackEfficiencyMonitor_cfi.py:24
edm::Service
Definition: Service.h:30
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackEfficiencyMonitor::muonEta
MonitorElement * muonEta
Definition: TrackEfficiencyMonitor.h:87
TrackEfficiencyMonitor_cfi.signDeltaYMax
signDeltaYMax
Definition: TrackEfficiencyMonitor_cfi.py:92
TrackEfficiencyMonitor_cfi.trackCompatibleLayersMax
trackCompatibleLayersMax
Definition: TrackEfficiencyMonitor_cfi.py:76
TrackEfficiencyMonitor::muonD0
MonitorElement * muonD0
Definition: TrackEfficiencyMonitor.h:89
DirectTrackerNavigation
Definition: DirectTrackerNavigation.h:26
reco::TransientTrack::outermostMeasurementState
TrajectoryStateOnSurface outermostMeasurementState() const
Definition: TransientTrack.h:86
Propagator::propagate
TrajectoryStateOnSurface propagate(STA const &state, SUR const &surface) const
Definition: Propagator.h:50
muonTagProbeFilters_cff.staTracks
staTracks
Definition: muonTagProbeFilters_cff.py:29
TrackEfficiencyMonitor::conf_
edm::ParameterSet conf_
Definition: TrackEfficiencyMonitor.h:67
TrackEfficiencyMonitor_cfi.muonZBin
muonZBin
Definition: TrackEfficiencyMonitor_cfi.py:30
TrackEfficiencyMonitor::failedToPropagate
int failedToPropagate
Definition: TrackEfficiencyMonitor.h:80
get
#define get
TrackCollections2monitor_cff.normalizedChi2
normalizedChi2
Definition: TrackCollections2monitor_cff.py:247
TrackEfficiencyMonitor_cfi.muonEtaBin
muonEtaBin
Definition: TrackEfficiencyMonitor_cfi.py:34
TrackEfficiencyMonitor_cfi.deltaYMin
deltaYMin
Definition: TrackEfficiencyMonitor_cfi.py:83
TrackEfficiencyMonitor::trackEta
MonitorElement * trackEta
Definition: TrackEfficiencyMonitor.h:95
TrackEfficiencyMonitor_cfi.muonXBin
muonXBin
Definition: TrackEfficiencyMonitor_cfi.py:22
TrackEfficiencyMonitor_cfi.muonD0Max
muonD0Max
Definition: TrackEfficiencyMonitor_cfi.py:44
TrackEfficiencyMonitor_cfi.muonYMax
muonYMax
Definition: TrackEfficiencyMonitor_cfi.py:28
TrackEfficiencyMonitor_cfi.muonPhiMin
muonPhiMin
Definition: TrackEfficiencyMonitor_cfi.py:39
DDAxes::phi
TrackEfficiencyMonitor_cfi.theRadius
theRadius
Definition: TrackEfficiencyMonitor_cfi.py:10
TrackEfficiencyMonitor::StandaloneMuonPtEtaPhiLowPt
MonitorElement * StandaloneMuonPtEtaPhiLowPt
Definition: TrackEfficiencyMonitor.h:105
TrackEfficiencyMonitor_cfi.muonCompatibleLayersMax
muonCompatibleLayersMax
Definition: TrackEfficiencyMonitor_cfi.py:48
TrackEfficiencyMonitor::theTTrackBuilder
edm::ESHandle< TransientTrackBuilder > theTTrackBuilder
Definition: TrackEfficiencyMonitor.h:114
TrackEfficiencyMonitor::measurementTrackerHandle
edm::ESHandle< MeasurementTracker > measurementTrackerHandle
Definition: TrackEfficiencyMonitor.h:118
reco::TransientTrack
Definition: TransientTrack.h:19
TrackEfficiencyMonitor::muonCompatibleLayers
MonitorElement * muonCompatibleLayers
Definition: TrackEfficiencyMonitor.h:90
Propagator::clone
virtual Propagator * clone() const =0
TrackEfficiencyMonitor::trackEfficiency_
bool trackEfficiency_
Definition: TrackEfficiencyMonitor.h:72
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
TrackEfficiencyMonitor::Down
Definition: TrackEfficiencyMonitor.h:50
TrackEfficiencyMonitor::theTKTracksLabel_
edm::InputTag theTKTracksLabel_
Definition: TrackEfficiencyMonitor.h:75
GeometricSearchDet::surface
virtual const BoundSurface & surface() const =0
The surface of the GeometricSearchDet.
TrackEfficiencyMonitor_cfi.theMaxZ
theMaxZ
Definition: TrackEfficiencyMonitor_cfi.py:11
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
TrajectoryStateOnSurface::surface
const SurfaceType & surface() const
Definition: TrajectoryStateOnSurface.h:78
TrackEfficiencyMonitor::Up
Definition: TrackEfficiencyMonitor.h:50
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
TrackEfficiencyMonitor_cfi.deltaXMax
deltaXMax
Definition: TrackEfficiencyMonitor_cfi.py:80
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
TrackEfficiencyMonitor::isBFieldOff_
bool isBFieldOff_
Definition: TrackEfficiencyMonitor.h:71
TrackEfficiencyMonitor_cfi.trackD0Min
trackD0Min
Definition: TrackEfficiencyMonitor_cfi.py:71
TrackEfficiencyMonitor::findDetLayer
bool findDetLayer
Definition: TrackEfficiencyMonitor.h:82
TrackEfficiencyMonitor::GlobalMuonPtEtaPhiHighPt
MonitorElement * GlobalMuonPtEtaPhiHighPt
Definition: TrackEfficiencyMonitor.h:106
TrackEfficiencyMonitor_cfi.trackXMax
trackXMax
Definition: TrackEfficiencyMonitor_cfi.py:52
TrackEfficiencyMonitor::theNavigation
const DirectTrackerNavigation * theNavigation
Definition: TrackEfficiencyMonitor.h:108
TrackEfficiencyMonitor_cfi.trackD0Bin
trackD0Bin
Definition: TrackEfficiencyMonitor_cfi.py:70
TrackEfficiencyMonitor::deltaY
MonitorElement * deltaY
Definition: TrackEfficiencyMonitor.h:101
TrajectoryStateOnSurface::localError
const LocalTrajectoryError & localError() const
Definition: TrajectoryStateOnSurface.h:77
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:85
TrackEfficiencyMonitor::trackCompatibleLayers
MonitorElement * trackCompatibleLayers
Definition: TrackEfficiencyMonitor.h:98
TrackEfficiencyMonitor_cfi.deltaXBin
deltaXBin
Definition: TrackEfficiencyMonitor_cfi.py:78
TrackEfficiencyMonitor_cfi.muonD0Bin
muonD0Bin
Definition: TrackEfficiencyMonitor_cfi.py:42
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:800
TrackEfficiencyMonitor_cfi.trackEtaMin
trackEtaMin
Definition: TrackEfficiencyMonitor_cfi.py:63
LocalError::yy
float yy() const
Definition: LocalError.h:24
TrackEfficiencyMonitor_cfi.muonYBin
muonYBin
Definition: TrackEfficiencyMonitor_cfi.py:26
edm::InputTag
Definition: InputTag.h:15
alongMomentum
Definition: PropagationDirection.h:4
hgcalTopologyTester_cfi.layers
layers
Definition: hgcalTopologyTester_cfi.py:8
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
TrajectoryStateOnSurface::isValid
bool isValid() const
Definition: TrajectoryStateOnSurface.h:54
TrackEfficiencyMonitor::trackerAcceptance
bool trackerAcceptance(TrajectoryStateOnSurface theTSOS, double theRadius, double theMaxZ)
Definition: TrackEfficiencyMonitor.cc:560
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
TrackEfficiencyMonitor_cfi.trackYMin
trackYMin
Definition: TrackEfficiencyMonitor_cfi.py:55
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:40
reco::TransientTrack::innermostMeasurementState
TrajectoryStateOnSurface innermostMeasurementState() const
Definition: TransientTrack.h:88
TrackEfficiencyMonitor::nCompatibleLayers
int nCompatibleLayers
Definition: TrackEfficiencyMonitor.h:81
TrackEfficiencyMonitor_cfi.trackD0Max
trackD0Max
Definition: TrackEfficiencyMonitor_cfi.py:72
TrackingComponentsRecord
Definition: TrackingComponentsRecord.h:12
Generated for CMSSW Reference Manual by doxygen 1.8.16