CMS 3D CMS Logo
TrackSplittingMonitor.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * \author Suchandra Dutta , Giorgia Mila
5  */
6 
7 #include "DQM/TrackingMonitor/interface/TrackSplittingMonitor.h"
8 #include "DQMServices/Core/interface/DQMStore.h"
9 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
10 #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
11 #include "DataFormats/TrackReco/interface/Track.h"
12 #include "DataFormats/TrackReco/interface/TrackFwd.h"
13 #include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"
14 #include "FWCore/MessageLogger/interface/MessageLogger.h"
15 #include "FWCore/Utilities/interface/InputTag.h"
16 #include "TrackingTools/PatternTools/interface/TSCBLBuilderNoMaterial.h"
17 #include "TrackingTools/PatternTools/interface/TSCPBuilderNoMaterial.h"
18 #include "TrackingTools/Records/interface/TransientRecHitRecord.h"
19 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
20 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
21 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
22 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
23 
24 #include <string>
25 
26 TrackSplittingMonitor::TrackSplittingMonitor(const edm::ParameterSet& iConfig)
27  : conf_(iConfig),
28  mfToken_(esConsumes()),
29  tkGeomToken_(esConsumes()),
30  dtGeomToken_(esConsumes()),
31  cscGeomToken_(esConsumes()),
32  rpcGeomToken_(esConsumes()),
33  splitTracksToken_(consumes<std::vector<reco::Track> >(conf_.getParameter<edm::InputTag>("splitTrackCollection"))),
34  splitMuonsToken_(mayConsume<std::vector<reco::Muon> >(conf_.getParameter<edm::InputTag>("splitMuonCollection"))),
35  plotMuons_(conf_.getParameter<bool>("ifPlotMuons")),
36  pixelHitsPerLeg_(conf_.getParameter<int>("pixelHitsPerLeg")),
37  totalHitsPerLeg_(conf_.getParameter<int>("totalHitsPerLeg")),
38  d0Cut_(conf_.getParameter<double>("d0Cut")),
39  dzCut_(conf_.getParameter<double>("dzCut")),
40  ptCut_(conf_.getParameter<double>("ptCut")),
41  norchiCut_(conf_.getParameter<double>("norchiCut")) {}
42 
43 void TrackSplittingMonitor::bookHistograms(DQMStore::IBooker& ibooker,
44  edm::Run const& /* iRun */,
45  edm::EventSetup const& /* iSetup */) {
46  std::string MEFolderName = conf_.getParameter<std::string>("FolderName");
47  ibooker.setCurrentFolder(MEFolderName);
48 
49  // bin declarations
50  int ddxyBin = conf_.getParameter<int>("ddxyBin");
51  double ddxyMin = conf_.getParameter<double>("ddxyMin");
52  double ddxyMax = conf_.getParameter<double>("ddxyMax");
53 
54  int ddzBin = conf_.getParameter<int>("ddzBin");
55  double ddzMin = conf_.getParameter<double>("ddzMin");
56  double ddzMax = conf_.getParameter<double>("ddzMax");
57 
58  int dphiBin = conf_.getParameter<int>("dphiBin");
59  double dphiMin = conf_.getParameter<double>("dphiMin");
60  double dphiMax = conf_.getParameter<double>("dphiMax");
61 
62  int dthetaBin = conf_.getParameter<int>("dthetaBin");
63  double dthetaMin = conf_.getParameter<double>("dthetaMin");
64  double dthetaMax = conf_.getParameter<double>("dthetaMax");
65 
66  int dptBin = conf_.getParameter<int>("dptBin");
67  double dptMin = conf_.getParameter<double>("dptMin");
68  double dptMax = conf_.getParameter<double>("dptMax");
69 
70  int dcurvBin = conf_.getParameter<int>("dcurvBin");
71  double dcurvMin = conf_.getParameter<double>("dcurvMin");
72  double dcurvMax = conf_.getParameter<double>("dcurvMax");
73 
74  int normBin = conf_.getParameter<int>("normBin");
75  double normMin = conf_.getParameter<double>("normMin");
76  double normMax = conf_.getParameter<double>("normMax");
77 
78  // declare histogram
79  ddxyAbsoluteResiduals_tracker_ =
80  ibooker.book1D("ddxyAbsoluteResiduals_tracker", "ddxyAbsoluteResiduals_tracker", ddxyBin, ddxyMin, ddxyMax);
81  ddzAbsoluteResiduals_tracker_ =
82  ibooker.book1D("ddzAbsoluteResiduals_tracker", "ddzAbsoluteResiduals_tracker", ddzBin, ddzMin, ddzMax);
83  dphiAbsoluteResiduals_tracker_ =
84  ibooker.book1D("dphiAbsoluteResiduals_tracker", "dphiAbsoluteResiduals_tracker", dphiBin, dphiMin, dphiMax);
85  dthetaAbsoluteResiduals_tracker_ = ibooker.book1D(
86  "dthetaAbsoluteResiduals_tracker", "dthetaAbsoluteResiduals_tracker", dthetaBin, dthetaMin, dthetaMax);
87  dptAbsoluteResiduals_tracker_ =
88  ibooker.book1D("dptAbsoluteResiduals_tracker", "dptAbsoluteResiduals_tracker", dptBin, dptMin, dptMax);
89  dcurvAbsoluteResiduals_tracker_ =
90  ibooker.book1D("dcurvAbsoluteResiduals_tracker", "dcurvAbsoluteResiduals_tracker", dcurvBin, dcurvMin, dcurvMax);
91 
92  ddxyNormalizedResiduals_tracker_ =
93  ibooker.book1D("ddxyNormalizedResiduals_tracker", "ddxyNormalizedResiduals_tracker", normBin, normMin, normMax);
94  ddzNormalizedResiduals_tracker_ =
95  ibooker.book1D("ddzNormalizedResiduals_tracker", "ddzNormalizedResiduals_tracker", normBin, normMin, normMax);
96  dphiNormalizedResiduals_tracker_ =
97  ibooker.book1D("dphiNormalizedResiduals_tracker", "dphiNormalizedResiduals_tracker", normBin, normMin, normMax);
98  dthetaNormalizedResiduals_tracker_ = ibooker.book1D(
99  "dthetaNormalizedResiduals_tracker", "dthetaNormalizedResiduals_tracker", normBin, normMin, normMax);
100  dptNormalizedResiduals_tracker_ =
101  ibooker.book1D("dptNormalizedResiduals_tracker", "dptNormalizedResiduals_tracker", normBin, normMin, normMax);
102  dcurvNormalizedResiduals_tracker_ =
103  ibooker.book1D("dcurvNormalizedResiduals_tracker", "dcurvNormalizedResiduals_tracker", normBin, normMin, normMax);
104 
105  if (plotMuons_) {
106  ddxyAbsoluteResiduals_global_ =
107  ibooker.book1D("ddxyAbsoluteResiduals_global", "ddxyAbsoluteResiduals_global", ddxyBin, ddxyMin, ddxyMax);
108  ddzAbsoluteResiduals_global_ =
109  ibooker.book1D("ddzAbsoluteResiduals_global", "ddzAbsoluteResiduals_global", ddzBin, ddzMin, ddzMax);
110  dphiAbsoluteResiduals_global_ =
111  ibooker.book1D("dphiAbsoluteResiduals_global", "dphiAbsoluteResiduals_global", dphiBin, dphiMin, dphiMax);
112  dthetaAbsoluteResiduals_global_ = ibooker.book1D(
113  "dthetaAbsoluteResiduals_global", "dthetaAbsoluteResiduals_global", dthetaBin, dthetaMin, dthetaMax);
114  dptAbsoluteResiduals_global_ =
115  ibooker.book1D("dptAbsoluteResiduals_global", "dptAbsoluteResiduals_global", dptBin, dptMin, dptMax);
116  dcurvAbsoluteResiduals_global_ =
117  ibooker.book1D("dcurvAbsoluteResiduals_global", "dcurvAbsoluteResiduals_global", dcurvBin, dcurvMin, dcurvMax);
118 
119  ddxyNormalizedResiduals_global_ =
120  ibooker.book1D("ddxyNormalizedResiduals_global", "ddxyNormalizedResiduals_global", normBin, normMin, normMax);
121  ddzNormalizedResiduals_global_ =
122  ibooker.book1D("ddzNormalizedResiduals_global", "ddzNormalizedResiduals_global", normBin, normMin, normMax);
123  dphiNormalizedResiduals_global_ =
124  ibooker.book1D("dphiNormalizedResiduals_global", "dphiNormalizedResiduals_global", normBin, normMin, normMax);
125  dthetaNormalizedResiduals_global_ = ibooker.book1D(
126  "dthetaNormalizedResiduals_global", "dthetaNormalizedResiduals_global", normBin, normMin, normMax);
127  dptNormalizedResiduals_global_ =
128  ibooker.book1D("dptNormalizedResiduals_global", "dptNormalizedResiduals_global", normBin, normMin, normMax);
129  dcurvNormalizedResiduals_global_ =
130  ibooker.book1D("dcurvNormalizedResiduals_global", "dcurvNormalizedResiduals_global", normBin, normMin, normMax);
131  }
132 
133  ddxyAbsoluteResiduals_tracker_->setAxisTitle("(#delta d_{xy})/#sqrt{2} [#mum]");
134  ddzAbsoluteResiduals_tracker_->setAxisTitle("(#delta d_{z})/#sqrt{2} [#mum]");
135  dphiAbsoluteResiduals_tracker_->setAxisTitle("(#delta #phi)/#sqrt{2} [mrad]");
136  dthetaAbsoluteResiduals_tracker_->setAxisTitle("(#delta #theta)/#sqrt{2} [mrad]");
137  dptAbsoluteResiduals_tracker_->setAxisTitle("(#delta p_{T})/#sqrt{2} [GeV]");
138  dcurvAbsoluteResiduals_tracker_->setAxisTitle("(#delta (1/p_{T}))/#sqrt{2} [GeV^{-1}]");
139 
140  ddxyNormalizedResiduals_tracker_->setAxisTitle("#delta d_{xy}/#sigma(d_{xy})");
141  ddzNormalizedResiduals_tracker_->setAxisTitle("#delta d_{z}/#sigma(d_{z})");
142  dphiNormalizedResiduals_tracker_->setAxisTitle("#delta #phi/#sigma(d_{#phi})");
143  dthetaNormalizedResiduals_tracker_->setAxisTitle("#delta #theta/#sigma(d_{#theta})");
144  dptNormalizedResiduals_tracker_->setAxisTitle("#delta p_{T}/#sigma(p_{T})");
145  dcurvNormalizedResiduals_tracker_->setAxisTitle("#delta 1/p_{T}/#sigma(1/p_{T})");
146 
147  if (plotMuons_) {
148  ddxyAbsoluteResiduals_global_->setAxisTitle("(#delta d_{xy})/#sqrt{2} [#mum]");
149  ddzAbsoluteResiduals_global_->setAxisTitle("(#delta d_{z})/#sqrt{2} [#mum]");
150  dphiAbsoluteResiduals_global_->setAxisTitle("(#delta #phi)/#sqrt{2} [mrad]");
151  dthetaAbsoluteResiduals_global_->setAxisTitle("(#delta #theta)/#sqrt{2} [mrad]");
152  dptAbsoluteResiduals_global_->setAxisTitle("(#delta p_{T})/#sqrt{2} [GeV]");
153  dcurvAbsoluteResiduals_global_->setAxisTitle("(#delta (1/p_{T}))/#sqrt{2} [GeV^{-1}]");
154 
155  ddxyNormalizedResiduals_global_->setAxisTitle("#delta d_{xy}/#sigma(d_{xy})");
156  ddzNormalizedResiduals_global_->setAxisTitle("#delta d_{z}/#sigma(d_{z})");
157  dphiNormalizedResiduals_global_->setAxisTitle("#delta #phi/#sigma(d_{#phi})");
158  dthetaNormalizedResiduals_global_->setAxisTitle("#delta #theta/#sigma(d_{#theta})");
159  dptNormalizedResiduals_global_->setAxisTitle("#delta p_{T}/#sigma(p_{T})");
160  dcurvNormalizedResiduals_global_->setAxisTitle("#delta 1/p_{T}/#sigma(1/p_{T})");
161  }
162 }
163 
164 //
165 // -- Analyse
166 //
167 void TrackSplittingMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
168  theMagField = &iSetup.getData(mfToken_);
169  theGeometry = &iSetup.getData(tkGeomToken_);
170  dtGeometry = &iSetup.getData(dtGeomToken_);
171  cscGeometry = &iSetup.getData(cscGeomToken_);
172  rpcGeometry = &iSetup.getData(rpcGeomToken_);
173 
174  edm::Handle<std::vector<reco::Track> > splitTracks = iEvent.getHandle(splitTracksToken_);
175  if (!splitTracks.isValid())
176  return;
177 
178  edm::Handle<std::vector<reco::Muon> > splitMuons;
179  if (plotMuons_) {
180  splitMuons = iEvent.getHandle(splitMuonsToken_);
181  }
182 
183  if (splitTracks->size() == 2) {
184  // check that there are 2 tracks in split track collection
185  edm::LogInfo("TrackSplittingMonitor") << "Split Track size: " << splitTracks->size();
186 
187  // split tracks calculations
188  reco::Track track1 = splitTracks->at(0);
189  reco::Track track2 = splitTracks->at(1);
190 
191  // -------------------------- basic selection ---------------------------
192 
193  // hit counting
194  // looping through the hits for track 1
195  double nRechits1 = 0;
196  double nRechitinBPIX1 = 0;
197  for (auto const& iHit : track1.recHits()) {
198  if (iHit->isValid()) {
199  nRechits1++;
200  int type = iHit->geographicalId().subdetId();
201  if (type == int(PixelSubdetector::PixelBarrel)) {
202  ++nRechitinBPIX1;
203  }
204  }
205  }
206  // looping through the hits for track 2
207  double nRechits2 = 0;
208  double nRechitinBPIX2 = 0;
209  for (auto const& iHit : track2.recHits()) {
210  if (iHit->isValid()) {
211  nRechits2++;
212  int type = iHit->geographicalId().subdetId();
213  if (type == int(PixelSubdetector::PixelBarrel)) {
214  ++nRechitinBPIX2;
215  }
216  }
217  }
218 
219  // DCA of each track
220  double d01 = track1.d0();
221  double dz1 = track1.dz();
222  double d02 = track2.d0();
223  double dz2 = track2.dz();
224 
225  // pT of each track
226  double pt1 = track1.pt();
227  double pt2 = track2.pt();
228 
229  // chi2 of each track
230  double norchi1 = track1.normalizedChi2();
231  double norchi2 = track2.normalizedChi2();
232 
233  // basic selection
234  // pixel hits and total hits
235  if ((nRechitinBPIX1 >= pixelHitsPerLeg_) && (nRechitinBPIX2 >= pixelHitsPerLeg_) &&
236  (nRechits1 >= totalHitsPerLeg_) && (nRechits2 >= totalHitsPerLeg_)) {
237  // dca cut
238  if (((std::abs(d01) < d0Cut_)) && (std::abs(d02) < d0Cut_) && (std::abs(dz1) < dzCut_) &&
239  (std::abs(dz2) < dzCut_)) {
240  // pt cut
241  if ((pt1 + pt2) / 2 < ptCut_) {
242  // chi2 cut
243  if ((norchi1 < norchiCut_) && (norchi2 < norchiCut_)) {
244  // passed all cuts...
245  edm::LogInfo("TrackSplittingMonitor") << " Setected after all cuts ?";
246 
247  double ddxyVal = d01 - d02;
248  double ddzVal = dz1 - dz2;
249  double dphiVal = track1.phi() - track2.phi();
250  double dthetaVal = track1.theta() - track2.theta();
251  double dptVal = pt1 - pt2;
252  double dcurvVal = (1 / pt1) - (1 / pt2);
253 
254  double d01ErrVal = track1.d0Error();
255  double d02ErrVal = track2.d0Error();
256  double dz1ErrVal = track1.dzError();
257  double dz2ErrVal = track2.dzError();
258  double phi1ErrVal = track1.phiError();
259  double phi2ErrVal = track2.phiError();
260  double theta1ErrVal = track1.thetaError();
261  double theta2ErrVal = track2.thetaError();
262  double pt1ErrVal = track1.ptError();
263  double pt2ErrVal = track2.ptError();
264 
265  ddxyAbsoluteResiduals_tracker_->Fill(cmToUm * ddxyVal / sqrt2);
266  ddzAbsoluteResiduals_tracker_->Fill(cmToUm * ddzVal / sqrt2);
267  dphiAbsoluteResiduals_tracker_->Fill(radToUrad * dphiVal / sqrt2);
268  dthetaAbsoluteResiduals_tracker_->Fill(radToUrad * dthetaVal / sqrt2);
269  dptAbsoluteResiduals_tracker_->Fill(dptVal / sqrt2);
270  dcurvAbsoluteResiduals_tracker_->Fill(dcurvVal / sqrt2);
271 
272  ddxyNormalizedResiduals_tracker_->Fill(ddxyVal / sqrt(d01ErrVal * d01ErrVal + d02ErrVal * d02ErrVal));
273  ddzNormalizedResiduals_tracker_->Fill(ddzVal / sqrt(dz1ErrVal * dz1ErrVal + dz2ErrVal * dz2ErrVal));
274  dphiNormalizedResiduals_tracker_->Fill(dphiVal / sqrt(phi1ErrVal * phi1ErrVal + phi2ErrVal * phi2ErrVal));
275  dthetaNormalizedResiduals_tracker_->Fill(dthetaVal /
276  sqrt(theta1ErrVal * theta1ErrVal + theta2ErrVal * theta2ErrVal));
277  dptNormalizedResiduals_tracker_->Fill(dptVal / sqrt(pt1ErrVal * pt1ErrVal + pt2ErrVal * pt2ErrVal));
278  dcurvNormalizedResiduals_tracker_->Fill(
279  dcurvVal / sqrt(pow(pt1ErrVal, 2) / pow(pt1, 4) + pow(pt2ErrVal, 2) / pow(pt2, 4)));
280 
281  // if do the same for split muons
282  if (plotMuons_ && splitMuons.isValid()) {
283  int gmCtr = 0;
284  bool topGlobalMuonFlag = false;
285  bool bottomGlobalMuonFlag = false;
286  int topGlobalMuon = -1;
287  int bottomGlobalMuon = -1;
288  double topGlobalMuonNorchi2 = 1e10;
289  double bottomGlobalMuonNorchi2 = 1e10;
290 
291  // check if usable split global muons
292  for (std::vector<reco::Muon>::const_iterator gmI = splitMuons->begin(); gmI != splitMuons->end(); gmI++) {
293  if (gmI->isTrackerMuon() && gmI->isStandAloneMuon() && gmI->isGlobalMuon()) {
294  reco::TrackRef trackerTrackRef1(splitTracks, 0);
295  reco::TrackRef trackerTrackRef2(splitTracks, 1);
296 
297  if (gmI->innerTrack() == trackerTrackRef1) {
298  if (gmI->globalTrack()->normalizedChi2() < topGlobalMuonNorchi2) {
299  topGlobalMuonFlag = true;
300  topGlobalMuonNorchi2 = gmI->globalTrack()->normalizedChi2();
301  topGlobalMuon = gmCtr;
302  }
303  }
304  if (gmI->innerTrack() == trackerTrackRef2) {
305  if (gmI->globalTrack()->normalizedChi2() < bottomGlobalMuonNorchi2) {
306  bottomGlobalMuonFlag = true;
307  bottomGlobalMuonNorchi2 = gmI->globalTrack()->normalizedChi2();
308  bottomGlobalMuon = gmCtr;
309  }
310  }
311  }
312  gmCtr++;
313  }
314 
315  if (bottomGlobalMuonFlag && topGlobalMuonFlag) {
316  reco::Muon muonTop = splitMuons->at(topGlobalMuon);
317  reco::Muon muonBottom = splitMuons->at(bottomGlobalMuon);
318 
319  reco::TrackRef glb1 = muonTop.globalTrack();
320  reco::TrackRef glb2 = muonBottom.globalTrack();
321 
322  double ddxyValGlb = glb1->d0() - glb2->d0();
323  double ddzValGlb = glb1->dz() - glb2->dz();
324  double dphiValGlb = glb1->phi() - glb2->phi();
325  double dthetaValGlb = glb1->theta() - glb2->theta();
326  double dptValGlb = glb1->pt() - glb2->pt();
327  double dcurvValGlb = (1 / glb1->pt()) - (1 / glb2->pt());
328 
329  double d01ErrValGlb = glb1->d0Error();
330  double d02ErrValGlb = glb2->d0Error();
331  double dz1ErrValGlb = glb1->dzError();
332  double dz2ErrValGlb = glb2->dzError();
333  double phi1ErrValGlb = glb1->phiError();
334  double phi2ErrValGlb = glb2->phiError();
335  double theta1ErrValGlb = glb1->thetaError();
336  double theta2ErrValGlb = glb2->thetaError();
337  double pt1ErrValGlb = glb1->ptError();
338  double pt2ErrValGlb = glb2->ptError();
339 
340  ddxyAbsoluteResiduals_global_->Fill(cmToUm * ddxyValGlb / sqrt2);
341  ddzAbsoluteResiduals_global_->Fill(cmToUm * ddzValGlb / sqrt2);
342  dphiAbsoluteResiduals_global_->Fill(radToUrad * dphiValGlb / sqrt2);
343  dthetaAbsoluteResiduals_global_->Fill(radToUrad * dthetaValGlb / sqrt2);
344  dptAbsoluteResiduals_global_->Fill(dptValGlb / sqrt2);
345  dcurvAbsoluteResiduals_global_->Fill(dcurvValGlb / sqrt2);
346 
347  ddxyNormalizedResiduals_global_->Fill(ddxyValGlb /
348  sqrt(d01ErrValGlb * d01ErrValGlb + d02ErrValGlb * d02ErrValGlb));
349  ddxyNormalizedResiduals_global_->Fill(ddzValGlb /
350  sqrt(dz1ErrValGlb * dz1ErrValGlb + dz2ErrValGlb * dz2ErrValGlb));
351  ddxyNormalizedResiduals_global_->Fill(
352  dphiValGlb / sqrt(phi1ErrValGlb * phi1ErrValGlb + phi2ErrValGlb * phi2ErrValGlb));
353  ddxyNormalizedResiduals_global_->Fill(
354  dthetaValGlb / sqrt(theta1ErrValGlb * theta1ErrValGlb + theta2ErrValGlb * theta2ErrValGlb));
355  ddxyNormalizedResiduals_global_->Fill(dptValGlb /
356  sqrt(pt1ErrValGlb * pt1ErrValGlb + pt2ErrValGlb * pt2ErrValGlb));
357  ddxyNormalizedResiduals_global_->Fill(
358  dcurvValGlb / sqrt(pow(pt1ErrValGlb, 2) / pow(pt1, 4) + pow(pt2ErrValGlb, 2) / pow(pt2, 4)));
359  }
360 
361  } // end of split muons loop
362  }
363  }
364  }
365  }
366  }
367 }
368 
369 void TrackSplittingMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
370  edm::ParameterSetDescription desc;
371  desc.setComment(
372  "Validates track parameters resolution by splitting cosmics tracks at the PCA and comparing the parameters of "
373  "the two halves");
374  desc.add<std::string>("FolderName", "TrackSplitMonitoring");
375  desc.add<edm::InputTag>("splitTrackCollection", edm::InputTag("splittedTracksP5"));
376  desc.add<edm::InputTag>("splitMuonCollection", edm::InputTag("splitMuons"));
377  desc.add<bool>("ifPlotMuons", true);
378  desc.add<int>("pixelHitsPerLeg", 1);
379  desc.add<int>("totalHitsPerLeg", 6);
380  desc.add<double>("d0Cut", 12.0);
381  desc.add<double>("dzCut", 25.0);
382  desc.add<double>("ptCut", 4.0);
383  desc.add<double>("norchiCut", 100.0);
384  desc.add<int>("ddxyBin", 100);
385  desc.add<double>("ddxyMin", -200.0);
386  desc.add<double>("ddxyMax", 200.0);
387  desc.add<int>("ddzBin", 100);
388  desc.add<double>("ddzMin", -400.0);
389  desc.add<double>("ddzMax", 400.0);
390  desc.add<int>("dphiBin", 100);
391  desc.add<double>("dphiMin", -0.01);
392  desc.add<double>("dphiMax", 0.01);
393  desc.add<int>("dthetaBin", 100);
394  desc.add<double>("dthetaMin", -0.01);
395  desc.add<double>("dthetaMax", 0.01);
396  desc.add<int>("dptBin", 100);
397  desc.add<double>("dptMin", -5.0);
398  desc.add<double>("dptMax", 5.0);
399  desc.add<int>("dcurvBin", 100);
400  desc.add<double>("dcurvMin", -0.005);
401  desc.add<double>("dcurvMax", 0.005);
402  desc.add<int>("normBin", 100);
403  desc.add<double>("normMin", -5.);
404  desc.add<double>("normMax", 5.);
405  descriptions.addWithDefaultLabel(desc);
406 }
407 
408 DEFINE_FWK_MODULE(TrackSplittingMonitor);
TrackSplittingMonitor_cfi.dphiMax
dphiMax
Definition: TrackSplittingMonitor_cfi.py:27
edm::ConfigurationDescriptions::addWithDefaultLabel
void addWithDefaultLabel(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:87
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
deDxTools::esConsumes
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
TrackSplittingMonitor_cfi.ddxyMax
ddxyMax
Definition: TrackSplittingMonitor_cfi.py:21
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:307
TrackSplittingMonitor::dthetaAbsoluteResiduals_global_
MonitorElement * dthetaAbsoluteResiduals_global_
Definition: TrackSplittingMonitor.h:102
TrackSplittingMonitor_cfi.ddzMax
ddzMax
Definition: TrackSplittingMonitor_cfi.py:24
TrackSplittingMonitor::sqrt2
static constexpr double sqrt2
Definition: TrackSplittingMonitor.h:56
edm::EventSetup::getData
T const & getData(const ESGetToken< T, R > &iToken) const noexcept(false)
Definition: EventSetup.h:119
TrackSplittingMonitor::dcurvNormalizedResiduals_global_
MonitorElement * dcurvNormalizedResiduals_global_
Definition: TrackSplittingMonitor.h:111
TrackSplittingMonitor::cscGeometry
const CSCGeometry * cscGeometry
Definition: TrackSplittingMonitor.h:70
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:754
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:36
TrackSplittingMonitor::cmToUm
static constexpr double cmToUm
Definition: TrackSplittingMonitor.h:54
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:51
TrackSplittingMonitor::dthetaAbsoluteResiduals_tracker_
MonitorElement * dthetaAbsoluteResiduals_tracker_
Definition: TrackSplittingMonitor.h:88
TrackSplittingMonitor_cfi.dphiBin
dphiBin
Definition: TrackSplittingMonitor_cfi.py:25
TrackSplittingMonitor_cfi.dthetaMin
dthetaMin
Definition: TrackSplittingMonitor_cfi.py:29
TrackSplittingMonitor::ddzNormalizedResiduals_global_
MonitorElement * ddzNormalizedResiduals_global_
Definition: TrackSplittingMonitor.h:107
TrackSplittingMonitor_cfi.ddzMin
ddzMin
Definition: TrackSplittingMonitor_cfi.py:23
TrackSplittingMonitor_cfi.dthetaBin
dthetaBin
Definition: TrackSplittingMonitor_cfi.py:28
reco::TrackBase::thetaError
double thetaError() const
error on theta
Definition: TrackBase.h:757
TrackSplittingMonitor::ddxyNormalizedResiduals_tracker_
MonitorElement * ddxyNormalizedResiduals_tracker_
Definition: TrackSplittingMonitor.h:92
TrackSplittingMonitor::dcurvAbsoluteResiduals_tracker_
MonitorElement * dcurvAbsoluteResiduals_tracker_
Definition: TrackSplittingMonitor.h:90
TrackSplittingMonitor_cfi.normMax
normMax
Definition: TrackSplittingMonitor_cfi.py:39
TrackSplittingMonitor_cfi.dcurvBin
dcurvBin
Definition: TrackSplittingMonitor_cfi.py:34
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
TrackSplittingMonitor::dtGeometry
const DTGeometry * dtGeometry
Definition: TrackSplittingMonitor.h:69
TrackSplittingMonitor::cscGeomToken_
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord > cscGeomToken_
Definition: TrackSplittingMonitor.h:64
TrackSplittingMonitor::tkGeomToken_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > tkGeomToken_
Definition: TrackSplittingMonitor.h:62
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
TrackSplittingMonitor::ddzAbsoluteResiduals_global_
MonitorElement * ddzAbsoluteResiduals_global_
Definition: TrackSplittingMonitor.h:100
TrackSplittingMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: TrackSplittingMonitor.cc:43
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:292
TrackSplittingMonitor::rpcGeometry
const RPCGeometry * rpcGeometry
Definition: TrackSplittingMonitor.h:71
TrackSplittingMonitor::dphiNormalizedResiduals_global_
MonitorElement * dphiNormalizedResiduals_global_
Definition: TrackSplittingMonitor.h:108
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
reco::Track::recHits
auto recHits() const
Access to reconstructed hits on the track.
Definition: Track.h:85
TrackSplittingMonitor_cfi.dptMin
dptMin
Definition: TrackSplittingMonitor_cfi.py:32
TrackSplittingMonitor_cfi.dcurvMin
dcurvMin
Definition: TrackSplittingMonitor_cfi.py:35
TrackSplittingMonitor::dthetaNormalizedResiduals_tracker_
MonitorElement * dthetaNormalizedResiduals_tracker_
Definition: TrackSplittingMonitor.h:95
TrackSplittingMonitor::splitMuonsToken_
const edm::EDGetTokenT< std::vector< reco::Muon > > splitMuonsToken_
Definition: TrackSplittingMonitor.h:74
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:622
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackSplittingMonitor::mfToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > mfToken_
Definition: TrackSplittingMonitor.h:61
TrackSplittingMonitor::ddxyNormalizedResiduals_global_
MonitorElement * ddxyNormalizedResiduals_global_
Definition: TrackSplittingMonitor.h:106
Muon
Definition: Muon.py:1
TrackSplittingMonitor::dthetaNormalizedResiduals_global_
MonitorElement * dthetaNormalizedResiduals_global_
Definition: TrackSplittingMonitor.h:109
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:778
TrackSplittingMonitor::theMagField
const MagneticField * theMagField
Definition: TrackSplittingMonitor.h:68
TrackSplittingMonitor::dphiNormalizedResiduals_tracker_
MonitorElement * dphiNormalizedResiduals_tracker_
Definition: TrackSplittingMonitor.h:94
TrackSplittingMonitor::theGeometry
const TrackerGeometry * theGeometry
Definition: TrackSplittingMonitor.h:67
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
TrackSplittingMonitor::dcurvAbsoluteResiduals_global_
MonitorElement * dcurvAbsoluteResiduals_global_
Definition: TrackSplittingMonitor.h:104
TrackSplittingMonitor::dphiAbsoluteResiduals_tracker_
MonitorElement * dphiAbsoluteResiduals_tracker_
Definition: TrackSplittingMonitor.h:87
TrackSplittingMonitor_cfi.dptBin
dptBin
Definition: TrackSplittingMonitor_cfi.py:31
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TrackSplittingMonitor_cfi.normMin
normMin
Definition: TrackSplittingMonitor_cfi.py:38
HLT_2023v12_cff.pt1
pt1
Definition: HLT_2023v12_cff.py:16743
TrackSplittingMonitor_cfi.ddxyMin
ddxyMin
Definition: TrackSplittingMonitor_cfi.py:20
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:649
TrackSplittingMonitor::ddzNormalizedResiduals_tracker_
MonitorElement * ddzNormalizedResiduals_tracker_
Definition: TrackSplittingMonitor.h:93
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
TrackSplittingMonitor::dptAbsoluteResiduals_global_
MonitorElement * dptAbsoluteResiduals_global_
Definition: TrackSplittingMonitor.h:103
TrackSplittingMonitor::dtGeomToken_
const edm::ESGetToken< DTGeometry, MuonGeometryRecord > dtGeomToken_
Definition: TrackSplittingMonitor.h:63
TrackSplittingMonitor::dptAbsoluteResiduals_tracker_
MonitorElement * dptAbsoluteResiduals_tracker_
Definition: TrackSplittingMonitor.h:89
TrackSplittingMonitor::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: TrackSplittingMonitor.cc:369
TrackSplittingMonitor_cfi.normBin
normBin
Definition: TrackSplittingMonitor_cfi.py:37
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:131
TrackSplittingMonitor_cfi.dptMax
dptMax
Definition: TrackSplittingMonitor_cfi.py:33
RecoMuonCosmics_cff.splitMuons
splitMuons
Definition: RecoMuonCosmics_cff.py:285
reco::TrackBase::d0
double d0() const
dxy parameter in perigee convention (d0 = -dxy)
Definition: TrackBase.h:611
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:593
TrackSplittingMonitor::TrackSplittingMonitor
TrackSplittingMonitor(const edm::ParameterSet &)
Definition: TrackSplittingMonitor.cc:26
TrackSplittingMonitor::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: TrackSplittingMonitor.cc:167
nano_mu_local_reco_cff.bool
bool
Definition: nano_mu_local_reco_cff.py:13
HLT_2023v12_cff.pt2
pt2
Definition: HLT_2023v12_cff.py:16745
TrackSplittingMonitor_cfi.dthetaMax
dthetaMax
Definition: TrackSplittingMonitor_cfi.py:30
TrackSplittingMonitor::ddzAbsoluteResiduals_tracker_
MonitorElement * ddzAbsoluteResiduals_tracker_
Definition: TrackSplittingMonitor.h:86
MTS_cfg.splitTracks
splitTracks
Definition: MTS_cfg.py:184
TrackSplittingMonitor::radToUrad
static constexpr double radToUrad
Definition: TrackSplittingMonitor.h:55
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:602
TrackSplittingMonitor::splitTracksToken_
const edm::EDGetTokenT< std::vector< reco::Track > > splitTracksToken_
Definition: TrackSplittingMonitor.h:73
TrackSplittingMonitor::ddxyAbsoluteResiduals_global_
MonitorElement * ddxyAbsoluteResiduals_global_
Definition: TrackSplittingMonitor.h:99
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:46
edm
HLT enums.
Definition: AlignableModifier.h:19
TrackSplittingMonitor::dcurvNormalizedResiduals_tracker_
MonitorElement * dcurvNormalizedResiduals_tracker_
Definition: TrackSplittingMonitor.h:97
TrackSplittingMonitor::dphiAbsoluteResiduals_global_
MonitorElement * dphiAbsoluteResiduals_global_
Definition: TrackSplittingMonitor.h:101
TrackSplittingMonitor::dptNormalizedResiduals_tracker_
MonitorElement * dptNormalizedResiduals_tracker_
Definition: TrackSplittingMonitor.h:96
TrackSplittingMonitor::dptNormalizedResiduals_global_
MonitorElement * dptNormalizedResiduals_global_
Definition: TrackSplittingMonitor.h:110
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
TrackSplittingMonitor_cfi.dphiMin
dphiMin
Definition: TrackSplittingMonitor_cfi.py:26
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:772
reco::TrackBase::phiError
double phiError() const
error on phi
Definition: TrackBase.h:766
TrackSplittingMonitor::ddxyAbsoluteResiduals_tracker_
MonitorElement * ddxyAbsoluteResiduals_tracker_
Definition: TrackSplittingMonitor.h:85
TrackSplittingMonitor_cfi.ddzBin
ddzBin
Definition: TrackSplittingMonitor_cfi.py:22
TrackSplittingMonitor_cfi.dcurvMax
dcurvMax
Definition: TrackSplittingMonitor_cfi.py:36
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
edm::Run
Definition: Run.h:45
TrackSplittingMonitor_cfi.ddxyBin
ddxyBin
Definition: TrackSplittingMonitor_cfi.py:19
TrackSplittingMonitor::rpcGeomToken_
const edm::ESGetToken< RPCGeometry, MuonGeometryRecord > rpcGeomToken_
Definition: TrackSplittingMonitor.h:65
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:801
Generated for CMSSW Reference Manual by doxygen 1.8.14