CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TrackEfficiencyMonitor.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * \author Jeremy Andrea
5  */
6 
7 #include "DataFormats/TrackReco/interface/Track.h"
8 #include "DataFormats/TrackReco/interface/TrackFwd.h"
9 //#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
10 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
11 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
12 #include "MagneticField/Engine/interface/MagneticField.h"
13 
14 #include "FWCore/MessageLogger/interface/MessageLogger.h"
15 #include "FWCore/Utilities/interface/InputTag.h"
16 #include "DQMServices/Core/interface/DQMStore.h"
17 #include "DQM/TrackingMonitor/interface/TrackEfficiencyMonitor.h"
18 #include <string>
19 
20 // needed to compute the efficiency
21 
22 #include "DataFormats/TrackCandidate/interface/TrackCandidate.h"
23 #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
24 #include "DataFormats/MuonReco/interface/Muon.h"
25 #include "TrackingTools/GeomPropagators/interface/Propagator.h"
26 #include "TrackingTools/PatternTools/interface/TwoTrackMinimumDistance.h"
27 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
28 
29 #include "TrackPropagation/SteppingHelixPropagator/interface/SteppingHelixPropagator.h"
30 #include "TrackingTools/GeomPropagators/interface/SmartPropagator.h"
31 #include "DataFormats/Math/interface/Vector3D.h"
32 #include "DataFormats/GeometrySurface/interface/Plane.h"
33 #include "DataFormats/GeometrySurface/interface/BoundPlane.h"
34 #include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"
35 
36 #include "CommonTools/UtilAlgos/interface/TFileService.h"
37 #include "DataFormats/GeometrySurface/interface/Cylinder.h"
38 
39 #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
40 #include <RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h>
41 
42 #include "RecoTracker/Record/interface/CkfComponentsRecord.h"
43 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
44 #include "RecoTracker/Record/interface/NavigationSchoolRecord.h"
45 
46 
47 
48 //-----------------------------------------------------------------------------------
49 TrackEfficiencyMonitor::TrackEfficiencyMonitor(const edm::ParameterSet& iConfig)
50 //-----------------------------------------------------------------------------------
51 {
52  dqmStore_ = edm::Service<DQMStore>().operator->();
53 
54  theRadius_ = iConfig.getParameter<double>("theRadius");
55  theMaxZ_ = iConfig.getParameter<double>("theMaxZ");
56  isBFieldOff_ = iConfig.getParameter<bool>("isBFieldOff");
57  trackEfficiency_ = iConfig.getParameter<bool>("trackEfficiency");
58  theTKTracksLabel_ = iConfig.getParameter<edm::InputTag>("TKTrackCollection");
59  theSTATracksLabel_ = iConfig.getParameter<edm::InputTag>("STATrackCollection");
60 
61  theTKTracksToken_ = consumes<reco::TrackCollection>(theTKTracksLabel_);
62  theSTATracksToken_ = consumes<reco::TrackCollection>(theSTATracksLabel_);
63 
64  conf_ = iConfig;
65 }
66 
67 
68 
69 //-----------------------------------------------------------------------------------
70 TrackEfficiencyMonitor::~TrackEfficiencyMonitor()
71 //-----------------------------------------------------------------------------------
72 {}
73 
74 //-----------------------------------------------------------------------------------
75 void TrackEfficiencyMonitor::bookHistograms(DQMStore::IBooker & ibooker,
76  edm::Run const & /* iRun */,
77  edm::EventSetup const & /* iSetup */)
78 //-----------------------------------------------------------------------------------
79 {
80  std::string MEFolderName = conf_.getParameter<std::string>("FolderName");
81  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
82 
83 
84  ibooker.setCurrentFolder(MEFolderName);
85 
86  //
87  int muonXBin = conf_.getParameter<int> ("muonXBin");
88  double muonXMin = conf_.getParameter<double>("muonXMin");
89  double muonXMax = conf_.getParameter<double>("muonXMax");
90 
91  histname = "muonX_";
92  muonX = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonXBin, muonXMin, muonXMax);
93  muonX->setAxisTitle("");
94 
95  //
96  int muonYBin = conf_.getParameter<int> ("muonYBin");
97  double muonYMin = conf_.getParameter<double>("muonYMin");
98  double muonYMax = conf_.getParameter<double>("muonYMax");
99 
100  histname = "muonY_";
101  muonY = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonYBin, muonYMin, muonYMax);
102  muonY->setAxisTitle("");
103 
104  //
105  int muonZBin = conf_.getParameter<int> ("muonZBin");
106  double muonZMin = conf_.getParameter<double>("muonZMin");
107  double muonZMax = conf_.getParameter<double>("muonZMax");
108 
109  histname = "muonZ_";
110  muonZ = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonZBin, muonZMin, muonZMax);
111  muonZ->setAxisTitle("");
112 
113  //
114  int muonEtaBin = conf_.getParameter<int> ("muonEtaBin");
115  double muonEtaMin = conf_.getParameter<double>("muonEtaMin");
116  double muonEtaMax = conf_.getParameter<double>("muonEtaMax");
117 
118  histname = "muonEta_";
119  muonEta = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonEtaBin, muonEtaMin, muonEtaMax);
120  muonEta->setAxisTitle("");
121 
122  //
123  int muonPhiBin = conf_.getParameter<int> ("muonPhiBin");
124  double muonPhiMin = conf_.getParameter<double>("muonPhiMin");
125  double muonPhiMax = conf_.getParameter<double>("muonPhiMax");
126 
127  histname = "muonPhi_";
128  muonPhi = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonPhiBin, muonPhiMin, muonPhiMax);
129  muonPhi->setAxisTitle("");
130 
131  //
132  int muonD0Bin = conf_.getParameter<int> ("muonD0Bin");
133  double muonD0Min = conf_.getParameter<double>("muonD0Min");
134  double muonD0Max = conf_.getParameter<double>("muonD0Max");
135 
136  histname = "muonD0_";
137  muonD0 = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonD0Bin, muonD0Min, muonD0Max);
138  muonD0->setAxisTitle("");
139 
140  //
141  int muonCompatibleLayersBin = conf_.getParameter<int> ("muonCompatibleLayersBin");
142  double muonCompatibleLayersMin = conf_.getParameter<double>("muonCompatibleLayersMin");
143  double muonCompatibleLayersMax = conf_.getParameter<double>("muonCompatibleLayersMax");
144 
145  histname = "muonCompatibleLayers_";
146  muonCompatibleLayers = ibooker.book1D(histname+AlgoName, histname+AlgoName, muonCompatibleLayersBin, muonCompatibleLayersMin, 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, histname+AlgoName, trackCompatibleLayersBin, trackCompatibleLayersMin, trackCompatibleLayersMax);
212  trackCompatibleLayers->setAxisTitle("");
213 
214  //------------------------------------------------------------------------------------
215 
216  //
217  int deltaXBin = conf_.getParameter<int> ("deltaXBin");
218  double deltaXMin = conf_.getParameter<double>("deltaXMin");
219  double deltaXMax = conf_.getParameter<double>("deltaXMax");
220 
221  histname = "deltaX_";
222  deltaX = ibooker.book1D(histname+AlgoName, histname+AlgoName, deltaXBin, deltaXMin, deltaXMax);
223  deltaX->setAxisTitle("");
224 
225  //
226  int deltaYBin = conf_.getParameter<int> ("deltaYBin");
227  double deltaYMin = conf_.getParameter<double>("deltaYMin");
228  double deltaYMax = conf_.getParameter<double>("deltaYMax");
229 
230  histname = "deltaY_";
231  deltaY = ibooker.book1D(histname+AlgoName, histname+AlgoName, deltaYBin, deltaYMin, deltaYMax);
232  deltaY->setAxisTitle("");
233 
234  //
235  int signDeltaXBin = conf_.getParameter<int> ("signDeltaXBin");
236  double signDeltaXMin = conf_.getParameter<double>("signDeltaXMin");
237  double signDeltaXMax = conf_.getParameter<double>("signDeltaXMax");
238 
239  histname = "signDeltaX_";
240  signDeltaX = ibooker.book1D(histname+AlgoName, histname+AlgoName, signDeltaXBin, signDeltaXMin, signDeltaXMax);
241  signDeltaX->setAxisTitle("");
242 
243  //
244  int signDeltaYBin = conf_.getParameter<int> ("signDeltaYBin");
245  double signDeltaYMin = conf_.getParameter<double>("signDeltaYMin");
246  double signDeltaYMax = conf_.getParameter<double>("signDeltaYMax");
247 
248  histname = "signDeltaY_";
249  signDeltaY = ibooker.book1D(histname+AlgoName, histname+AlgoName, signDeltaYBin, signDeltaYMin, signDeltaYMax);
250  signDeltaY->setAxisTitle("");
251 
252 }
253 
254 
255 //-----------------------------------------------------------------------------------
256 void TrackEfficiencyMonitor::beginJob(void)
257 //-----------------------------------------------------------------------------------
258 {
259 
260 }
261 
262 
263 
264 //-----------------------------------------------------------------------------------
265 void TrackEfficiencyMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
266 //-----------------------------------------------------------------------------------
267 {
268 
269 
270  edm::Handle<reco::TrackCollection> tkTracks;
271  iEvent.getByToken(theTKTracksToken_, tkTracks);
272  edm::Handle<reco::TrackCollection> staTracks;
273  iEvent.getByToken(theSTATracksToken_, staTracks);
274  edm::ESHandle<NavigationSchool> nav;
275  iSetup.get<NavigationSchoolRecord>().get("CosmicNavigationSchool", nav);
276  iSetup.get<CkfComponentsRecord>().get(measurementTrackerHandle);
277 
278  nCompatibleLayers = 0;
279 
280  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theTTrackBuilder);
281  iSetup.get<TrackingComponentsRecord>().get("SteppingHelixPropagatorAny",thePropagator);
282  iSetup.get<IdealMagneticFieldRecord>().get(bField);
283  iSetup.get<TrackerRecoGeometryRecord>().get(theTracker);
284  theNavigation = new DirectTrackerNavigation(theTracker);
285 
286 
287  if(trackEfficiency_){
288  //---------------------------------------------------
289  // Select muons with good quality
290  // If B field is on, no up-down matching between the muons
291  //---------------------------------------------------
292  bool isGoodMuon = false;
293  double mudd0 = 0., mudphi = 0., muddsz = 0., mudeta = 0.;
294  if(isBFieldOff_)
295  {
296  if ( staTracks->size() == 2 )
297  {
298  for ( unsigned int bindex = 0; bindex < staTracks->size(); ++bindex )
299  {
300 
301  if (0 == bindex){
302  mudd0+=(*staTracks)[bindex].d0();
303  mudphi+=(*staTracks)[bindex].phi();
304  muddsz+=(*staTracks)[bindex].dsz();
305  mudeta+=(*staTracks)[bindex].eta();}
306  if (1 == bindex){
307  mudd0-=(*staTracks)[bindex].d0();
308  mudphi-=(*staTracks)[bindex].phi();
309  muddsz-=(*staTracks)[bindex].dsz();
310  mudeta-=(*staTracks)[bindex].eta();}
311  }
312  if ((fabs(mudd0)<15.0)&&(fabs(mudphi)<0.045)&&(fabs(muddsz)<20.0)&&(fabs(mudeta)<0.060)) isGoodMuon = true;
313  }
314 
315  if(isGoodMuon) testTrackerTracks(tkTracks,staTracks, *nav.product());
316 
317  }
318  else if ( staTracks->size() == 1 || staTracks->size() == 2) testTrackerTracks(tkTracks,staTracks, *nav.product());
319  }
320 
321 
322  if(!trackEfficiency_ && tkTracks->size() == 1 ){
323  if( (tkTracks->front()).normalizedChi2() < 5 &&
324  (tkTracks->front()).hitPattern().numberOfValidHits() > 8)
325  testSTATracks(tkTracks,staTracks);
326  }
327 
328 
329  delete theNavigation;
330 
331 }
332 
333 
334 
335 //-----------------------------------------------------------------------------------
336 void TrackEfficiencyMonitor::endJob(void)
337 //-----------------------------------------------------------------------------------
338 {
339  bool outputMEsInRootFile = conf_.getParameter<bool>("OutputMEsInRootFile");
340  std::string outputFileName = conf_.getParameter<std::string>("OutputFileName");
341  if(outputMEsInRootFile){
342  dqmStore_->showDirStructure();
343  dqmStore_->save(outputFileName);
344  }
345 
346  //if ( theNavigation ) delete theNavigation;
347 
348 }
349 
350 
351 
352 //-----------------------------------------------------------------------------------
353 void TrackEfficiencyMonitor::testTrackerTracks(edm::Handle<reco::TrackCollection> tkTracks, edm::Handle<reco::TrackCollection> staTracks, const NavigationSchool& navigationSchool)
354 //-----------------------------------------------------------------------------------
355 {
356 
357  const std::string metname = "testStandAloneMuonTracks";
358 
359  //---------------------------------------------------
360  // get the index of the "up" muon
361  // histograms will only be computed for the "up" muon
362  //---------------------------------------------------
363 
364  int nUpMuon = 0;
365  int idxUpMuon = -1;
366  for(unsigned int i =0; i< staTracks->size(); i++){
367  if( checkSemiCylinder((*staTracks)[i]) == TrackEfficiencyMonitor::Up ){
368  nUpMuon++;
369  idxUpMuon = i;
370  }
371  }
372 
373 
374  if( nUpMuon == 1)
375  {
376 
377  //---------------------------------------------------
378  //get the muon informations
379  //---------------------------------------------------
380 
381  reco::TransientTrack staTT = theTTrackBuilder->build((*staTracks)[idxUpMuon]);
382  double ipX = staTT.impactPointState().globalPosition().x();
383  double ipY = staTT.impactPointState().globalPosition().y();
384  double ipZ = staTT.impactPointState().globalPosition().z();
385  double eta = staTT.impactPointState().globalDirection().eta();
386  double phi = staTT.impactPointState().globalDirection().phi();
387  double d0 = (*staTracks)[idxUpMuon].d0();
388 
389  TrajectoryStateOnSurface theTSOS = staTT.outermostMeasurementState();
390  TrajectoryStateOnSurface theTSOSCompLayers = staTT.outermostMeasurementState();
391 
392 
393  //---------------------------------------------------
394  //check if the muon is in the tracker acceptance
395  //---------------------------------------------------
396  bool isInTrackerAcceptance = false;
397  isInTrackerAcceptance = trackerAcceptance( theTSOS, theRadius_ , theMaxZ_ );
398 
399  //---------------------------------------------------st
400  //count the number of compatible layers
401  //---------------------------------------------------
402  nCompatibleLayers = compatibleLayers(navigationSchool, theTSOSCompLayers);
403 
404  if(isInTrackerAcceptance && (*staTracks)[idxUpMuon].hitPattern().numberOfValidHits() > 28)
405  {
406  //---------------------------------------------------
407  //count the number of good muon candidates
408  //---------------------------------------------------
409 
410  TrajectoryStateOnSurface staState;
411  LocalVector diffLocal;
412 
413 
414  bool isTrack = false;
415  if(!tkTracks->empty())
416  {
417  //---------------------------------------------------
418  //look for associated tracks
419  //---------------------------------------------------
420  float DR2min = 1000;
421  reco::TrackCollection::const_iterator closestTrk = tkTracks->end();
422 
423  for(reco::TrackCollection::const_iterator tkTrack = tkTracks->begin(); tkTrack != tkTracks->end(); ++tkTrack)
424  {
425  reco::TransientTrack tkTT = theTTrackBuilder->build(*tkTrack);
426  TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
427  staState = thePropagator->propagate(staTT.outermostMeasurementState(),tkInner.surface());
428  failedToPropagate = 1;
429 
430  if(staState.isValid())
431  {
432  failedToPropagate = 0;
433  diffLocal = tkInner.localPosition() - staState.localPosition();
434  double DR2 = diffLocal.x()*diffLocal.x()+diffLocal.y()*diffLocal.y();
435  if (DR2<DR2min) { DR2min = DR2; closestTrk = tkTrack;}
436  if ( pow(DR2,0.5) < 100. ) isTrack = true;
437  }
438  }
439 
440 
441  if (DR2min != 1000)
442  {
443 
444  reco::TransientTrack tkTT = theTTrackBuilder->build(*closestTrk);
445  TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
446  staState = thePropagator->propagate(staTT.outermostMeasurementState(),tkInner.surface());
447  deltaX->Fill(diffLocal.x());
448  deltaY->Fill(diffLocal.y());
449  signDeltaX->Fill(diffLocal.x()/(tkInner.localError().positionError().xx() + staState.localError().positionError().xx()));
450  signDeltaY->Fill(diffLocal.y()/(tkInner.localError().positionError().yy() + staState.localError().positionError().yy()));
451 
452  }
453  }
454 
455 
456  if(failedToPropagate == 0)
457  {
458  muonX->Fill(ipX);
459  muonY->Fill(ipY);
460  muonZ->Fill(ipZ);
461  muonEta->Fill(eta);
462  muonPhi->Fill(phi);
463  muonD0->Fill(d0);
464  muonCompatibleLayers->Fill(nCompatibleLayers);
465 
466  if(isTrack)
467  {
468  trackX->Fill(ipX);
469  trackY->Fill(ipY);
470  trackZ->Fill(ipZ);
471  trackEta->Fill(eta);
472  trackPhi->Fill(phi);
473  trackD0->Fill(d0);
474  trackCompatibleLayers->Fill(nCompatibleLayers);
475  }
476  }
477  }
478  }
479 
480 }
481 
482 
483 
484 
485 
486 
487 
488 
489 
490 
491 
492 //-----------------------------------------------------------------------------------
493 void TrackEfficiencyMonitor::testSTATracks(edm::Handle<reco::TrackCollection> tkTracks, edm::Handle<reco::TrackCollection> staTracks)
494 //-----------------------------------------------------------------------------------
495 {
496 
497 
498  reco::TransientTrack tkTT = theTTrackBuilder->build(tkTracks->front());
499  double ipX = tkTT.impactPointState().globalPosition().x();
500  double ipY = tkTT.impactPointState().globalPosition().y();
501  double ipZ = tkTT.impactPointState().globalPosition().z();
502  double eta = tkTT.impactPointState().globalDirection().eta();
503  double phi = tkTT.impactPointState().globalDirection().phi();
504  double d0 = (*tkTracks)[0].d0();
505 
506  TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
507  LocalVector diffLocal;
508  TrajectoryStateOnSurface staState;
509  bool isTrack = false;
510 
511 
512  if(!staTracks->empty()){
513 
514  //---------------------------------------------------
515  //look for associated muons
516  //---------------------------------------------------
517 
518  float DR2min = 1000;
519  reco::TrackCollection::const_iterator closestTrk = staTracks->end();
520  //----------------------loop on tracker tracks:
521  for(reco::TrackCollection::const_iterator staTrack = staTracks->begin(); staTrack != staTracks->end(); ++staTrack){
522  if(checkSemiCylinder(*staTrack) == TrackEfficiencyMonitor::Up){
523 
524  reco::TransientTrack staTT = theTTrackBuilder->build(*staTrack);
525  failedToPropagate = 1;
526  staState = thePropagator->propagate(staTT.outermostMeasurementState(),tkInner.surface());
527 
528 
529  if(staState.isValid())
530  {
531  failedToPropagate = 0;
532  diffLocal = tkInner.localPosition() - staState.localPosition();
533 
534  double DR2 = diffLocal.x()*diffLocal.x()+diffLocal.y()*diffLocal.y();
535  if (DR2<DR2min) { DR2min = DR2; closestTrk = staTrack;}
536  if ( pow(DR2,0.5) < 100. ) isTrack = true;
537  }
538  }
539  }
540  }
541 
542  if(failedToPropagate == 0)
543  {
544 
545  trackX->Fill(ipX);
546  trackY->Fill(ipY);
547  trackZ->Fill(ipZ);
548  trackEta->Fill(eta);
549  trackPhi->Fill(phi);
550  trackD0->Fill(d0);
551 
552  if(isTrack)
553  {
554  muonX->Fill(ipX);
555  muonY->Fill(ipY);
556  muonZ->Fill(ipZ);
557  muonEta->Fill(eta);
558  muonPhi->Fill(phi);
559  muonD0->Fill(d0);
560  }
561  }
562 
563 
564 
565 }
566 
567 
568 
569 
570 
571 
572 
573 
574 
575 
576 
577 
578 
579 
580 
581 
582 
583 //-----------------------------------------------------------------------------------
584 TrackEfficiencyMonitor::SemiCylinder TrackEfficiencyMonitor::checkSemiCylinder(const reco::Track& tk)
585 //-----------------------------------------------------------------------------------
586 {
587  return tk.innerPosition().phi() > 0 ? TrackEfficiencyMonitor::Up : TrackEfficiencyMonitor::Down;
588 }
589 
590 
591 
592 //-----------------------------------------------------------------------------------
593 bool TrackEfficiencyMonitor::trackerAcceptance( TrajectoryStateOnSurface theTSOS, double theRadius, double theMaxZ)
594 //-----------------------------------------------------------------------------------
595 {
596 
597  //---------------------------------------------------
598  // check if the muon is in the tracker acceptance
599  // check the compatibility with a cylinder of radius "theRadius"
600  //---------------------------------------------------
601 
602  //Propagator* theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
603 
604  //Propagator* theTmpPropagator = &*thePropagator;
605  Propagator* theTmpPropagator = &*thePropagator->clone();
606 
607  if (theTSOS.globalPosition().y() <0 ) theTmpPropagator->setPropagationDirection(oppositeToMomentum);
608  else theTmpPropagator->setPropagationDirection(alongMomentum);
609 
610  Cylinder::PositionType pos0;
611  Cylinder::RotationType rot0;
612  const Cylinder::CylinderPointer cyl = Cylinder::build(pos0, rot0, theRadius);
613  TrajectoryStateOnSurface tsosAtCyl = theTmpPropagator->propagate(*theTSOS.freeState(), *cyl);
614  double accept = false;
615  if ( tsosAtCyl.isValid() ) {
616  if (fabs(tsosAtCyl.globalPosition().z())<theMaxZ ) {
617  Cylinder::PositionType pos02;
618  Cylinder::RotationType rot02;
619  const Cylinder::CylinderPointer cyl2 = Cylinder::build(pos02, rot02, theRadius -10);
620  TrajectoryStateOnSurface tsosAtCyl2 = theTmpPropagator->propagate(*tsosAtCyl.freeState(), *cyl2);
621  if ( tsosAtCyl2.isValid() ) {
622  Cylinder::PositionType pos03;
623  Cylinder::RotationType rot03;
624  const Cylinder::CylinderPointer cyl3 = Cylinder::build(pos03, rot03, theRadius );
625  TrajectoryStateOnSurface tsosAtCyl3 = theTmpPropagator->propagate(*tsosAtCyl2.freeState(), *cyl3);
626  if ( tsosAtCyl3.isValid() ) {
627  accept=true;
628  }
629  }
630 
631  }
632  }
633  delete theTmpPropagator;
634  //muon propagated to the barrel cylinder
635  return accept;
636 
637 }
638 
639 
640 
641 //-----------------------------------------------------------------------------------
642 int TrackEfficiencyMonitor::compatibleLayers(const NavigationSchool& navigationSchool, TrajectoryStateOnSurface theTSOS)
643 //-----------------------------------------------------------------------------------
644 {
645  //---------------------------------------------------
646  // check the number of compatible layers
647  //---------------------------------------------------
648 
649  std::vector< const BarrelDetLayer*> barrelTOBLayers = measurementTrackerHandle->geometricSearchTracker()->tobLayers() ;
650 
651  unsigned int layers = 0;
652  for ( unsigned int k=0 ; k < barrelTOBLayers.size() ; k++ )
653  {
654  const DetLayer* firstLay = barrelTOBLayers[barrelTOBLayers.size() -1 - k];
655 
656  //Propagator* theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
657 
658 
659 
660  Propagator* theTmpPropagator = &*thePropagator->clone();
661  theTmpPropagator->setPropagationDirection(alongMomentum);
662 
663  TrajectoryStateOnSurface startTSOS = theTmpPropagator->propagate(*theTSOS.freeState(),firstLay->surface());
664 
665  std::vector< const DetLayer*> trackCompatibleLayers;
666 
667  findDetLayer = true;
668  bool isUpMuon = false;
669  bool firstdtep = true;
670 
671  if(startTSOS.isValid())
672  {
673 
674  if(firstdtep) layers++;
675 
676  int nwhile = 0;
677 
678  //for other compatible layers
679  while ( startTSOS.isValid() && firstLay && findDetLayer)
680  {
681 
682  if(firstdtep && startTSOS.globalPosition().y()> 0) isUpMuon = true;
683 
684  if(firstdtep){
685  std::vector< const DetLayer*> firstCompatibleLayers;
686  firstCompatibleLayers.push_back(firstLay);
687  std::pair<TrajectoryStateOnSurface, const DetLayer* > nextLayer = findNextLayer(theTSOS, firstCompatibleLayers, isUpMuon );
688  firstdtep = false;
689  }
690  else{
691  trackCompatibleLayers = navigationSchool.nextLayers(*firstLay, *(startTSOS.freeState()),alongMomentum);
692  if (trackCompatibleLayers.size()!=0 ){
693  std::pair<TrajectoryStateOnSurface, const DetLayer* > nextLayer = findNextLayer(startTSOS, trackCompatibleLayers, isUpMuon );
694  if (firstLay != nextLayer.second ){
695  firstLay = nextLayer.second;
696  startTSOS = nextLayer.first;
697  layers++;
698  }
699  else firstLay=0;
700  }
701  }
702  nwhile++;
703  if(nwhile > 100) break;
704 
705  }
706  delete theTmpPropagator;
707  break;
708  }
709  delete theTmpPropagator;
710  }
711  return layers;
712 
713 }
714 
715 
716 
717 
718 //-----------------------------------------------------------------------------------
719 std::pair<TrajectoryStateOnSurface, const DetLayer*> TrackEfficiencyMonitor::findNextLayer( TrajectoryStateOnSurface sTSOS, const std::vector< const DetLayer*>& trackCompatibleLayers , bool isUpMuon )
720 //-----------------------------------------------------------------------------------
721 {
722 
723  //Propagator* theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
724 
725 
726  Propagator* theTmpPropagator = &*thePropagator->clone();
727  theTmpPropagator->setPropagationDirection(alongMomentum);
728 
729 
730  std::vector<const DetLayer*>::const_iterator itl;
731  findDetLayer = false;
732  for (itl=trackCompatibleLayers.begin();itl!=trackCompatibleLayers.end();++itl) {
733  TrajectoryStateOnSurface tsos = theTmpPropagator->propagate(*(sTSOS.freeState()),(**itl).surface());
734  if (tsos.isValid())
735  {
736  sTSOS = tsos;
737  findDetLayer = true;
738 
739  break;
740  }
741  }
742  std::pair<TrajectoryStateOnSurface, const DetLayer* > blabla;
743  blabla.first = sTSOS;
744  blabla.second = &**itl;
745  delete theTmpPropagator;
746  return blabla;
747 }
748 
749 DEFINE_FWK_MODULE(TrackEfficiencyMonitor);
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
GeometricSearchDet::surface
virtual const BoundSurface & surface() const =0
The surface of the GeometricSearchDet.
Propagator::propagate
virtual FreeTrajectoryState propagate(const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const final
Definition: Propagator.h:119
i
int i
Definition: DBlmapReader.cc:9
TrackEfficiencyMonitor::bField
edm::ESHandle< MagneticField > bField
Definition: TrackEfficiencyMonitor.h:120
Propagator::setPropagationDirection
virtual void setPropagationDirection(PropagationDirection dir)
Definition: Propagator.h:144
LocalError::xx
float xx() const
Definition: LocalError.h:24
LayerTriplets::layers
std::vector< LayerSetAndLayers > layers(const SeedingLayerSetsHits &sets)
Definition: LayerTriplets.cc:4
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:449
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:44
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
TrackEfficiencyMonitor::theTracker
edm::ESHandle< GeometricSearchTracker > theTracker
Definition: TrackEfficiencyMonitor.h:119
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:69
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
TrajectoryStateOnSurface::globalPosition
GlobalPoint globalPosition() const
Definition: TrajectoryStateOnSurface.h:89
eta
T eta() const
Definition: Basic3DVectorLD.h:177
muonTagProbeFilters_cff.staTracks
tuple staTracks
Definition: muonTagProbeFilters_cff.py:29
TrackEfficiencyMonitor::testTrackerTracks
void testTrackerTracks(edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks, const NavigationSchool &navigationSchool)
Definition: TrackEfficiencyMonitor.cc:353
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:25
LocalTrajectoryError::positionError
LocalError positionError() const
Definition: LocalTrajectoryError.h:83
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
reco::TransientTrack::innermostMeasurementState
TrajectoryStateOnSurface innermostMeasurementState() const
Definition: TransientTrack.h:81
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
reco::Track::innerPosition
const math::XYZPoint & innerPosition() const
position of the innermost hit
Definition: Track.h:55
dumpDBToFile_GT_ttrig_cfg.outputFileName
tuple outputFileName
Definition: dumpDBToFile_GT_ttrig_cfg.py:31
Cylinder::build
static CylinderPointer build(const PositionType &pos, const RotationType &rot, Scalar radius, Bounds *bounds=0)
Definition: Cylinder.h:51
TrackEfficiencyMonitor::muonCompatibleLayers
MonitorElement * muonCompatibleLayers
Definition: TrackEfficiencyMonitor.h:97
iEvent
int iEvent
Definition: GenABIO.cc:230
TrajectoryStateOnSurface::surface
const SurfaceType & surface() const
Definition: TrajectoryStateOnSurface.h:128
LocalError::yy
float yy() const
Definition: LocalError.h:26
TrajectoryStateOnSurface::freeState
FreeTrajectoryState const * freeState(bool withErrors=true) const
Definition: TrajectoryStateOnSurface.h:76
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
TrackEfficiencyMonitor::measurementTrackerHandle
edm::ESHandle< MeasurementTracker > measurementTrackerHandle
Definition: TrackEfficiencyMonitor.h:122
PFRecoTauChargedHadronQualityPlugins_cfi.isTrack
tuple isTrack
Definition: PFRecoTauChargedHadronQualityPlugins_cfi.py:20
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TrackEfficiencyMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: TrackEfficiencyMonitor.cc:75
TrajectoryStateOnSurface::localError
const LocalTrajectoryError & localError() const
Definition: TrajectoryStateOnSurface.h:125
TrackEfficiencyMonitor::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TrackEfficiencyMonitor.cc:265
reco::TransientTrack::outermostMeasurementState
TrajectoryStateOnSurface outermostMeasurementState() const
Definition: TransientTrack.h:78
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:567
TrackEfficiencyMonitor::theTKTracksToken_
edm::EDGetTokenT< reco::TrackCollection > theTKTracksToken_
Definition: TrackEfficiencyMonitor.h:83
TrackEfficiencyMonitor::thePropagator
edm::ESHandle< Propagator > thePropagator
Definition: TrackEfficiencyMonitor.h:116
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
TrackEfficiencyMonitor::findNextLayer
std::pair< TrajectoryStateOnSurface, const DetLayer * > findNextLayer(TrajectoryStateOnSurface startTSOS, const std::vector< const DetLayer * > &trackCompatibleLayers, bool isUpMuon)
Definition: TrackEfficiencyMonitor.cc:719
TrackEfficiencyMonitor::theTTrackBuilder
edm::ESHandle< TransientTrackBuilder > theTTrackBuilder
Definition: TrackEfficiencyMonitor.h:118
HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043
NavigationSchool::nextLayers
std::vector< const DetLayer * > nextLayers(const DetLayer &detLayer, Args &&...args) const
NavigationDirection.
Definition: NavigationSchool.h:37
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
TrackEfficiencyMonitor::theNavigation
const DirectTrackerNavigation * theNavigation
Definition: TrackEfficiencyMonitor.h:112
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:76
DQMStore::save
void save(const std::string &filename, const std::string &path="", const std::string &pattern="", const std::string &rewrite="", const uint32_t run=0, const uint32_t lumi=0, SaveReferenceTag ref=SaveWithReference, int minStatus=dqm::qstatus::STATUS_OK, const std::string &fileupdate="RECREATE", const bool resetMEsAfterWriting=false)
Definition: DQMStore.cc:2608
TrackEfficiencyMonitor::trackerAcceptance
bool trackerAcceptance(TrajectoryStateOnSurface theTSOS, double theRadius, double theMaxZ)
Definition: TrackEfficiencyMonitor.cc:593
TrackEfficiencyMonitor::compatibleLayers
int compatibleLayers(const NavigationSchool &navigationSchool, TrajectoryStateOnSurface theTSOS)
Definition: TrackEfficiencyMonitor.cc:642
TrackEfficiencyMonitor::TrackEfficiencyMonitor
TrackEfficiencyMonitor(const edm::ParameterSet &)
Definition: TrackEfficiencyMonitor.cc:49
reco::TransientTrack::impactPointState
TrajectoryStateOnSurface impactPointState() const
Definition: TransientTrack.h:94
DQMStore::showDirStructure
void showDirStructure(void) const
Definition: DQMStore.cc:3401
TrackEfficiencyMonitor::checkSemiCylinder
SemiCylinder checkSemiCylinder(const Track &)
Definition: TrackEfficiencyMonitor.cc:584
relval_steps.k
list k
Definition: relval_steps.py:1518
TrackEfficiencyMonitor::trackCompatibleLayers
MonitorElement * trackCompatibleLayers
Definition: TrackEfficiencyMonitor.h:105
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
TrackEfficiencyMonitor::testSTATracks
void testSTATracks(edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks)
Definition: TrackEfficiencyMonitor.cc:493
TrackEfficiencyMonitor::theSTATracksToken_
edm::EDGetTokenT< reco::TrackCollection > theSTATracksToken_
Definition: TrackEfficiencyMonitor.h:84
edm::Run
Definition: Run.h:41
TrajectoryStateOnSurface::globalDirection
GlobalVector globalDirection() const
Definition: TrajectoryStateOnSurface.h:95
phi
Definition: DDAxes.h:10
Generated for CMSSW Reference Manual by doxygen 1.8.5