CMS 3D CMS Logo
TrackCutClassifier.cc
Go to the documentation of this file.
1 #include "RecoTracker/FinalTrackSelectors/interface/TrackMVAClassifier.h"
2 
3 #include "DataFormats/TrackReco/interface/Track.h"
4 
5 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h"
6 
7 #include <cassert>
8 
9 #include "getBestVertex.h"
10 #include "powN.h"
11 
12 namespace {
13 
14  void fillArrayF(float* x, const edm::ParameterSet& cfg, const char* name) {
15  auto v = cfg.getParameter<std::vector<double>>(name);
16  assert(v.size() == 3);
17  std::copy(std::begin(v), std::end(v), x);
18  }
19 
20  void fillArrayI(int* x, const edm::ParameterSet& cfg, const char* name) {
21  auto v = cfg.getParameter<std::vector<int>>(name);
22  assert(v.size() == 3);
23  std::copy(std::begin(v), std::end(v), x);
24  }
25 
26  // fake mva value to return for loose,tight,hp
27  constexpr float mvaVal[3] = {-.5, .5, 1.};
28 
29  template <typename T, typename Comp>
30  inline float cut(T val, const T* cuts, Comp comp) {
31  for (int i = 2; i >= 0; --i) {
32  if (comp(val, cuts[i]))
33  return mvaVal[i];
34  }
35  return -1.f;
36  }
37 
38  inline float chi2n(reco::Track const& tk) { return tk.normalizedChi2(); }
39 
40  inline float relPtErr(reco::Track const& tk) {
41  return (tk.pt() != 0. ? float(tk.ptError()) / float(tk.pt()) : 9999999.);
42  }
43 
44  inline int lostLayers(reco::Track const& tk) {
45  return tk.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS);
46  }
47 
48  inline int n3DLayers(reco::Track const& tk, bool isHLT) {
49  uint32_t nlayers3D = tk.hitPattern().pixelLayersWithMeasurement();
50  if (!isHLT)
51  nlayers3D += tk.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
52  else {
53  size_t count3D = 0;
54  for (auto it = tk.recHitsBegin(), et = tk.recHitsEnd(); it != et; ++it) {
55  const TrackingRecHit* hit = (*it);
56  if (!trackerHitRTTI::isFromDetOrFast(*hit))
57  continue;
58 
59  if (hit->dimension() == 2) {
60  auto const& thit = static_cast<BaseTrackerRecHit const&>(*hit);
61  if (thit.isMatched())
62  count3D++;
63  }
64  }
65  nlayers3D += count3D;
66  }
67  return nlayers3D;
68  }
69 
70  inline int nHits(reco::Track const& tk) { return tk.numberOfValidHits(); }
71 
72  inline int nPixelHits(reco::Track const& tk) { return tk.hitPattern().numberOfValidPixelHits(); }
73 
74  inline float dz(reco::Track const& trk, Point const& bestVertex) { return std::abs(trk.dz(bestVertex)); }
75  inline float dr(reco::Track const& trk, Point const& bestVertex) { return std::abs(trk.dxy(bestVertex)); }
76 
77  inline void dzCut_par1(reco::Track const& trk, int& nLayers, const float* par, const int* exp, float dzCut[]) {
78  float dzE = trk.dzError();
79  for (int i = 2; i >= 0; --i) {
80  dzCut[i] = powN(par[i] * nLayers, exp[i]) * dzE;
81  }
82  }
83  inline void drCut_par1(reco::Track const& trk, int& nLayers, const float* par, const int* exp, float drCut[]) {
84  float drE = trk.d0Error();
85  for (int i = 2; i >= 0; --i) {
86  drCut[i] = powN(par[i] * nLayers, exp[i]) * drE;
87  }
88  }
89 
90  inline void dzCut_par2(reco::Track const& trk,
91  int& nLayers,
92  const float* par,
93  const int* exp,
94  const float* d0err,
95  const float* d0err_par,
96  float dzCut[]) {
97  float pt = float(trk.pt());
98  float p = float(trk.p());
99 
100  for (int i = 2; i >= 0; --i) {
101  // parametrized d0 resolution for the track pt
102  float nomd0E = sqrt(d0err[i] * d0err[i] + (d0err_par[i] / pt) * (d0err_par[i] / pt));
103  // parametrized z0 resolution for the track pt and eta
104  float nomdzE = nomd0E * (p / pt); // cosh(eta):=abs(p)/pt
105 
106  dzCut[i] = powN(par[i] * nLayers, exp[i]) * nomdzE;
107  }
108  }
109  inline void drCut_par2(reco::Track const& trk,
110  int& nLayers,
111  const float* par,
112  const int* exp,
113  const float* d0err,
114  const float* d0err_par,
115  float drCut[]) {
116  float pt = trk.pt();
117 
118  for (int i = 2; i >= 0; --i) {
119  // parametrized d0 resolution for the track pt
120  float nomd0E = sqrt(d0err[i] * d0err[i] + (d0err_par[i] / pt) * (d0err_par[i] / pt));
121 
122  drCut[i] = powN(par[i] * nLayers, exp[i]) * nomd0E;
123  }
124  }
125 
126  inline void dzCut_wPVerror_par(reco::Track const& trk,
127  int& nLayers,
128  const float* par,
129  const int* exp,
130  Point const& bestVertexError,
131  float dzCut[]) {
132  float dzE = trk.dzError();
133  float zPVerr = bestVertexError.z();
134 
135  float dzErrPV = std::sqrt(dzE * dzE + zPVerr * zPVerr);
136  for (int i = 2; i >= 0; --i) {
137  dzCut[i] = par[i] * dzErrPV;
138  if (exp[i] != 0)
139  dzCut[i] *= pow(nLayers, exp[i]);
140  }
141  }
142 
143  inline void drCut_wPVerror_par(reco::Track const& trk,
144  int& nLayers,
145  const float* par,
146  const int* exp,
147  Point const& bestVertexError,
148  float drCut[]) {
149  float drE = trk.d0Error();
150  // shouldn't it be bestVertex.xError()*bestVertex.xError()+bestVertex.yError()*bestVertex.yError() ?!?!?
151  float rPVerr = sqrt(bestVertexError.x() * bestVertexError.y());
152 
153  float drErrPV = std::sqrt(drE * drE + rPVerr * rPVerr);
154  for (int i = 2; i >= 0; --i) {
155  drCut[i] = par[i] * drErrPV;
156  if (exp[i] != 0)
157  drCut[i] *= pow(nLayers, exp[i]);
158  }
159  }
160 
161  struct Cuts {
162  Cuts(const edm::ParameterSet& cfg) {
163  isHLT = cfg.getParameter<bool>("isHLT");
164  fillArrayF(minNdof, cfg, "minNdof");
165  fillArrayF(maxChi2, cfg, "maxChi2");
166  fillArrayF(maxChi2n, cfg, "maxChi2n");
167  fillArrayI(minHits4pass, cfg, "minHits4pass");
168  fillArrayI(minHits, cfg, "minHits");
169  fillArrayI(minPixelHits, cfg, "minPixelHits");
170  fillArrayI(min3DLayers, cfg, "min3DLayers");
171  fillArrayI(minLayers, cfg, "minLayers");
172  fillArrayI(maxLostLayers, cfg, "maxLostLayers");
173  fillArrayF(maxRelPtErr, cfg, "maxRelPtErr");
174  minNVtxTrk = cfg.getParameter<int>("minNVtxTrk");
175  fillArrayF(maxDz, cfg, "maxDz");
176  fillArrayF(maxDzWrtBS, cfg, "maxDzWrtBS");
177  fillArrayF(maxDr, cfg, "maxDr");
178  edm::ParameterSet dz_par = cfg.getParameter<edm::ParameterSet>("dz_par");
179  fillArrayI(dz_exp, dz_par, "dz_exp");
180  fillArrayF(dz_par1, dz_par, "dz_par1");
181  fillArrayF(dz_par2, dz_par, "dz_par2");
182  fillArrayF(dzWPVerr_par, dz_par, "dzWPVerr_par");
183  edm::ParameterSet dr_par = cfg.getParameter<edm::ParameterSet>("dr_par");
184  fillArrayI(dr_exp, dr_par, "dr_exp");
185  fillArrayF(dr_par1, dr_par, "dr_par1");
186  fillArrayF(dr_par2, dr_par, "dr_par2");
187  fillArrayF(d0err, dr_par, "d0err");
188  fillArrayF(d0err_par, dr_par, "d0err_par");
189  fillArrayF(drWPVerr_par, dr_par, "drWPVerr_par");
190  }
191 
192  void beginStream() {}
193  void initEvent(const edm::EventSetup&) {}
194 
195  float operator()(reco::Track const& trk,
196  reco::BeamSpot const& beamSpot,
197  reco::VertexCollection const& vertices) const {
198  float ret = 1.f;
199  // minimum number of hits for by-passing the other checks
200  if (minHits4pass[0] < std::numeric_limits<int>::max()) {
201  ret = std::min(ret, cut(nHits(trk), minHits4pass, std::greater_equal<int>()));
202  if (ret == 1.f)
203  return ret;
204  }
205 
206  if (maxRelPtErr[2] < std::numeric_limits<float>::max()) {
207  ret = std::min(ret, cut(relPtErr(trk), maxRelPtErr, std::less_equal<float>()));
208  if (ret == -1.f)
209  return ret;
210  }
211 
212  ret = std::min(ret, cut(float(trk.ndof()), minNdof, std::greater_equal<float>()));
213  if (ret == -1.f)
214  return ret;
215 
216  auto nLayers = trk.hitPattern().trackerLayersWithMeasurement();
217  ret = std::min(ret, cut(nLayers, minLayers, std::greater_equal<int>()));
218  if (ret == -1.f)
219  return ret;
220 
221  ret = std::min(ret, cut(chi2n(trk) / float(nLayers), maxChi2n, std::less_equal<float>()));
222  if (ret == -1.f)
223  return ret;
224 
225  ret = std::min(ret, cut(chi2n(trk), maxChi2, std::less_equal<float>()));
226  if (ret == -1.f)
227  return ret;
228 
229  ret = std::min(ret, cut(n3DLayers(trk, isHLT), min3DLayers, std::greater_equal<int>()));
230  if (ret == -1.f)
231  return ret;
232 
233  ret = std::min(ret, cut(nHits(trk), minHits, std::greater_equal<int>()));
234  if (ret == -1.f)
235  return ret;
236 
237  ret = std::min(ret, cut(nPixelHits(trk), minPixelHits, std::greater_equal<int>()));
238  if (ret == -1.f)
239  return ret;
240 
241  ret = std::min(ret, cut(lostLayers(trk), maxLostLayers, std::less_equal<int>()));
242  if (ret == -1.f)
243  return ret;
244 
245  // original dz and dr cut
246  if (maxDz[2] < std::numeric_limits<float>::max() || maxDr[2] < std::numeric_limits<float>::max()) {
247  // if not primaryVertices are reconstructed, check compatibility w.r.t. beam spot
248  // min number of tracks [2 (=default) for offline, 3 for HLT]
249  Point bestVertex = getBestVertex(trk, vertices, minNVtxTrk);
250  float maxDzcut[3];
251  std::copy(std::begin(maxDz), std::end(maxDz), std::begin(maxDzcut));
252  if (bestVertex.z() < -99998.) {
253  bestVertex = beamSpot.position();
254  std::copy(std::begin(maxDzWrtBS), std::end(maxDzWrtBS), std::begin(maxDzcut));
255  }
256  ret = std::min(ret, cut(dr(trk, bestVertex), maxDr, std::less<float>()));
257  if (ret == -1.f)
258  return ret;
259 
260  ret = std::min(ret, cut(dz(trk, bestVertex), maxDzcut, std::less<float>()));
261  if (ret == -1.f)
262  return ret;
263  }
264 
265  // parametrized dz and dr cut by using PV error
266  if (dzWPVerr_par[2] < std::numeric_limits<float>::max() || drWPVerr_par[2] < std::numeric_limits<float>::max()) {
267  Point bestVertexError(-1., -1., -1.);
268  // min number of tracks [2 (=default) for offline, 3 for HLT]
269  Point bestVertex = getBestVertex_withError(trk, vertices, bestVertexError, minNVtxTrk);
270 
271  float maxDz_par[3];
272  float maxDr_par[3];
273  dzCut_wPVerror_par(trk, nLayers, dzWPVerr_par, dz_exp, bestVertexError, maxDz_par);
274  drCut_wPVerror_par(trk, nLayers, drWPVerr_par, dr_exp, bestVertexError, maxDr_par);
275 
276  ret = std::min(ret, cut(dr(trk, bestVertex), maxDr_par, std::less<float>()));
277  if (ret == -1.f)
278  return ret;
279 
280  ret = std::min(ret, cut(dz(trk, bestVertex), maxDr_par, std::less<float>()));
281  if (ret == -1.f)
282  return ret;
283  }
284 
285  // parametrized dz and dr cut by using their error
286  if (dz_par1[2] < std::numeric_limits<float>::max() || dr_par1[2] < std::numeric_limits<float>::max()) {
287  float maxDz_par1[3];
288  float maxDr_par1[3];
289  dzCut_par1(trk, nLayers, dz_par1, dz_exp, maxDz_par1);
290  drCut_par1(trk, nLayers, dr_par1, dr_exp, maxDr_par1);
291 
292  float maxDz_par[3];
293  float maxDr_par[3];
294  std::copy(std::begin(maxDz_par1), std::end(maxDz_par1), std::begin(maxDz_par));
295  std::copy(std::begin(maxDr_par1), std::end(maxDr_par1), std::begin(maxDr_par));
296 
297  // parametrized dz and dr cut by using d0 and z0 resolution
298  if (dz_par2[2] < std::numeric_limits<float>::max() || dr_par2[2] < std::numeric_limits<float>::max()) {
299  float maxDz_par2[3];
300  float maxDr_par2[3];
301  dzCut_par2(trk, nLayers, dz_par2, dz_exp, d0err, d0err_par, maxDz_par2);
302  drCut_par2(trk, nLayers, dr_par2, dr_exp, d0err, d0err_par, maxDr_par2);
303 
304  for (int i = 2; i >= 0; --i) {
305  if (maxDr_par2[i] < maxDr_par[i])
306  maxDr_par[i] = maxDr_par2[i];
307  if (maxDz_par2[i] < maxDz_par[i])
308  maxDz_par[i] = maxDz_par2[i];
309  }
310  }
311 
312  Point bestVertex = getBestVertex(trk, vertices, minNVtxTrk); // min number of tracks 3 @HLT
313  if (bestVertex.z() < -99998.) {
314  bestVertex = beamSpot.position();
315  }
316 
317  ret = std::min(ret, cut(dz(trk, bestVertex), maxDz_par, std::less<float>()));
318  if (ret == -1.f)
319  return ret;
320  ret = std::min(ret, cut(dr(trk, bestVertex), maxDr_par, std::less<float>()));
321  if (ret == -1.f)
322  return ret;
323  }
324  if (ret == -1.f)
325  return ret;
326 
327  return ret;
328  }
329 
330  static const char* name() { return "TrackCutClassifier"; }
331 
332  static void fillDescriptions(edm::ParameterSetDescription& desc) {
333  desc.add<bool>("isHLT", false);
334  desc.add<std::vector<int>>(
335  "minHits4pass",
336  {std::numeric_limits<int>::max(), std::numeric_limits<int>::max(), std::numeric_limits<int>::max()});
337  desc.add<std::vector<int>>("minHits", {0, 0, 1});
338  desc.add<std::vector<int>>("minPixelHits", {0, 0, 1});
339  desc.add<std::vector<int>>("minLayers", {3, 4, 5});
340  desc.add<std::vector<int>>("min3DLayers", {1, 2, 3});
341  desc.add<std::vector<int>>("maxLostLayers", {99, 3, 3});
342  desc.add<std::vector<double>>(
343  "maxRelPtErr",
344  {std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max()});
345  desc.add<std::vector<double>>("minNdof", {-1., -1., -1.});
346  desc.add<std::vector<double>>("maxChi2", {9999., 25., 16.});
347  desc.add<std::vector<double>>("maxChi2n", {9999., 1.0, 0.4});
348 
349  desc.add<int>("minNVtxTrk", 2);
350 
351  desc.add<std::vector<double>>(
352  "maxDz",
353  {std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max()});
354  desc.add<std::vector<double>>("maxDzWrtBS", {std::numeric_limits<float>::max(), 24., 15.});
355  desc.add<std::vector<double>>(
356  "maxDr",
357  {std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max()});
358 
359  edm::ParameterSetDescription dz_par;
360  dz_par.add<std::vector<int>>("dz_exp",
361  {std::numeric_limits<int>::max(),
362  std::numeric_limits<int>::max(),
363  std::numeric_limits<int>::max()}); // par = 4
364  dz_par.add<std::vector<double>>("dz_par1",
365  {std::numeric_limits<float>::max(),
366  std::numeric_limits<float>::max(),
367  std::numeric_limits<float>::max()}); // par = 0.4
368  dz_par.add<std::vector<double>>("dz_par2",
369  {std::numeric_limits<float>::max(),
370  std::numeric_limits<float>::max(),
371  std::numeric_limits<float>::max()}); // par = 0.35
372  dz_par.add<std::vector<double>>("dzWPVerr_par",
373  {std::numeric_limits<float>::max(),
374  std::numeric_limits<float>::max(),
375  std::numeric_limits<float>::max()}); // par = 3.
376  desc.add<edm::ParameterSetDescription>("dz_par", dz_par);
377 
378  edm::ParameterSetDescription dr_par;
379  dr_par.add<std::vector<int>>("dr_exp",
380  {std::numeric_limits<int>::max(),
381  std::numeric_limits<int>::max(),
382  std::numeric_limits<int>::max()}); // par = 4
383  dr_par.add<std::vector<double>>("dr_par1",
384  {std::numeric_limits<float>::max(),
385  std::numeric_limits<float>::max(),
386  std::numeric_limits<float>::max()}); // par = 0.4
387  dr_par.add<std::vector<double>>("dr_par2",
388  {std::numeric_limits<float>::max(),
389  std::numeric_limits<float>::max(),
390  std::numeric_limits<float>::max()}); // par = 0.3
391  dr_par.add<std::vector<double>>("d0err", {0.003, 0.003, 0.003});
392  dr_par.add<std::vector<double>>("d0err_par", {0.001, 0.001, 0.001});
393  dr_par.add<std::vector<double>>("drWPVerr_par",
394  {std::numeric_limits<float>::max(),
395  std::numeric_limits<float>::max(),
396  std::numeric_limits<float>::max()}); // par = 3.
397  desc.add<edm::ParameterSetDescription>("dr_par", dr_par);
398  }
399 
400  bool isHLT;
401  float maxRelPtErr[3];
402  float minNdof[3];
403  float maxChi2[3];
404  float maxChi2n[3];
405  int minLayers[3];
406  int min3DLayers[3];
407  int minHits4pass[3];
408  int minHits[3];
409  int minPixelHits[3];
410  int maxLostLayers[3];
411  int minNVtxTrk;
412  float maxDz[3];
413  float maxDzWrtBS[3];
414  float maxDr[3];
415  int dz_exp[3];
416  float dz_par1[3];
417  float dz_par2[3];
418  float dzWPVerr_par[3];
419  int dr_exp[3];
420  float dr_par1[3];
421  float dr_par2[3];
422  float d0err[3];
423  float d0err_par[3];
424  float drWPVerr_par[3];
425  };
426 
427  using TrackCutClassifier = TrackMVAClassifier<Cuts>;
428 
429 } // namespace
430 
431 #include "FWCore/PluginManager/interface/ModuleDef.h"
432 #include "FWCore/Framework/interface/MakerMacros.h"
433 
434 DEFINE_FWK_MODULE(TrackCutClassifier);
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:367
beam_dqm_sourceclient-live_cfg.dr_exp
dr_exp
Definition: beam_dqm_sourceclient-live_cfg.py:129
beam_dqm_sourceclient-live_cfg.dr_par1
dr_par1
Definition: beam_dqm_sourceclient-live_cfg.py:128
mps_fire.i
i
Definition: mps_fire.py:428
beam_dqm_sourceclient-live_cfg.minLayers
minLayers
Definition: beam_dqm_sourceclient-live_cfg.py:144
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:754
trackerHitRTTI::isFromDetOrFast
bool isFromDetOrFast(TrackingRecHit const &hit)
Definition: trackerHitRTTI.h:38
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
chi2n
Definition: HIMultiTrackSelector.h:45
TkAlMuonSelectors_cfi.cut
cut
Definition: TkAlMuonSelectors_cfi.py:5
reco::HitPattern::trackerLayersWithoutMeasurement
int trackerLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:532
filterCSVwithJSON.copy
copy
Definition: filterCSVwithJSON.py:36
reco::Track::recHitsBegin
trackingRecHit_iterator recHitsBegin() const
Iterator to first hit on the track.
Definition: Track.h:88
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
reco::TrackBase::p
double p() const
momentum vector magnitude
Definition: TrackBase.h:631
min
T min(T a, T b)
Definition: MathUtil.h:58
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
reco_skim_cfg_mod.dz_par2
dz_par2
Definition: reco_skim_cfg_mod.py:183
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
getBestVertex.h
powN.h
cms::cuda::assert
assert(be >=bs)
beam_dqm_sourceclient-live_cfg.maxChi2
maxChi2
Definition: beam_dqm_sourceclient-live_cfg.py:142
beam_dqm_sourceclient-live_cfg.maxDr
maxDr
Definition: beam_dqm_sourceclient-live_cfg.py:143
reco::TrackBase::ndof
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:590
findQualityFiles.v
v
Definition: findQualityFiles.py:179
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:798
AlCaHLTBitMon_QueryRunRegistry.comp
comp
Definition: AlCaHLTBitMon_QueryRunRegistry.py:249
reco::HitPattern::pixelLayersWithMeasurement
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:492
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
TrackMVAClassifier.h
MakerMacros.h
beam_dqm_sourceclient-live_cfg.minNVtxTrk
minNVtxTrk
Definition: beam_dqm_sourceclient-live_cfg.py:139
TrackMVAClassifier
Definition: TrackMVAClassifier.h:95
beam_dqm_sourceclient-live_cfg.maxLostLayers
maxLostLayers
Definition: beam_dqm_sourceclient-live_cfg.py:132
Track.h
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:513
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
reco::Track::recHitsEnd
trackingRecHit_iterator recHitsEnd() const
Iterator to last hit on the track.
Definition: Track.h:91
mps_fire.end
end
Definition: mps_fire.py:242
reco::BeamSpot
Definition: BeamSpot.h:21
TrackSplittingMonitor_cfi.dzCut
dzCut
Definition: TrackSplittingMonitor_cfi.py:20
reco::Track
Definition: Track.h:27
beam_dqm_sourceclient-live_cfg.d0err
d0err
Definition: beam_dqm_sourceclient-live_cfg.py:126
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
beam_dqm_sourceclient-live_cfg.maxDzWrtBS
maxDzWrtBS
Definition: beam_dqm_sourceclient-live_cfg.py:124
beam_dqm_sourceclient-live_cfg.dr_par2
dr_par2
Definition: beam_dqm_sourceclient-live_cfg.py:127
getBestVertex_withError
Point getBestVertex_withError(reco::Track const &trk, reco::VertexCollection const &vertices, Point &error, const size_t minNtracks=2)
Definition: getBestVertex.h:28
beam_dqm_sourceclient-live_cfg.maxDz
maxDz
Definition: beam_dqm_sourceclient-live_cfg.py:140
beam_dqm_sourceclient-live_cfg.minPixelHits
minPixelHits
Definition: beam_dqm_sourceclient-live_cfg.py:123
MuonTCMETValueMapProducer_cff.nLayers
nLayers
Definition: MuonTCMETValueMapProducer_cff.py:38
beam_dqm_sourceclient-live_cfg.min3DLayers
min3DLayers
Definition: beam_dqm_sourceclient-live_cfg.py:133
HLT_FULL_cff.maxChi2n
maxChi2n
Definition: HLT_FULL_cff.py:9684
Point
Structure Point Contains parameters of Gaussian fits to DMRs.
Definition: DMRtrends.cc:57
edm::ParameterSet
Definition: ParameterSet.h:47
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
HLT_FULL_cff.dzWPVerr_par
dzWPVerr_par
Definition: HLT_FULL_cff.py:87912
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:778
ModuleDef.h
beam_dqm_sourceclient-live_cfg.dz_exp
dz_exp
Definition: beam_dqm_sourceclient-live_cfg.py:137
EgHLTOffHistBins_cfi.et
et
Definition: EgHLTOffHistBins_cfi.py:8
edm::EventSetup
Definition: EventSetup.h:57
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
beam_dqm_sourceclient-live_cfg.minNdof
minNdof
Definition: beam_dqm_sourceclient-live_cfg.py:141
reco::HitPattern::TRACK_HITS
Definition: HitPattern.h:155
looper.cfg
cfg
Definition: looper.py:297
beam_dqm_sourceclient-live_cfg.dz_par
dz_par
Definition: beam_dqm_sourceclient-live_cfg.py:134
TrackingRecHit
Definition: TrackingRecHit.h:21
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:504
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
heppy_batch.val
val
Definition: heppy_batch.py:351
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:772
PVValHelper::dz
Definition: PVValidationHelpers.h:50
T
long double T
Definition: Basic3DVectorLD.h:48
flavorHistoryFilter_cfi.dr
dr
Definition: flavorHistoryFilter_cfi.py:37
genVertex_cff.x
x
Definition: genVertex_cff.py:12
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
HLT_FULL_cff.maxRelPtErr
maxRelPtErr
Definition: HLT_FULL_cff.py:114053
reco::HitPattern::numberOfValidPixelHits
int numberOfValidPixelHits() const
Definition: HitPattern.h:800
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
L1TMuonDQMOffline_cfi.cuts
cuts
Definition: L1TMuonDQMOffline_cfi.py:41
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
HLT_FULL_cff.drWPVerr_par
drWPVerr_par
Definition: HLT_FULL_cff.py:87905
SiStripMatchedRecHit2D.h
beam_dqm_sourceclient-live_cfg.d0err_par
d0err_par
Definition: beam_dqm_sourceclient-live_cfg.py:130
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:608
HLT_FULL_cff.isHLT
isHLT
Definition: HLT_FULL_cff.py:14980
reco_skim_cfg_mod.minHits
minHits
Definition: reco_skim_cfg_mod.py:177
beam_dqm_sourceclient-live_cfg.dr_par
dr_par
Definition: beam_dqm_sourceclient-live_cfg.py:125
hit
Definition: SiStripHitEffFromCalibTree.cc:88
reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo
int numberOfValidStripLayersWithMonoAndStereo(uint16_t stripdet, uint16_t layer) const
Definition: HitPattern.cc:348
getBestVertex
Point getBestVertex(reco::Track const &trk, reco::VertexCollection const &vertices, const size_t minNtracks=2)
Definition: getBestVertex.h:8
reco_skim_cfg_mod.dz_par1
dz_par1
Definition: reco_skim_cfg_mod.py:182
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
Generated for CMSSW Reference Manual by doxygen 1.8.16