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, GlobalCacheLuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCacheRunContext
 
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 hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

Private Attributes

edm::ESHandle< MagneticFieldbField
 
edm::ParameterSet conf_
 
MonitorElementdeltaX
 
MonitorElementdeltaY
 
DQMStoredqmStore_
 
int failedToPropagate
 
bool findDetLayer
 
MonitorElementGlobalMuonPtEtaPhiHighPt
 
MonitorElementGlobalMuonPtEtaPhiLowPt
 
std::string histname
 
bool isBFieldOff_
 
edm::ESHandle< MeasurementTrackermeasurementTrackerHandle
 
MonitorElementmuonCompatibleLayers
 
MonitorElementmuonD0
 
MonitorElementmuonEta
 
MonitorElementmuonPhi
 
edm::EDGetTokenT< edm::View< reco::Muon > > muonToken_
 
MonitorElementmuonX
 
MonitorElementmuonY
 
MonitorElementmuonZ
 
int nCompatibleLayers
 
MonitorElementsignDeltaX
 
MonitorElementsignDeltaY
 
MonitorElementStandaloneMuonPtEtaPhiHighPt
 
MonitorElementStandaloneMuonPtEtaPhiLowPt
 
edm::ESHandle< GeometricSearchTrackertheGeometricSearchTracker
 
double theMaxZ_
 
MuonServiceProxytheMuonServiceProxy
 
const DirectTrackerNavigationtheNavigation
 
edm::ESHandle< PropagatorthePropagator
 
edm::ESHandle< PropagatorthePropagatorCyl
 
double theRadius_
 
edm::InputTag theSTATracksLabel_
 
edm::EDGetTokenT< reco::TrackCollectiontheSTATracksToken_
 
edm::InputTag theTKTracksLabel_
 
edm::EDGetTokenT< reco::TrackCollectiontheTKTracksToken_
 
edm::ESHandle< GeometricSearchTrackertheTracker
 
edm::ESHandle< TransientTrackBuildertheTTrackBuilder
 
MonitorElementtrackCompatibleLayers
 
MonitorElementtrackD0
 
bool trackEfficiency_
 
MonitorElementtrackEta
 
MonitorElementtrackPhi
 
MonitorElementtrackX
 
MonitorElementtrackY
 
MonitorElementtrackZ
 

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< DQMEDAnalyzerGlobalCacheinitializeGlobalCache (edm::ParameterSet const &)
 
- Protected Member Functions inherited from DQMEDAnalyzer
uint64_t meId () const
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMTokenlumiToken_
 
edm::EDPutTokenT< DQMTokenrunToken_
 
unsigned int streamId_
 

Detailed Description

Monitoring source to measure the track efficiency

Definition at line 40 of file TrackEfficiencyMonitor.h.

Member Typedef Documentation

◆ Track

Definition at line 42 of file TrackEfficiencyMonitor.h.

◆ TrackCollection

Definition at line 43 of file TrackEfficiencyMonitor.h.

Member Enumeration Documentation

◆ 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 {
280  iEvent.getByToken(theTKTracksToken_, tkTracks);
282  iEvent.getByToken(theSTATracksToken_, staTracks);
284  iSetup.get<NavigationSchoolRecord>().get("CosmicNavigationSchool", nav);
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);
297 
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_2018_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");
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_";
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_";
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_";
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_";
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_";
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,
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_";
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_";
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_";
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_";
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_";
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_";
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,
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_";
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_";
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_";
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_";
255 
256  histname = "GlobalMuonPtEtaPhi_LowPt_";
257  GlobalMuonPtEtaPhiLowPt = ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
259 
260  histname = "StandaloneMuonPtEtaPhi_LowPt_";
262  ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
264 
265  histname = "GlobalMuonPtEtaPhi_HighPt_";
266  GlobalMuonPtEtaPhiHighPt = ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
268 
269  histname = "StandaloneMuonPtEtaPhi_HighPt_";
271  ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
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 
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++) {
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 
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);
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);
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);
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);
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 
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) {
587  const Cylinder::CylinderPointer cyl2 = Cylinder::build(pos02, rot02, theRadius - 10);
588  TrajectoryStateOnSurface tsosAtCyl2 = theTmpPropagator->propagate(*tsosAtCyl.freeState(), *cyl2);
589  if (tsosAtCyl2.isValid()) {
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

◆ 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

◆ 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:355
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:39
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
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:11
ReferenceCountingPointer< Cylinder >
TrackEfficiencyMonitor_cfi.trackXBin
trackXBin
Definition: TrackEfficiencyMonitor_cfi.py:50
TrackEfficiencyMonitor::theTracker
edm::ESHandle< GeometricSearchTracker > theTracker
Definition: TrackEfficiencyMonitor.h:115
HLT_2018_cff.muon
muon
Definition: HLT_2018_cff.py:10349
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:30
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:664
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:73
TrackEfficiencyMonitor_cfi.trackPhiMax
trackPhiMax
Definition: TrackEfficiencyMonitor_cfi.py:68
CkfComponentsRecord
Definition: CkfComponentsRecord.h:22
LocalError::xx
float xx() const
Definition: LocalError.h:22
TrackEfficiencyMonitor_cfi.trackCompatibleLayersBin
trackCompatibleLayersBin
Definition: TrackEfficiencyMonitor_cfi.py:74
PVValHelper::eta
Definition: PVValidationHelpers.h:69
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
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
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
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
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:30
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:84
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
TrackEfficiencyMonitor_cfi.trackYMin
trackYMin
Definition: TrackEfficiencyMonitor_cfi.py:55
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:43
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