CMS 3D CMS Logo
trackingPlots.py
Go to the documentation of this file.
1 from __future__ import absolute_import
2 from builtins import range
3 import os
4 import copy
5 import collections
6 
7 import six
8 import ROOT
9 ROOT.gROOT.SetBatch(True)
10 ROOT.PyConfig.IgnoreCommandLineOptions = True
11 
12 from .plotting import Subtract, FakeDuplicate, CutEfficiency, Transform, AggregateBins, ROC, Plot, PlotEmpty, PlotGroup, PlotOnSideGroup, PlotFolder, Plotter
13 from .html import PlotPurpose
14 from . import plotting
15 from . import validation
16 from . import html
17 
18 
23 
24 _maxEff = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 0.8, 1.025, 1.2, 1.5, 2]
25 _maxFake = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 0.8, 1.025]
26 
27 #_minMaxResol = [1e-5, 2e-5, 5e-5, 1e-4, 2e-4, 5e-4, 1e-3, 2e-3, 5e-3, 1e-2, 2e-2, 5e-2, 0.1, 0.2, 0.5, 1]
28 _minMaxResol = [1e-5, 4e-5, 1e-4, 4e-4, 1e-3, 4e-3, 1e-2, 4e-2, 0.1, 0.4, 1]
29 _minMaxN = [5e-1, 5, 5e1, 5e2, 5e3, 5e4, 5e5, 5e6, 5e7, 5e8, 5e9]
30 
31 _minHits = [0, 5, 10]
32 _maxHits = [5, 10, 20, 40, 60, 80]
33 _minLayers = [0, 5, 10]
34 _maxLayers = [5, 10, 25]
35 _maxPixelLayers = 8
36 _min3DLayers = [0, 5, 10]
37 _max3DLayers = [5, 10, 20]
38 _minZ = [-60, -40, -20, -10, -5]
39 _maxZ = [5, 10, 20, 40, 60]
40 _minPU = [0, 10, 20, 50, 100, 150]
41 _maxPU = [20, 50, 65, 80, 100, 150, 200, 250]
42 _minMaxTracks = [0, 200, 500, 1000, 1500, 2000]
43 _minMaxMVA = [-1.025, -0.5, 0, 0.5, 1.025]
44 _maxDRJ = 0.1
45 
46 def _minMaxResidual(ma):
47  return ([-x for x in ma], ma)
48 
49 (_minResidualPhi, _maxResidualPhi) = _minMaxResidual([1e-4, 2e-4]) # rad
50 (_minResidualCotTheta, _maxResidualCotTheta) = _minMaxResidual([1e-4, 2e-4])
51 (_minResidualDxy, _maxResidualDxy) = _minMaxResidual([10, 20, 50, 100]) # um
52 (_minResidualDz, _maxResidualDz) = (_minResidualDxy, _maxResidualDxy)
53 (_minResidualPt, _maxResidualPt) = _minMaxResidual([1, 1.5, 2, 5]) # %
54 
55 
56 _legendDy_1row = 0.46
57 _legendDy_2rows = -0.025
58 _legendDy_2rows_3cols = -0.17
59 _legendDy_4rows = 0.09
60 
61 # Ok, because of the way the "reference release" histograms are
62 # stored, this histogram is not accessible for the summary plots. To
63 # be fixed later with (large) reorganization of how things work.
64 #_trackingNumberOfEventsHistogram = "DQMData/Run 1/Tracking/Run summary/Track/general_trackingParticleRecoAsssociation/tracks"
65 
66 _trackingIterationOrderHistogram = "DQMData/Run 1/Tracking/Run summary/TrackBuilding/num_reco_coll"
67 
68 def _makeEffFakeDupPlots(postfix, quantity, unit="", common={}, effopts={}, fakeopts={}):
69  p = postfix
70  q = quantity
71  xq = q
72  if unit != "":
73  xq += " (" + unit + ")"
74 
75  effargs = dict(xtitle="TP "+xq , ytitle="efficiency vs "+q , ymax=_maxEff)
76  fakeargs = dict(xtitle="track "+xq, ytitle="fake+duplicates rate vs "+q, ymax=_maxFake)
77  effargs.update(common)
78  fakeargs.update(common)
79  effargs.update(effopts)
80  fakeargs.update(fakeopts)
81 
82  return [
83  Plot("effic_vs_"+p, **effargs),
84  Plot(FakeDuplicate("fakeduprate_vs_"+p, assoc="num_assoc(recoToSim)_"+p, dup="num_duplicate_"+p, reco="num_reco_"+p, title="fake+duplicates vs "+q), **fakeargs)
85  ]
86 
87 def _makeFakeDupPileupPlots(postfix, quantity, unit="", xquantity="", xtitle=None, common={}):
88  p = postfix
89  q = quantity
90  if xtitle is None:
91  if xquantity != "":
92  xq = xquantity
93  else:
94  xq = q
95  if unit != "":
96  xq += " (" + unit + ")"
97  xtitle="track "+xq
98 
99  return [
100  Plot("fakerate_vs_"+p , xtitle=xtitle, ytitle="fakerate vs "+q , ymax=_maxFake, **common),
101  Plot("duplicatesRate_"+p, xtitle=xtitle, ytitle="duplicates rate vs "+q, ymax=_maxFake, **common),
102  Plot("pileuprate_"+p , xtitle=xtitle, ytitle="pileup rate vs "+q , ymax=_maxFake, **common),
103  ]
104 
105 def _makeFakeDist(postfix):
106  return Subtract("num_fake_"+postfix, "num_reco_"+postfix, "num_assoc(recoToSim)_"+postfix)
107 
108 def _makeDistPlots(postfix, quantity, common={}):
109  p = postfix
110  q = quantity
111 
112  args = dict(xtitle="track "+q, ylog=True, ymin=_minMaxN, ymax=_minMaxN)
113  args.update(common)
114 
115  return [
116  Plot("num_reco_"+p , ytitle="tracks", **args),
117  Plot("num_assoc(recoToSim)_"+p, ytitle="true tracks", **args),
118  Plot(_makeFakeDist(p), ytitle="fake tracks", **args),
119  Plot("num_duplicate_"+p , ytitle="duplicate tracks", **args),
120  ]
121 
122 def _makeDistSimPlots(postfix, quantity, common={}):
123  p = postfix
124  q = quantity
125 
126  args = dict(xtitle="TP "+q, ylog=True, ymin=_minMaxN, ymax=_minMaxN)
127  args.update(common)
128 
129  return [
130  Plot("num_simul_"+p , ytitle="TrackingParticles", **args),
131  Plot("num_assoc(simToReco)_"+p, ytitle="Reconstructed TPs", **args),
132  ]
133 
134 def _makeMVAPlots(num, hp=False):
135  pfix = "_hp" if hp else ""
136  pfix2 = "Hp" if hp else ""
137 
138  xtitle = "MVA%d output"%num
139  xtitlecut = "Cut on MVA%d output"%num
140  args = dict(xtitle=xtitle, ylog=True, ymin=_minMaxN, ymax=_minMaxN)
141 
142  argsroc = dict(
143  xtitle="Efficiency (excl. trk eff)", ytitle="Fake rate",
144  xmax=_maxEff, ymax=_maxFake,
145  drawStyle="EP",
146  )
147  argsroc2 = dict(
148  ztitle="Cut on MVA%d"%num,
149  xtitleoffset=5, ytitleoffset=6.5, ztitleoffset=4,
150  adjustMarginRight=0.12
151  )
152  argsroc2.update(argsroc)
153  argsroc2["drawStyle"] = "pcolz"
154 
155  argsprofile = dict(ymin=_minMaxMVA, ymax=_minMaxMVA)
156 
157  true_cuteff = CutEfficiency("trueeff_vs_mva%dcut%s"%(num,pfix), "num_assoc(recoToSim)_mva%dcut%s"%(num,pfix))
158  fake_cuteff = CutEfficiency("fakeeff_vs_mva%dcut%s"%(num,pfix), Subtract("num_fake_mva%dcut%s"%(num,pfix), "num_reco_mva%dcut%s"%(num,pfix), "num_assoc(recoToSim)_mva%dcut%s"%(num,pfix)))
159 
160  return [
161  PlotGroup("mva%d%s"%(num,pfix2), [
162  Plot("num_assoc(recoToSim)_mva%d%s"%(num,pfix), ytitle="true tracks", **args),
163  Plot(Subtract("num_fake_mva%d%s"%(num,pfix), "num_reco_mva%d%s"%(num,pfix), "num_assoc(recoToSim)_mva%d%s"%(num,pfix)), ytitle="fake tracks", **args),
164  Plot("effic_vs_mva%dcut%s"%(num,pfix), xtitle=xtitlecut, ytitle="Efficiency (excl. trk eff)", ymax=_maxEff),
165  #
166  Plot("fakerate_vs_mva%dcut%s"%(num,pfix), xtitle=xtitlecut, ytitle="Fake rate", ymax=_maxFake),
167  Plot(ROC("effic_vs_fake_mva%d%s"%(num,pfix), "effic_vs_mva%dcut%s"%(num,pfix), "fakerate_vs_mva%dcut%s"%(num,pfix)), **argsroc),
168  Plot(ROC("effic_vs_fake_mva%d%s"%(num,pfix), "effic_vs_mva%dcut%s"%(num,pfix), "fakerate_vs_mva%dcut%s"%(num,pfix), zaxis=True), **argsroc2),
169  # Same signal efficiency, background efficiency, and ROC definitions as in TMVA
170  Plot(true_cuteff, xtitle=xtitlecut, ytitle="True track selection efficiency", ymax=_maxEff),
171  Plot(fake_cuteff, xtitle=xtitlecut, ytitle="Fake track selection efficiency", ymax=_maxEff),
172  Plot(ROC("true_eff_vs_fake_rej_mva%d%s"%(num,pfix), true_cuteff, Transform("fake_rej_mva%d%s"%(num,pfix), fake_cuteff, lambda x: 1-x)), xtitle="True track selection efficiency", ytitle="Fake track rejection", xmax=_maxEff, ymax=_maxEff),
173  ], ncols=3, legendDy=_legendDy_1row),
174  PlotGroup("mva%d%sPtEta"%(num,pfix2), [
175  Plot("mva_assoc(recoToSim)_mva%d%s_pT"%(num,pfix), xtitle="Track p_{T} (GeV)", ytitle=xtitle+" for true tracks", xlog=True, **argsprofile),
176  Plot("mva_fake_mva%d%s_pT"%(num,pfix), xtitle="Track p_{T} (GeV)", ytitle=xtitle+" for fake tracks", xlog=True, **argsprofile),
177  Plot("mva_assoc(recoToSim)_mva%d%s_eta"%(num,pfix), xtitle="Track #eta", ytitle=xtitle+" for true tracks", **argsprofile),
178  Plot("mva_fake_mva%d%s_eta"%(num,pfix), xtitle="Track #eta", ytitle=xtitle+" for fake tracks", **argsprofile),
179  ], legendDy=_legendDy_2rows)
180  ]
181 
182 _effandfakePtEtaPhi = PlotGroup("effandfakePtEtaPhi", [
183  Plot("efficPt", title="Efficiency vs p_{T}", xtitle="TP p_{T} (GeV)", ytitle="efficiency vs p_{T}", xlog=True, ymax=_maxEff),
184  Plot(FakeDuplicate("fakeduprate_vs_pT", assoc="num_assoc(recoToSim)_pT", dup="num_duplicate_pT", reco="num_reco_pT", title="fake+duplicates vs p_{T}"),
185  xtitle="track p_{T} (GeV)", ytitle="fake+duplicates rate vs p_{T}", ymax=_maxFake, xlog=True),
186  Plot("effic", xtitle="TP #eta", ytitle="efficiency vs #eta", title="", ymax=_maxEff),
187  Plot(FakeDuplicate("fakeduprate_vs_eta", assoc="num_assoc(recoToSim)_eta", dup="num_duplicate_eta", reco="num_reco_eta", title=""),
188  xtitle="track #eta", ytitle="fake+duplicates rate vs #eta", ymax=_maxFake),
189 ] +
190  _makeEffFakeDupPlots("phi", "#phi")
191 )
192 
193 _effandfakeDxyDzBS = PlotGroup("effandfakeDxyDzBS",
194  _makeEffFakeDupPlots("dxy" , "dxy" , "cm") +
195  _makeEffFakeDupPlots("dz" , "dz" , "cm"),
196  legendDy=_legendDy_2rows
197 )
198 _effandfakeDxyDzPV = PlotGroup("effandfakeDxyDzPV",
199  _makeEffFakeDupPlots("dxypv" , "dxy(PV)", "cm") +
200  _makeEffFakeDupPlots("dxypv_zoomed", "dxy(PV)", "cm") +
201  _makeEffFakeDupPlots("dzpv" , "dz(PV)" , "cm") +
202  _makeEffFakeDupPlots("dzpv_zoomed" , "dz(PV)" , "cm"),
203  legendDy=_legendDy_4rows
204 )
205 _effandfakeHitsLayers = PlotGroup("effandfakeHitsLayers",
206  _makeEffFakeDupPlots("hit" , "hits" , common=dict(xmin=_minHits , xmax=_maxHits)) +
207  _makeEffFakeDupPlots("layer" , "layers" , common=dict(xmin=_minLayers , xmax=_maxLayers)) +
208  _makeEffFakeDupPlots("pixellayer", "pixel layers", common=dict( xmax=_maxPixelLayers)) +
209  _makeEffFakeDupPlots("3Dlayer" , "3D layers" , common=dict(xmin=_min3DLayers, xmax=_max3DLayers)),
210  legendDy=_legendDy_4rows
211 )
212 _common = {"ymin": 0, "ymax": _maxEff}
213 _effandfakePos = PlotGroup("effandfakePos",
214  _makeEffFakeDupPlots("vertpos", "vert r", "cm", fakeopts=dict(xtitle="track ref. point r (cm)", ytitle="fake+duplicates vs. r"), common=dict(xlog=True)) +
215  _makeEffFakeDupPlots("zpos" , "vert z", "cm", fakeopts=dict(xtitle="track ref. point z (cm)", ytitle="fake+duplicates vs. z")) +
216  _makeEffFakeDupPlots("simpvz" , "Sim. PV z", "cm", common=dict(xtitle="Sim. PV z (cm)", xmin=_minZ, xmax=_maxZ))
217 )
218 _effandfakeDeltaRPU = PlotGroup("effandfakeDeltaRPU",
219  _makeEffFakeDupPlots("dr" , "#DeltaR", effopts=dict(xtitle="TP min #DeltaR"), fakeopts=dict(xtitle="track min #DeltaR"), common=dict(xlog=True)) +
220  _makeEffFakeDupPlots("drj" , "#DeltaR(track, jet)", effopts=dict(xtitle="#DeltaR(TP, jet)", ytitle="efficiency vs #DeltaR(TP, jet"), fakeopts=dict(xtitle="#DeltaR(track, jet)"), common=dict(xlog=True, xmax=_maxDRJ))+
221  _makeEffFakeDupPlots("pu" , "PU" , common=dict(xtitle="Pileup", xmin=_minPU, xmax=_maxPU)),
222  legendDy=_legendDy_4rows
223 )
224 
225 
226 _algos_common = dict(removeEmptyBins=True, xbinlabelsize=10, xbinlabeloption="d")
227 _duplicateAlgo = PlotOnSideGroup("duplicateAlgo", Plot("duplicates_oriAlgo_vs_oriAlgo", drawStyle="COLZ", adjustMarginLeft=0.1, adjustMarginRight=0.1, **_algos_common))
228 
229 _dupandfakePtEtaPhi = PlotGroup("dupandfakePtEtaPhi", [
230  Plot("fakeratePt", xtitle="track p_{T} (GeV)", ytitle="fakerate vs p_{T}", xlog=True, ymax=_maxFake),
231  Plot("duplicatesRate_Pt", xtitle="track p_{T} (GeV)", ytitle="duplicates rate vs p_{T}", ymax=_maxFake, xlog=True),
232  Plot("pileuprate_Pt", xtitle="track p_{T} (GeV)", ytitle="pileup rate vs p_{T}", ymax=_maxFake, xlog=True),
233  Plot("fakerate", xtitle="track #eta", ytitle="fakerate vs #eta", title="", ymax=_maxFake),
234  Plot("duplicatesRate", xtitle="track #eta", ytitle="duplicates rate vs #eta", title="", ymax=_maxFake),
235  Plot("pileuprate", xtitle="track #eta", ytitle="pileup rate vs #eta", title="", ymax=_maxFake),
236 ] + _makeFakeDupPileupPlots("phi", "#phi"),
237  ncols=3
238 )
239 _dupandfakeDxyDzBS = PlotGroup("dupandfakeDxyDzBS",
240  _makeFakeDupPileupPlots("dxy" , "dxy" , "cm") +
241  _makeFakeDupPileupPlots("dz" , "dz" , "cm"),
242  ncols=3, legendDy=_legendDy_2rows_3cols
243 )
244 _dupandfakeDxyDzPV = PlotGroup("dupandfakeDxyDzPV",
245  _makeFakeDupPileupPlots("dxypv" , "dxy(PV)", "cm") +
246  _makeFakeDupPileupPlots("dxypv_zoomed", "dxy(PV)", "cm") +
247  _makeFakeDupPileupPlots("dzpv" , "dz(PV)" , "cm") +
248  _makeFakeDupPileupPlots("dzpv_zoomed" , "dz(PV)" , "cm"),
249  ncols=3, legendDy=_legendDy_4rows
250 )
251 _dupandfakeHitsLayers = PlotGroup("dupandfakeHitsLayers",
252  _makeFakeDupPileupPlots("hit" , "hits" , common=dict(xmin=_minHits , xmax=_maxHits)) +
253  _makeFakeDupPileupPlots("layer" , "layers" , common=dict(xmin=_minLayers , xmax=_maxLayers)) +
254  _makeFakeDupPileupPlots("pixellayer", "pixel layers", common=dict( xmax=_maxPixelLayers)) +
255  _makeFakeDupPileupPlots("3Dlayer" , "3D layers" , common=dict(xmin=_min3DLayers, xmax=_max3DLayers)),
256  ncols=3, legendDy=_legendDy_4rows
257 )
258 _dupandfakePos = PlotGroup("dupandfakePos",
259  _makeFakeDupPileupPlots("vertpos", "r", "cm", xquantity="ref. point r (cm)", common=dict(xlog=True)) +
260  _makeFakeDupPileupPlots("zpos" , "z", "cm", xquantity="ref. point z (cm)") +
261  _makeFakeDupPileupPlots("simpvz" , "Sim. PV z", xtitle="Sim. PV z (cm)", common=dict(xmin=_minZ, xmax=_maxZ)),
262  ncols=3,
263 )
264 _dupandfakeDeltaRPU = PlotGroup("dupandfakeDeltaRPU",
265  _makeFakeDupPileupPlots("dr" , "#DeltaR", xquantity="min #DeltaR", common=dict(xlog=True)) +
266  _makeFakeDupPileupPlots("drj" , "#DeltaR(track, jet)", xtitle="#DeltaR(track, jet)", common=dict(xlog=True, xmax=_maxDRJ)) +
267  _makeFakeDupPileupPlots("pu" , "PU" , xtitle="Pileup", common=dict(xmin=_minPU, xmax=_maxPU)),
268  ncols=3
269 )
270 _seedingLayerSet_common = dict(removeEmptyBins=True, xbinlabelsize=8, xbinlabeloption="d", adjustMarginRight=0.1)
271 _dupandfakeSeedingPlots = _makeFakeDupPileupPlots("seedingLayerSet", "seeding layers", xtitle="", common=_seedingLayerSet_common)
272 _dupandfakeChi2Seeding = PlotGroup("dupandfakeChi2Seeding",
273  _makeFakeDupPileupPlots("chi2", "#chi^{2}") +
274  _dupandfakeSeedingPlots,
275  ncols=3, legendDy=_legendDy_2rows_3cols
276 )
277 
278 _common = {
279  "ytitle": "Fake+pileup rate",
280  "ymax": _maxFake,
281  "drawStyle": "EP",
282 }
283 _common2 = {}
284 _common2.update(_common)
285 _common2["drawStyle"] = "pcolz"
286 _common2["ztitleoffset"] = 1.5
287 _common2["xtitleoffset"] = 7
288 _common2["ytitleoffset"] = 10
289 _common2["ztitleoffset"] = 6
290 _pvassociation1 = PlotGroup("pvassociation1", [
291  Plot(ROC("effic_vs_fakepileup_dzpvcut", "effic_vs_dzpvcut", FakeDuplicate("fakepileup_vs_dzpvcut", assoc="num_assoc(recoToSim)_dzpvcut", reco="num_reco_dzpvcut", dup="num_pileup_dzpvcut")),
292  xtitle="Efficiency vs. cut on dz(PV)", **_common),
293  Plot(ROC("effic_vs_fakepileup2_dzpvcut", "effic_vs_dzpvcut", FakeDuplicate("fakepileup_vs_dzpvcut", assoc="num_assoc(recoToSim)_dzpvcut", reco="num_reco_dzpvcut", dup="num_pileup_dzpvcut"), zaxis=True),
294  xtitle="Efficiency", ztitle="Cut on dz(PV)", **_common2),
295  #
296  Plot(ROC("effic_vs_fakepileup_dzpvsigcut", "effic_vs_dzpvsigcut", FakeDuplicate("fakepileup_vs_dzpvsigcut", assoc="num_assoc(recoToSim)_dzpvsigcut", reco="num_reco_dzpvsigcut", dup="num_pileup_dzpvsigcut")),
297  xtitle="Efficiency vs. cut on dz(PV)/dzError", **_common),
298  Plot(ROC("effic_vs_fakepileup2_dzpvsigcut", "effic_vs_dzpvsigcut", FakeDuplicate("fakepileup_vs_dzpvsigcut", assoc="num_assoc(recoToSim)_dzpvsigcut", reco="num_reco_dzpvsigcut", dup="num_pileup_dzpvsigcut"), zaxis=True),
299  xtitle="Efficiency", ztitle="Cut on dz(PV)/dzError", **_common2),
300 ], onlyForPileup=True,
301  legendDy=_legendDy_4rows
302 )
303 _pvassociation2 = PlotGroup("pvassociation2", [
304  Plot("effic_vs_dzpvcut", xtitle="Cut on dz(PV) (cm)", ytitle="Efficiency vs. cut on dz(PV)", ymax=_maxEff),
305  Plot("effic_vs_dzpvcut2", xtitle="Cut on dz(PV) (cm)", ytitle="Efficiency (excl. trk eff)", ymax=_maxEff),
306  Plot("fakerate_vs_dzpvcut", xtitle="Cut on dz(PV) (cm)", ytitle="Fake rate vs. cut on dz(PV)", ymax=_maxFake),
307  Plot("pileuprate_dzpvcut", xtitle="Cut on dz(PV) (cm)", ytitle="Pileup rate vs. cut on dz(PV)", ymax=_maxFake),
308  #
309  Plot("effic_vs_dzpvsigcut", xtitle="Cut on dz(PV)/dzError", ytitle="Efficiency vs. cut on dz(PV)/dzError", ymax=_maxEff),
310  Plot("effic_vs_dzpvsigcut2", xtitle="Cut on dz(PV)/dzError", ytitle="Efficiency (excl. trk eff)", ymax=_maxEff),
311  Plot("fakerate_vs_dzpvsigcut", xtitle="Cut on dz(PV)/dzError", ytitle="Fake rate vs. cut on dz(PV)/dzError", ymax=_maxFake),
312  Plot("pileuprate_dzpvsigcut", xtitle="Cut on dz(PV)/dzError", ytitle="Pileup rate vs. cut on dz(PV)/dzError", ymax=_maxFake),
313 ], onlyForPileup=True,
314  legendDy=_legendDy_4rows
315 )
316 
317 
318 # These don't exist in FastSim
319 _common = {"normalizeToUnitArea": True, "stat": True, "drawStyle": "hist"}
320 _dedx = PlotGroup("dedx", [
321  Plot("h_dedx_estim1", xtitle="dE/dx, harm2", **_common),
322  Plot("h_dedx_estim2", xtitle="dE/dx, trunc40", **_common),
323  Plot("h_dedx_nom1", xtitle="dE/dx number of measurements", title="", **_common),
324  Plot("h_dedx_sat1", xtitle="dE/dx number of measurements with saturation", title="", **_common),
325  ],
326  legendDy=_legendDy_2rows
327 )
328 
329 _chargemisid = PlotGroup("chargemisid", [
330  Plot("chargeMisIdRate", xtitle="#eta", ytitle="charge mis-id rate vs #eta", ymax=0.05),
331  Plot("chargeMisIdRate_Pt", xtitle="p_{T}", ytitle="charge mis-id rate vs p_{T}", xmax=300, ymax=0.1, xlog=True),
332  Plot("chargeMisIdRate_hit", xtitle="hits", ytitle="charge mis-id rate vs hits", title=""),
333  Plot("chargeMisIdRate_phi", xtitle="#phi", ytitle="charge mis-id rate vs #phi", title="", ymax=0.01),
334  Plot("chargeMisIdRate_dxy", xtitle="dxy", ytitle="charge mis-id rate vs dxy", ymax=0.1),
335  Plot("chargeMisIdRate_dz", xtitle="dz", ytitle="charge mis-id rate vs dz", ymax=0.1)
336 ])
337 _common = {"stat": True, "normalizeToUnitArea": True, "ylog": True, "ymin": 1e-6, "drawStyle": "hist"}
338 _hitsAndPt = PlotGroup("hitsAndPt", [
339  Plot("missing_inner_layers", xmin=_minLayers, xmax=_maxLayers, ymax=1, **_common),
340  Plot("missing_outer_layers", xmin=_minLayers, xmax=_maxLayers, ymax=1, **_common),
341  Plot("hits_eta", xtitle="track #eta", ytitle="<hits> vs #eta", ymin=_minHits, ymax=_maxHits, statyadjust=[0,0,-0.15],
342  fallback={"name": "nhits_vs_eta", "profileX": True}),
343  Plot("hits", stat=True, xtitle="track hits", xmin=_minHits, xmax=_maxHits, ylog=True, ymin=[5e-1, 5, 5e1, 5e2, 5e3], drawStyle="hist"),
344  Plot("num_simul_pT", xtitle="TP p_{T}", xlog=True, ymax=[1e-1, 2e-1, 5e-1, 1], **_common),
345  Plot("num_reco_pT", xtitle="track p_{T}", xlog=True, ymax=[1e-1, 2e-1, 5e-1, 1], **_common)
346 ])
347 _tuning = PlotGroup("tuning", [
348  Plot("chi2", stat=True, normalizeToUnitArea=True, ylog=True, ymin=1e-6, ymax=[0.1, 0.2, 0.5, 1.0001], drawStyle="hist", xtitle="#chi^{2}", ratioUncertainty=False),
349  Plot("chi2_prob", stat=True, normalizeToUnitArea=True, drawStyle="hist", xtitle="Prob(#chi^{2})"),
350  Plot("chi2mean", title="", xtitle="#eta", ytitle="< #chi^{2} / ndf >", ymin=[0, 0.5], ymax=[2, 2.5, 3, 5],
351  fallback={"name": "chi2_vs_eta", "profileX": True}),
352  Plot("ptres_vs_eta_Mean", scale=100, title="", xtitle="TP #eta (PCA to beamline)", ytitle="< #delta p_{T} / p_{T} > (%)", ymin=_minResidualPt, ymax=_maxResidualPt),
353  Plot("chi2mean_vs_pt", title="", xtitle="p_{T}", ytitle="< #chi^{2} / ndf >", ymin=[0, 0.5], ymax=[2, 2.5, 3, 5], xlog=True, fallback={"name": "chi2_vs_pt", "profileX": True}),
354  Plot("chi2mean_vs_drj", title="", xtitle="#DeltaR(track, jet)", ytitle="< #chi^{2} / ndf >", ymin=[0, 0.5], ymax=[2, 2.5, 3, 5], xlog=True, xmax=_maxDRJ, fallback={"name": "chi2_vs_drj", "profileX": True}),
355  Plot("ptres_vs_pt_Mean", title="", xtitle="p_{T}", ytitle="< #delta p_{T}/p_{T} > (%)", scale=100, ymin=_minResidualPt, ymax=_maxResidualPt,xlog=True)
356 ])
357 _common = {"stat": True, "fit": True, "normalizeToUnitArea": True, "drawStyle": "hist", "drawCommand": "", "xmin": -10, "xmax": 10, "ylog": True, "ymin": 5e-5, "ymax": [0.01, 0.05, 0.1, 0.2, 0.5, 0.8, 1.025], "ratioUncertainty": False}
358 _pulls = PlotGroup("pulls", [
359  Plot("pullPt", **_common),
360  Plot("pullQoverp", **_common),
361  Plot("pullPhi", **_common),
362  Plot("pullTheta", **_common),
363  Plot("pullDxy", **_common),
364  Plot("pullDz", **_common),
365 ],
366  legendDx=0.1, legendDw=-0.1, legendDh=-0.015
367 )
368 _common = {"title": "", "ylog": True, "xtitle": "TP #eta (PCA to beamline)", "ymin": _minMaxResol, "ymax": _minMaxResol}
369 _resolutionsEta = PlotGroup("resolutionsEta", [
370  Plot("phires_vs_eta_Sigma", ytitle="#sigma(#delta #phi) (rad)", **_common),
371  Plot("cotThetares_vs_eta_Sigma", ytitle="#sigma(#delta cot(#theta))", **_common),
372  Plot("dxyres_vs_eta_Sigma", ytitle="#sigma(#delta d_{xy}) (cm)", **_common),
373  Plot("dzres_vs_eta_Sigma", ytitle="#sigma(#delta d_{z}) (cm)", **_common),
374  Plot("ptres_vs_eta_Sigma", ytitle="#sigma(#delta p_{T}/p_{T})", **_common),
375 ])
376 _common = {"title": "", "ylog": True, "xlog": True, "xtitle": "TP p_{T} (PCA to beamline)", "xmin": 0.1, "xmax": 1000, "ymin": _minMaxResol, "ymax": _minMaxResol}
377 _resolutionsPt = PlotGroup("resolutionsPt", [
378  Plot("phires_vs_pt_Sigma", ytitle="#sigma(#delta #phi) (rad)", **_common),
379  Plot("cotThetares_vs_pt_Sigma", ytitle="#sigma(#delta cot(#theta))", **_common),
380  Plot("dxyres_vs_pt_Sigma", ytitle="#sigma(#delta d_{xy}) (cm)", **_common),
381  Plot("dzres_vs_pt_Sigma", ytitle="#sigma(#delta d_{z}) (cm)", **_common),
382  Plot("ptres_vs_pt_Sigma", ytitle="#sigma(#delta p_{T}/p_{T})", **_common),
383 ])
384 _common = {"title": "", "ylog": True, "xtitle": "TP #Phi (PCA to beamline)", "ymin": _minMaxResol, "ymax": _minMaxResol}
385 _resolutionsPhi = PlotGroup("resolutionsPhi", [
386  Plot("dxyres_vs_phi_Sigma", ytitle="#sigma(#delta d_{xy}) (cm)", **_common),
387  Plot("dzres_vs_phi_Sigma", ytitle="#sigma(#delta d_{z}) (cm)", **_common),
388  Plot("phires_vs_phi_Sigma", ytitle="#sigma(#delta #phi) (rad)", **_common),
389  Plot("ptres_vs_phi_Sigma", ytitle="#sigma(#delta p_{T}/p_{T})", **_common),
390 ])
391 
392 
393 _extDistPtEtaPhi = PlotGroup("distPtEtaPhi",
394  _makeDistPlots("pT", "p_{T} (GeV)", common=dict(xlog=True)) +
395  _makeDistPlots("eta", "#eta") +
396  _makeDistPlots("phi", "#phi"),
397  ncols=4)
398 _extDistDxyDzBS = PlotGroup("distDxyDzBS",
399  _makeDistPlots("dxy" , "dxy (cm)") +
400  _makeDistPlots("dz" , "dz (cm)"),
401  ncols=4, legendDy=_legendDy_2rows)
402 _extDistDxyDzPV = PlotGroup("distDxyDzPV",
403  _makeDistPlots("dxypv" , "dxy(PV) (cm)") +
404  _makeDistPlots("dxypv_zoomed", "dxy(PV) (cm)") +
405  _makeDistPlots("dzpv" , "dz(PV) (cm)") +
406  _makeDistPlots("dzpv_zoomed" , "dz(PV) (cm)"),
407  ncols=4, legendDy=_legendDy_4rows)
408 _extDistHitsLayers = PlotGroup("distHitsLayers",
409  _makeDistPlots("hit" , "hits" , common=dict(xmin=_minHits , xmax=_maxHits)) +
410  _makeDistPlots("layer" , "layers" , common=dict(xmin=_minLayers , xmax=_maxLayers)) +
411  _makeDistPlots("pixellayer", "pixel layers", common=dict( xmax=_maxPixelLayers)) +
412  _makeDistPlots("3Dlayer" , "3D layers" , common=dict(xmin=_min3DLayers, xmax=_max3DLayers)),
413  ncols=4, legendDy=_legendDy_4rows,
414 )
415 _extDistPos = PlotGroup("distPos",
416  _makeDistPlots("vertpos", "ref. point r (cm)", common=dict(xlog=True)) +
417  _makeDistPlots("zpos" , "ref. point z (cm)") +
418  _makeDistPlots("simpvz" , "Sim. PV z (cm)", common=dict(xmin=_minZ, xmax=_maxZ)),
419  ncols=3,
420 )
421 _extDistDeltaR = PlotGroup("distDeltaR",
422  _makeDistPlots("dr" , "min #DeltaR", common=dict(xlog=True)) +
423  _makeDistPlots("drj" , "#DeltaR(track, jet)", common=dict(xlog=True, xmax=_maxDRJ)),
424  ncols=2, legendDy=_legendDy_2rows,
425 )
426 _extDistSeedingPlots = _makeDistPlots("seedingLayerSet", "seeding layers", common=dict(xtitle="", **_seedingLayerSet_common))
427 _extDistChi2Seeding = PlotGroup("distChi2Seeding",
428  _makeDistPlots("chi2", "#chi^{2}") +
429  _extDistSeedingPlots,
430  ncols=4, legendDy=_legendDy_2rows_3cols
431 )
432 _common = dict(title="", xtitle="TP #eta (PCA to beamline)")
433 _extResidualEta = PlotGroup("residualEta", [
434  Plot("phires_vs_eta_Mean", ytitle="< #delta #phi > (rad)", ymin=_minResidualPhi, ymax=_maxResidualPhi, **_common),
435  Plot("cotThetares_vs_eta_Mean", ytitle="< #delta cot(#theta) >", ymin=_minResidualCotTheta, ymax=_maxResidualCotTheta, **_common),
436  Plot("dxyres_vs_eta_Mean", ytitle="< #delta d_{xy} > (#mum)", scale=10000, ymin=_minResidualDxy, ymax=_maxResidualDxy, **_common),
437  Plot("dzres_vs_eta_Mean", ytitle="< #delta d_{z} > (#mum)", scale=10000, ymin=_minResidualDz, ymax=_maxResidualDz, **_common),
438  Plot("ptres_vs_eta_Mean", ytitle="< #delta p_{T}/p_{T} > (%)", scale=100, ymin=_minResidualPt, ymax=_maxResidualPt, **_common), # same as in tuning, but to be complete
439 ])
440 _common = dict(title="", xlog=True, xtitle="TP p_{T} (PCA to beamline)", xmin=0.1, xmax=1000)
441 _extResidualPt = PlotGroup("residualPt", [
442  Plot("phires_vs_pt_Mean", ytitle="< #delta #phi > (rad)", ymin=_minResidualPhi, ymax=_maxResidualPhi, **_common),
443  Plot("cotThetares_vs_pt_Mean", ytitle="< #delta cot(#theta > )", ymin=_minResidualCotTheta, ymax=_maxResidualCotTheta, **_common),
444  Plot("dxyres_vs_pt_Mean", ytitle="< #delta d_{xy} > (#mum)", scale=10000, ymin=_minResidualDxy, ymax=_maxResidualDxy, **_common),
445  Plot("dzres_vs_pt_Mean", ytitle="< #delta d_{z} > (#mum)", scale=10000, ymin=_minResidualDz, ymax=_maxResidualDz, **_common),
446  Plot("ptres_vs_pt_Mean", ytitle="< #delta p_{T}/p_{T} > (%)", scale=100, ymin=_minResidualPt, ymax=_maxResidualPt, **_common), # same as in tuning, but to be complete
447 ])
448 _common = dict(title="", ytitle="Selected tracks/TrackingParticles", ymax=_maxEff)
449 _extNrecVsNsim = PlotGroup("nrecVsNsim", [
450  Plot("nrec_vs_nsim", title="", xtitle="TrackingParticles", ytitle="Tracks", profileX=True, xmin=_minMaxTracks, xmax=_minMaxTracks, ymin=_minMaxTracks, ymax=_minMaxTracks),
451  Plot("nrecPerNsim_vs_pu", xtitle="Pileup", xmin=_minPU, xmax=_maxPU, **_common),
452  Plot("nrecPerNsimPt", xtitle="p_{T} (GeV)", xlog=True, **_common),
453  Plot("nrecPerNsim", xtitle="#eta", **_common)
454 ], legendDy=_legendDy_2rows)
455 _extHitsLayers = PlotGroup("hitsLayers", [
456  Plot("PXLhits_vs_eta", xtitle="#eta", ytitle="<pixel hits>"),
457  Plot("PXLlayersWithMeas_vs_eta", xtitle="#eta", ytitle="<pixel layers>"),
458  Plot("STRIPhits_vs_eta", xtitle="#eta", ytitle="<strip hits>"),
459  Plot("STRIPlayersWithMeas_vs_eta", xtitle="#eta", ytitle="<strip layers>"),
460 ], legendDy=_legendDy_2rows)
461 
462 
463 
464 _extDistSimPtEtaPhi = PlotGroup("distsimPtEtaPhi",
465  _makeDistSimPlots("pT", "p_{T} (GeV)", common=dict(xlog=True)) +
466  _makeDistSimPlots("eta", "#eta") +
467  _makeDistSimPlots("phi", "#phi"),
468  ncols=2)
469 _extDistSimDxyDzBS = PlotGroup("distsimDxyDzBS",
470  _makeDistSimPlots("dxy" , "dxy (cm)") +
471  _makeDistSimPlots("dz" , "dz (cm)"),
472  ncols=2, legendDy=_legendDy_2rows)
473 _extDistSimDxyDzPV = PlotGroup("distsimDxyDzPV",
474  _makeDistSimPlots("dxypv" , "dxy(PV) (cm)") +
475  _makeDistSimPlots("dxypv_zoomed", "dxy(PV) (cm)") +
476  _makeDistSimPlots("dzpv" , "dz(PV) (cm)") +
477  _makeDistSimPlots("dzpv_zoomed" , "dz(PV) (cm)"),
478  ncols=2, legendDy=_legendDy_4rows)
479 _extDistSimHitsLayers = PlotGroup("distsimHitsLayers",
480  _makeDistSimPlots("hit" , "hits" , common=dict(xmin=_minHits , xmax=_maxHits)) +
481  _makeDistSimPlots("layer" , "layers" , common=dict(xmin=_minLayers , xmax=_maxLayers)) +
482  _makeDistSimPlots("pixellayer", "pixel layers", common=dict( xmax=_maxPixelLayers)) +
483  _makeDistSimPlots("3Dlayer" , "3D layers" , common=dict(xmin=_min3DLayers, xmax=_max3DLayers)),
484  ncols=2, legendDy=_legendDy_4rows,
485 )
486 _extDistSimPos = PlotGroup("distsimPos",
487  _makeDistSimPlots("vertpos", "vert r (cm)", common=dict(xlog=True)) +
488  _makeDistSimPlots("zpos" , "vert z (cm)") +
489  _makeDistSimPlots("simpvz" , "Sim. PV z (cm)", common=dict(xmin=_minZ, xmax=_maxZ)),
490  ncols=3,
491 )
492 _extDistSimDeltaR = PlotGroup("distsimDeltaR",
493  _makeDistSimPlots("dr" , "min #DeltaR", common=dict(xlog=True)) +
494  _makeDistSimPlots("drj" , "#DeltaR(TP, jet)", common=dict(xlog=True, xmax=_maxDRJ)),
495  ncols=2, legendDy=_legendDy_2rows,
496 )
497 
498 
503 
504 _possibleTrackingNonIterationColls = [
505  'ak4PFJets',
506  'btvLike',
507 ]
508 _possibleTrackingColls = [
509  'initialStepPreSplitting',
510  'initialStep',
511  'highPtTripletStep', # phase1
512  'detachedQuadStep', # phase1
513  'detachedTripletStep',
514  'lowPtQuadStep', # phase1
515  'lowPtTripletStep',
516  'pixelPairStepA', # seeds
517  'pixelPairStepB', # seeds
518  'pixelPairStepC', # seeds
519  'pixelPairStep',
520  'mixedTripletStepA', # seeds
521  'mixedTripletStepB', # seeds
522  'mixedTripletStep',
523  'pixelLessStep',
524  'tobTecStepPair', # seeds
525  'tobTecStepTripl', # seeds
526  'tobTecStep',
527  'displacedGeneralStep',
528  'jetCoreRegionalStep',
529  'muonSeededStepInOut',
530  'muonSeededStepOutIn',
531  'duplicateMerge',
532 ] + _possibleTrackingNonIterationColls
533 _possibleTrackingCollsOld = {
534  "Zero" : "iter0",
535  "First" : "iter1",
536  "Second": "iter2",
537  "Third" : "iter3",
538  "Fourth": "iter4",
539  "Fifth" : "iter5",
540  "Sixth" : "iter6",
541  "Seventh": "iter7",
542  "Ninth" : "iter9",
543  "Tenth" : "iter10",
544 }
545 
546 def _trackingSubFoldersFallbackSLHC_Phase1PU140(subfolder):
547  ret = subfolder.replace("trackingParticleRecoAsssociation", "AssociatorByHitsRecoDenom")
548  for (old, new) in [("InitialStep", "Zero"),
549  ("HighPtTripletStep", "First"),
550  ("LowPtQuadStep", "Second"),
551  ("LowPtTripletStep", "Third"),
552  ("DetachedQuadStep", "Fourth"),
553  ("PixelPairStep", "Fifth"),
554  ("MuonSeededStepInOut", "Ninth"),
555  ("MuonSeededStepOutIn", "Tenth")]:
556  ret = ret.replace(old, new)
557  if ret == subfolder:
558  return None
559  return ret
560 def _trackingRefFileFallbackSLHC_Phase1PU140(path):
561  for (old, new) in [("initialStep", "iter0"),
562  ("highPtTripletStep", "iter1"),
563  ("lowPtQuadStep", "iter2"),
564  ("lowPtTripletStep", "iter3"),
565  ("detachedQuadStep", "iter4"),
566  ("pixelPairStep", "iter5"),
567  ("muonSeededStepInOut", "iter9"),
568  ("muonSeededStepOutIn", "iter10")]:
569  path = path.replace(old, new)
570  return path
571 
572 def _trackingSubFoldersFallbackFromPV(subfolder):
573  return subfolder.replace("trackingParticleRecoAsssociation", "trackingParticleRecoAsssociationSignal")
574 def _trackingSubFoldersFallbackConversion(subfolder):
575  return subfolder.replace("quickAssociatorByHits", "quickAssociatorByHitsConversion")
576 def _trackingSubFoldersFallbackPreSplitting(subfolder):
577  return subfolder.replace("quickAssociatorByHits", "quickAssociatorByHitsPreSplitting")
578 
579 # Additional "quality" flags than highPurity. In a separate list to
580 # allow customization.
581 _additionalTrackQualities = [
582  "Pt09",
583  "ByOriginalAlgo",
584  "ByAlgoMask"
585 ]
586 def _mapCollectionToAlgoQuality(collName):
587  if "Hp" in collName:
588  quality = "highPurity"
589  else:
590  quality = ""
591  collNameNoQuality = collName.replace("Hp", "")
592  for qual in _additionalTrackQualities:
593  if qual in collName:
594  quality += qual
595  collNameNoQuality = collNameNoQuality.replace(qual, "")
596 
597  collNameNoQuality = collNameNoQuality.replace("Tracks", "", 1) # make summary naming consistent with iteration folders
598  collNameLow = collNameNoQuality.lower().replace("frompv2", "").replace("frompv", "").replace("frompvalltp", "").replace("alltp", "")
599 
600  if collNameLow.find("seed") == 0:
601  collNameLow = collNameLow[4:]
602  if collNameLow == "initialstepseedspresplitting":
603  collNameLow = "initialsteppresplittingseeds"
604  elif collNameLow == "muonseededseedsinout":
605  collNameLow = "muonseededstepinoutseeds"
606  elif collNameLow == "muonseededseedsoutin":
607  collNameLow = "muonseededstepoutinseeds"
608 
609  i_seeds = collNameLow.index("seeds")
610  quality = collNameLow[i_seeds:]+quality
611 
612  collNameLow = collNameLow[:i_seeds]
613 
614  algo = None
615  prefixes = ["cutsreco", "cutsrecofrompv", "cutsrecofrompv2", "cutsrecofrompvalltp", "cutsrecoetagreater2p7"]
616  if collNameLow in ["general", "generalfrompv", "generaletagreater2p7"]+prefixes:
617  algo = "ootb"
618  elif collNameLow in ["pixel", "pixelfrompv", "pixelfrompvalltp"]:
619  algo = "pixel"
620  else:
621  def testColl(coll):
622  for pfx in prefixes:
623  if coll == collNameLow.replace(pfx, ""):
624  return True
625  return False
626 
627  for coll in _possibleTrackingColls:
628  if testColl(coll.lower()):
629  algo = coll
630  break
631  # next try "old style"
632  if algo is None:
633  for coll, name in six.iteritems(_possibleTrackingCollsOld):
634  if testColl(coll.lower()):
635  algo = name
636  break
637 
638  # fallback
639  if algo is None:
640  algo = collNameNoQuality
641 
642  # fix for track collection naming convention
643  if algo == "muonSeededInOut":
644  algo = "muonSeededStepInOut"
645  if algo == "muonSeededOutIn":
646  algo = "muonSeededStepOutIn"
647 
648  return (algo, quality)
649 
650 def _collhelper(name):
651  return (name, [name])
652 _collLabelMap = collections.OrderedDict(map(_collhelper, ["generalTracks"]+_possibleTrackingColls))
653 _collLabelMapHp = collections.OrderedDict(map(_collhelper, ["generalTracks"]+[n for n in _possibleTrackingColls if "Step" in n]))
654 def _summaryBinRename(binLabel, highPurity, byOriginalAlgo, byAlgoMask, ptCut, seeds):
655  (algo, quality) = _mapCollectionToAlgoQuality(binLabel)
656  if algo == "ootb":
657  algo = "generalTracks"
658  ret = None
659 
660  if byOriginalAlgo:
661  if algo != "generalTracks" and "ByOriginalAlgo" not in quality: # keep generalTracks bin as well
662  return None
663  quality = quality.replace("ByOriginalAlgo", "")
664  if byAlgoMask:
665  if algo != "generalTracks" and "ByAlgoMask" not in quality: # keep generalTracks bin as well
666  return None
667  quality = quality.replace("ByAlgoMask", "")
668  if ptCut:
669  if "Pt09" not in quality:
670  return None
671  quality = quality.replace("Pt09", "")
672 
673  if highPurity:
674  if quality == "highPurity":
675  ret = algo
676  elif seeds:
677  i_seeds = quality.find("seeds")
678  if i_seeds == 0:
679  ret = algo
680  seedSubColl = quality[i_seeds+5:]
681  if seedSubColl != "":
682  ret += seedSubColl[0].upper() + seedSubColl[1:]
683  else:
684  if quality == "":
685  ret = algo
686 
687  return ret
688 
689 def _constructSummary(mapping=None, highPurity=False, byOriginalAlgo=False, byAlgoMask=False, ptCut=False, seeds=False, midfix=""):
690  _common = {"drawStyle": "EP", "xbinlabelsize": 10, "xbinlabeloption": "d"}
691  _commonN = dict(ylog=True, ymin=_minMaxN, ymax=_minMaxN,
692  normalizeToNumberOfEvents=True,
693  )
694  _commonN.update(_common)
695  _commonAB = dict(mapping=mapping,
696  renameBin=lambda bl: _summaryBinRename(bl, highPurity, byOriginalAlgo, byAlgoMask, ptCut, seeds),
697  ignoreMissingBins=True,
698  originalOrder=True,
699  )
700  if byOriginalAlgo or byAlgoMask:
701  _commonAB["minExistingBins"] = 2
702  prefix = "summary"+midfix
703 
704  h_eff = "effic_vs_coll"
705  h_fakerate = "fakerate_vs_coll"
706  h_duplicaterate = "duplicatesRate_coll"
707  h_pileuprate = "pileuprate_coll"
708 
709  h_reco = "num_reco_coll"
710  h_true = "num_assoc(recoToSim)_coll"
711  h_fake = Subtract("num_fake_coll_orig", "num_reco_coll", "num_assoc(recoToSim)_coll")
712  h_duplicate = "num_duplicate_coll"
713  h_pileup = "num_pileup_coll"
714  if mapping is not None:
715  h_eff = AggregateBins("efficiency", h_eff, **_commonAB)
716  h_fakerate = AggregateBins("fakerate", h_fakerate, **_commonAB)
717  h_duplicaterate = AggregateBins("duplicatesRate", h_duplicaterate, **_commonAB)
718  h_pileuprate = AggregateBins("pileuprate", h_pileuprate, **_commonAB)
719 
720  h_reco = AggregateBins("num_reco_coll", h_reco, **_commonAB)
721  h_true = AggregateBins("num_true_coll", h_true, **_commonAB)
722  h_fake = AggregateBins("num_fake_coll", h_fake, **_commonAB)
723  h_duplicate = AggregateBins("num_duplicate_coll", h_duplicate, **_commonAB)
724  h_pileup = AggregateBins("num_pileup_coll", h_pileup, **_commonAB)
725 
726  summary = PlotGroup(prefix, [
727  Plot(h_eff, title="Efficiency vs collection", ytitle="Efficiency", ymin=1e-3, ymax=1, ylog=True, **_common),
728  Plot(h_fakerate, title="Fakerate vs collection", ytitle="Fake rate", ymax=_maxFake, **_common),
729  #
730  Plot(h_duplicaterate, title="Duplicates rate vs collection", ytitle="Duplicates rate", ymax=_maxFake, **_common),
731  Plot(h_pileuprate, title="Pileup rate vs collection", ytitle="Pileup rate", ymax=_maxFake, **_common),
732  ],
733  legendDy=_legendDy_2rows
734  )
735  summaryN = PlotGroup(prefix+"_ntracks", [
736  # FIXME
737  #Plot(h_reco, ytitle="Tracks/event", title="Number of tracks/event vs collection", **_commonN),
738  #Plot(h_true, ytitle="True tracks/event", title="Number of true tracks/event vs collection", **_commonN),
739  #Plot(h_fake, ytitle="Fake tracks/event", title="Number of fake tracks/event vs collection", **_commonN),
740  #Plot(h_duplicate, ytitle="Duplicate tracks/event", title="Number of duplicate tracks/event vs collection", **_commonN),
741  #Plot(h_pileup, ytitle="Pileup tracks/event", title="Number of pileup tracks/event vs collection", **_commonN),
742  Plot(h_reco, ytitle="Tracks", title="Number of tracks vs collection", **_commonN),
743  Plot(h_true, ytitle="True tracks", title="Number of true tracks vs collection", **_commonN),
744  Plot(h_fake, ytitle="Fake tracks", title="Number of fake tracks vs collection", **_commonN),
745  Plot(h_duplicate, ytitle="Duplicate tracks", title="Number of duplicate tracks vs collection", **_commonN),
746  Plot(h_pileup, ytitle="Pileup tracks", title="Number of pileup tracks vs collection", **_commonN),
747  ])
748 
749  return (summary, summaryN)
750 
751 (_summaryRaw, _summaryRawN) = _constructSummary(midfix="Raw")
752 (_summary, _summaryN) = _constructSummary(_collLabelMap)
753 (_summaryHp, _summaryNHp) = _constructSummary(_collLabelMapHp, highPurity=True)
754 (_summaryByOriginalAlgo, _summaryByOriginalAlgoN) = _constructSummary(_collLabelMapHp, byOriginalAlgo=True, midfix="ByOriginalAlgo")
755 (_summaryByOriginalAlgoHp, _summaryByOriginalAlgoNHp) = _constructSummary(_collLabelMapHp, byOriginalAlgo=True, midfix="ByOriginalAlgo", highPurity=True)
756 (_summaryByAlgoMask, _summaryByAlgoMaskN) = _constructSummary(_collLabelMapHp, byAlgoMask=True, midfix="ByAlgoMask")
757 (_summaryByAlgoMaskHp, _summaryByAlgoMaskNHp) = _constructSummary(_collLabelMapHp, byAlgoMask=True, midfix="ByAlgoMask", highPurity=True)
758 (_summaryPt09, _summaryPt09N) = _constructSummary(_collLabelMap, ptCut=True, midfix="Pt09")
759 (_summaryPt09Hp, _summaryPt09NHp) = _constructSummary(_collLabelMap, ptCut=True, midfix="Pt09", highPurity=True)
760 (_summarySeeds, _summarySeedsN) = _constructSummary(_collLabelMapHp, seeds=True)
761 
762 
767 
768 _common = {"normalizeToUnitArea": True, "ylog": True, "ymin": [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2], "ymax": [1e-2, 1e-1, 1.1]}
769 _commonStatus = {}
770 _commonStatus.update(_common)
771 _commonStatus.update({"xbinlabelsize": 10, "xbinlabeloption": "d", "drawStyle": "hist", "adjustMarginRight": 0.08})
772 _commonLabelSize = {}
773 _commonLabelSize.update(_common)
774 _commonLabelSize.update({"xlabelsize": 17})
775 
776 _packedCandidateFlow = PlotGroup("flow", [
777  Plot("selectionFlow", xbinlabelsize=10, xbinlabeloption="d", adjustMarginRight=0.1, drawStyle="hist", ylog=True, ymin=[0.9, 9, 9e1, 9e2, 9e3, 9e4, 9e5, 9e6, 9e7]),
778  Plot("diffCharge", xtitle="Charge", **_common),
779  Plot("diffIsHighPurity", xtitle="High purity status", **_common),
780  Plot("diffNdof", xtitle="ndof", **_common),
781  Plot("diffNormalizedChi2", xtitle="#chi^{2}/ndof", **_common),
782 ])
783 
784 _packedCandidateHitsHitPattern = PlotGroup("hitsHitPattern", [
785  Plot("diffHitPatternNumberOfValidHits", xtitle="Valid hits (via HitPattern)", **_common),
786  Plot("diffHitPatternNumberOfValidPixelHits", xtitle="Valid pixel hits (via HitPattern)", **_common),
787  Plot("diffHitPatternHasValidHitInFirstPixelBarrel", xtitle="Has valid hit in BPix1 layer (via HitPattern)", **_common),
788  Plot("diffHitPatternNumberOfLostPixelHits", xtitle="Lost pixel hits (via HitPattern)", **_common),
789 ],
790  legendDy=_legendDy_2rows
791 )
792 _packedCandidateHits = PlotGroup("hits", [
793  Plot("diffNumberOfHits", xtitle="Hits", **_common),
794  Plot("diffNumberOfPixelHits", xtitle="Pixel hits", **_common),
795  Plot("diffLostInnerHits", xtitle="Lost inner hits", **_common),
796  Plot("numberHitsOverMax", xtitle="Number of overflown hits", **_common),
797  Plot("numberPixelHitsOverMax", xtitle="Number of overflown pixel hits", **_common),
798  Plot("numberStripHitsOverMax", xtitle="Number of overflown strip hits", **_common),
799 ],
800  ncols=3, legendDy=_legendDy_2rows_3cols
801 )
802 
803 _packedCandidateLayers = PlotGroup("layers", [
804  PlotEmpty(),
805  Plot("diffNumberOfPixelLayers", xtitle="Pixel layers", **_common),
806  Plot("diffNumberOfStripLayers", xtitle="Strip layers", **_common),
807  #
808  Plot("diffHitPatternTrackerLayersWithMeasurement", xtitle="Layers (via HitPattern)", **_common),
809  Plot("diffHitPatternPixelLayersWithMeasurement", xtitle="Pixel layers (via HitPattern)", **_common),
810  Plot("diffHitPatternStripLayersWithMeasurement", xtitle="Strip layers (via HitPattern)", **_common),
811  #
812  Plot("numberLayersOverMax", xtitle="Number of overflown layers", **_common),
813  Plot("numberPixelLayersOverMax", xtitle="Number of overflown pixel layers", **_common),
814  Plot("numberStripLayersOverMax", xtitle="Number of overflown strip layers", **_common),
815 ],
816  ncols=3
817 )
818 
819 
820 _packedCandidateImpactParameter1 = PlotGroup("impactParameter1", [
821  Plot("diffDxyAssocPV", xtitle="dxy(assocPV)", adjustMarginRight=0.02, **_commonLabelSize),
822  Plot("diffDxyAssocPVStatus", **_commonStatus),
823  Plot("diffDxyAssocPVUnderOverFlowSign", xtitle="dxy(assocPV)", **_common),
824  Plot("diffDzAssocPV", xtitle="dz(assocPV)", adjustMarginRight=0.02, **_commonLabelSize),
825  Plot("diffDzAssocPVStatus", **_commonStatus),
826  Plot("diffDzAssocPVUnderOverFlowSign", xtitle="dz(assocPV)", **_common),
827  Plot("diffDxyError", xtitle="dxyError()", adjustMarginRight=0.02, **_commonLabelSize),
828  Plot("diffDszError", xtitle="dszError()", adjustMarginRight=0.02, **_commonLabelSize),
829  Plot("diffDzError", xtitle="dzError()", adjustMarginRight=0.02, **_commonLabelSize),
830 
831 ],
832  ncols=3
833 )
834 
835 _packedCandidateImpactParameter2 = PlotGroup("impactParameter2", [
836  Plot("diffDxyPV", xtitle="dxy(PV) via PC", **_commonLabelSize),
837  Plot("diffDzPV", xtitle="dz(PV) via PC", **_commonLabelSize),
838  Plot("diffTrackDxyAssocPV", xtitle="dxy(PV) via PC::bestTrack()", **_commonLabelSize),
839  Plot("diffTrackDzAssocPV", xtitle="dz(PV) via PC::bestTrack()", **_commonLabelSize),
840  Plot("diffTrackDxyError", xtitle="dxyError() via PC::bestTrack()", adjustMarginRight=0.02, **_commonLabelSize),
841  Plot("diffTrackDzError", xtitle="dzError() via PC::bestTrack()", **_commonLabelSize),
842 ])
843 
844 _packedCandidateCovarianceMatrix1 = PlotGroup("covarianceMatrix1", [
845  Plot("diffCovQoverpQoverp", xtitle="cov(qoverp, qoverp)", **_commonLabelSize),
846  Plot("diffCovQoverpQoverpStatus", **_commonStatus),
847  Plot("diffCovQoverpQoverpUnderOverFlowSign", xtitle="cov(qoverp, qoverp)", **_common),
848  Plot("diffCovLambdaLambda", xtitle="cov(lambda, lambda)", **_commonLabelSize),
849  Plot("diffCovLambdaLambdaStatus", **_commonStatus),
850  Plot("diffCovLambdaLambdaUnderOverFlowSign", xtitle="cov(lambda, lambda)", **_common),
851  Plot("diffCovLambdaDsz", xtitle="cov(lambda, dsz)", **_commonLabelSize),
852  Plot("diffCovLambdaDszStatus", **_commonStatus),
853  Plot("diffCovLambdaDszUnderOverFlowSign", xtitle="cov(lambda, dsz)", **_common),
854  Plot("diffCovPhiPhi", xtitle="cov(phi, phi)", **_commonLabelSize),
855  Plot("diffCovPhiPhiStatus", **_commonStatus),
856  Plot("diffCovPhiPhiUnderOverFlowSign", xtitle="cov(phi, phi)", **_common),
857 ],
858  ncols=3, legendDy=_legendDy_4rows
859 )
860 _packedCandidateCovarianceMatrix2 = PlotGroup("covarianceMatrix2", [
861  Plot("diffCovPhiDxy", xtitle="cov(phi, dxy)", **_commonLabelSize),
862  Plot("diffCovPhiDxyStatus", **_commonStatus),
863  Plot("diffCovPhiDxyUnderOverFlowSign", xtitle="cov(phi, dxy)", **_common),
864  Plot("diffCovDxyDxy", xtitle="cov(dxy, dxy)", adjustMarginRight=0.02, **_commonLabelSize),
865  Plot("diffCovDxyDxyStatus", **_commonStatus),
866  Plot("diffCovDxyDxyUnderOverFlowSign", xtitle="cov(dxy, dxy)", **_common),
867  Plot("diffCovDxyDsz", xtitle="cov(dxy, dsz)", adjustMarginRight=0.02, **_commonLabelSize),
868  Plot("diffCovDxyDszStatus", **_commonStatus),
869  Plot("diffCovDxyDszUnderOverFlowSign", xtitle="cov(dxy, dsz)", **_common),
870  Plot("diffCovDszDsz", xtitle="cov(dsz, dsz)", adjustMarginRight=0.02, **_commonLabelSize),
871  Plot("diffCovDszDszStatus", **_commonStatus),
872  Plot("diffCovDszDszUnderOverFlowSign", xtitle="cov(dsz, dsz)", **_common),
873 ],
874  ncols=3, legendDy=_legendDy_4rows
875 )
876 
877 _common["xlabelsize"] = 16
878 _packedCandidateVertex = PlotGroup("vertex", [
879  Plot("diffVx", xtitle="Reference point x", **_common),
880  Plot("diffVy", xtitle="Reference point y", **_common),
881  Plot("diffVz", xtitle="Reference point z", **_common),
882 ],
883  legendDy=_legendDy_2rows
884 )
885 
886 _common["adjustMarginRight"] = 0.05
887 _packedCandidateKinematics = PlotGroup("kinematics", [
888  Plot("diffPt", xtitle="p_{T}", **_common),
889  Plot("diffPtError", xtitle="p_{T} error", **_common),
890  Plot("diffEta", xtitle="#eta", **_common),
891  Plot("diffEtaError", xtitle="#eta error", **_common),
892  Plot("diffPhi", xtitle="#phi", **_common),
893 ])
894 
895 class TrackingPlotFolder(PlotFolder):
896  def __init__(self, *args, **kwargs):
897  self._fallbackRefFiles = kwargs.pop("fallbackRefFiles", [])
898  PlotFolder.__init__(self, *args, **kwargs)
899 
900  def translateSubFolder(self, dqmSubFolderName):
901  spl = dqmSubFolderName.split("_")
902  if len(spl) != 2:
903  return None
904  collName = spl[0]
905  return _mapCollectionToAlgoQuality(collName)
906 
907  def iterSelectionName(self, plotFolderName, translatedDqmSubFolder):
908  (algoOrig, quality) = translatedDqmSubFolder
909 
910  for fallback in [lambda n: n]+self._fallbackRefFiles:
911  algo = fallback(algoOrig)
912 
913  ret = ""
914  if plotFolderName != "":
915  ret += "_"+plotFolderName
916  if quality != "":
917  ret += "_"+quality
918  if not (algo == "ootb" and quality != ""):
919  ret += "_"+algo
920  yield ret
921 
922  def limitSubFolder(self, limitOnlyTo, translatedDqmSubFolder):
923  """Return True if this subfolder should be processed
924 
925  Arguments:
926  limitOnlyTo -- Function '(algo, quality) -> bool'
927  translatedDqmSubFolder -- Return value of translateSubFolder
928  """
929  (algo, quality) = translatedDqmSubFolder
930  return limitOnlyTo(algo, quality)
931 
932  # track-specific hack
933  def isAlgoIterative(self, algo):
934  return algo not in _possibleTrackingNonIterationColls
935 
936 class TrackingSummaryTable:
937  class GeneralTracks: pass
938  class GeneralTracksPt09: pass
939  class HighPurity: pass
940  class HighPurityPt09: pass
941  class BTVLike: pass
942  class AK4PFJets: pass
943  class Pixel: pass
944  class PixelPt09: pass
945 
946  def __init__(self, section, collection=GeneralTracks):
947  self._collection = collection
948  self._purpose = PlotPurpose.TrackingSummary
949  self._page = "summary"
950  self._section = section
951 
952  def getPurpose(self):
953  return self._purpose
954 
955  def getPage(self):
956  return self._page
957 
958  def getSection(self, dqmSubFolder):
959  return self._section
960 
961  def create(self, tdirectory):
962  def _getAlgoQuality(data, algo, quality):
963  for label, value in six.iteritems(data):
964  (a, q) = _mapCollectionToAlgoQuality(label)
965  if a == algo and q == quality:
966  return value[0] # value is (value, uncertainty) tuple
967  return None
968  def _getN(hname):
969  h = tdirectory.Get(hname)
970  if not h:
971  return None
972  data = plotting._th1ToOrderedDict(h)
973  if self._collection == TrackingSummaryTable.GeneralTracks:
974  return _getAlgoQuality(data, "ootb", "")
975  elif self._collection == TrackingSummaryTable.GeneralTracksPt09:
976  return _getAlgoQuality(data, "ootb", "Pt09")
977  elif self._collection == TrackingSummaryTable.HighPurity:
978  return _getAlgoQuality(data, "ootb", "highPurity")
979  elif self._collection == TrackingSummaryTable.HighPurityPt09:
980  return _getAlgoQuality(data, "ootb", "highPurityPt09")
981  elif self._collection == TrackingSummaryTable.BTVLike:
982  return _getAlgoQuality(data, "btvLike", "")
983  elif self._collection == TrackingSummaryTable.AK4PFJets:
984  return _getAlgoQuality(data, "ak4PFJets", "")
985  elif self._collection == TrackingSummaryTable.Pixel:
986  return _getAlgoQuality(data, "pixel", "")
987  elif self._collection == TrackingSummaryTable.PixelPt09:
988  return _getAlgoQuality(data, "pixel", "Pt09")
989  else:
990  raise Exception("Collection not recognized, %s" % str(self._collection))
991  def _formatOrNone(num, func):
992  if num is None:
993  return None
994  return func(num)
995 
996  n_tps = _formatOrNone(_getN("num_simul_coll"), int)
997  n_m_tps = _formatOrNone(_getN("num_assoc(simToReco)_coll"), int)
998 
999  n_tracks = _formatOrNone(_getN("num_reco_coll"), int)
1000  n_true = _formatOrNone(_getN("num_assoc(recoToSim)_coll"), int)
1001  if n_tracks is not None and n_true is not None:
1002  n_fake = n_tracks-n_true
1003  else:
1004  n_fake = None
1005  n_pileup = _formatOrNone(_getN("num_pileup_coll"), int)
1006  n_duplicate = _formatOrNone(_getN("num_duplicate_coll"), int)
1007 
1008  eff = _formatOrNone(_getN("effic_vs_coll"), lambda n: "%.4f" % n)
1009  eff_nopt = _formatOrNone(_getN("effic_vs_coll_allPt"), lambda n: "%.4f" % n)
1010  fake = _formatOrNone(_getN("fakerate_vs_coll"), lambda n: "%.4f" % n)
1011  duplicate = _formatOrNone(_getN("duplicatesRate_coll"), lambda n: "%.4f" % n)
1012 
1013  ret = [eff, n_tps, n_m_tps,
1014  eff_nopt, fake, duplicate,
1015  n_tracks, n_true, n_fake, n_pileup, n_duplicate]
1016  if ret.count(None) == len(ret):
1017  return None
1018  return ret
1019 
1020  def headers(self):
1021  return [
1022  "Efficiency",
1023  "Number of TrackingParticles (after cuts)",
1024  "Number of matched TrackingParticles",
1025  "Efficiency (w/o pT cut)",
1026  "Fake rate",
1027  "Duplicate rate",
1028  "Number of tracks",
1029  "Number of true tracks",
1030  "Number of fake tracks",
1031  "Number of pileup tracks",
1032  "Number of duplicate tracks"
1033  ]
1034 
1035 # Provide a "PlotGroup" interface, but provide a html page
1036 class TrackingSeedingLayerTable:
1037  def __init__(self, fileName, plots, titles, isRate, **kwargs):
1038  self._plots = plots
1039  self._titles = titles
1040  self._fileName = fileName
1041  self._format = "%.4g" if isRate else "%d"
1042 
1043  if len(plots) != len(titles):
1044  raise Exception("Number of plots (%d) has to be the same as number of titles (%d)" % (len(plots), len(titles)))
1045 
1046  def _set(attr, default):
1047  setattr(self, "_"+attr, kwargs.get(attr, default))
1048 
1049  _set("onlyForPileup", False)
1050 
1051  def onlyForPileup(self):
1052  """Return True if the PlotGroup is intended only for pileup samples"""
1053  return self._onlyForPileup
1054 
1055  def create(self, tdirectoryNEvents, requireAllHistograms=False):
1056  # [plot][histo]
1057  for plot in self._plots:
1058  plot.create(tdirectoryNEvents, requireAllHistograms)
1059 
1060  def draw(self, legendLabels, prefix=None, directory="", *args, **kwargs):
1061  # Do not make the table if it would be empty
1062  onlyEmptyPlots = True
1063  for plot in self._plots:
1064  if not plot.isEmpty():
1065  onlyEmptyPlots = False
1066  break
1067  if onlyEmptyPlots:
1068  return []
1069 
1070  haveShortLabels = False
1071  legendLabels = legendLabels[:]
1072  if max(map(len, legendLabels)) > 20:
1073  haveShortLabels = True
1074  labels_short = [str(chr(ord('A')+i)) for i in range(len(legendLabels))]
1075  for i, ls in enumerate(labels_short):
1076  legendLabels[i] = "%s: %s" % (ls, legendLabels[i])
1077  else:
1078  labels_short = legendLabels
1079 
1080  content = [
1081  '<html>',
1082  ' <body>',
1083  ' <table border="1">',
1084  ' <tr>',
1085  ]
1086 
1087 
1088  histos_linear = []
1089  histos_index = []
1090  labels = []
1091  for plot, title in zip(self._plots, self._titles):
1092  h_tmp = []
1093  l_tmp = []
1094  for h, l in zip(plot._histograms, labels_short):
1095  if h is not None:
1096  h_tmp.append(len(histos_linear))
1097  histos_linear.append(h)
1098  l_tmp.append(l)
1099 
1100  if len(h_tmp) > 0:
1101  histos_index.append(h_tmp)
1102  labels.append(l_tmp)
1103  content.extend([
1104  ' <td></td>',
1105  ' <td colspan="%d">%s</td>' % (len(h_tmp), title),
1106  ])
1107 
1108  if len(histos_linear) == 0:
1109  return []
1110 
1111  content.extend([
1112  ' </tr>',
1113  ' <tr>',
1114  ])
1115 
1116  xbinlabels = plotting._mergeBinLabelsX(histos_linear)
1117  histos_linear = plotting._th1IncludeOnlyBins(histos_linear, xbinlabels)
1118  if len(histos_linear) == 0:
1119  return []
1120  (histos_linear_new, xbinlabels) = plotting._th1RemoveEmptyBins(histos_linear, xbinlabels)
1121  # in practice either all histograms are returned, or none, but let's add a check anyway
1122  if len(histos_linear_new) > 0 and len(histos_linear_new) != len(histos_linear):
1123  raise Exception("This should never happen. len(histos_linear_new) %d != len(histos_linear) %d" % (len(histos_linear_new), len(histos_linear)))
1124  histos_linear = histos_linear_new
1125  if len(histos_linear) == 0:
1126  return []
1127 
1128  data = [ [h.GetBinContent(i) for i in range(1, h.GetNbinsX()+1)] for h in histos_linear]
1129  table = html.Table(["dummy"]*len(histos_linear), xbinlabels, data, None, None, None)
1130  data = table.tableAsRowColumn()
1131 
1132  for labs in labels:
1133  content.append(' <td></td>')
1134  content.extend([' <td>%s</td>' % lab for lab in labs])
1135  content.extend([
1136  ' </tr>',
1137  ])
1138 
1139  for irow, row in enumerate(data):
1140  content.extend([
1141  ' <tr>',
1142  ' <td>%s</td>' % table.rowHeaders()[irow]
1143  ])
1144 
1145  for hindices in histos_index:
1146  for hindex in hindices:
1147  item = row[hindex]
1148  formatted = self._format%item if item is not None else ""
1149  content.append(' <td align="right">%s</td>' % formatted)
1150  content.append(' <td></td>')
1151  del content[-1]
1152  content.append(' </tr>')
1153 
1154  content.append(' </table>')
1155  if haveShortLabels:
1156  for lab in legendLabels:
1157  content.append(' %s<br/>' % lab)
1158 
1159  content.extend([
1160  ' </body>',
1161  '<html>'
1162  ])
1163 
1164  name = self._fileName
1165  if prefix is not None:
1166  name = prefix+name
1167  name += ".html"
1168  name = os.path.join(directory, name)
1169 
1170  with open(name, "w") as f:
1171  for line in content:
1172  f.write(line)
1173  f.write("\n")
1174  return [name]
1175 
1176 _dupandfakeSeedingTable = TrackingSeedingLayerTable("dupandfakeSeeding", [p.clone() for p in _dupandfakeSeedingPlots],
1177  ["Fake rate", "Duplicate rate", "Pileup rate"], isRate=True)
1178 _extDistSeedingTable = TrackingSeedingLayerTable("distSeeding", [p.clone() for p in _extDistSeedingPlots],
1179  ["All tracks", "True tracks", "Fake tracks", "Duplicate tracks"], isRate=False)
1180 
1181 def _trackingFolders(lastDirName="Track"):
1182  return [
1183  "DQMData/Run 1/Tracking/Run summary/"+lastDirName,
1184  "DQMData/Tracking/"+lastDirName,
1185  "DQMData/Run 1/RecoTrackV/Run summary/"+lastDirName,
1186  "DQMData/RecoTrackV/"+lastDirName,
1187  ]
1188 
1189 _simBasedPlots = [
1190  _effandfakePtEtaPhi,
1191  _effandfakeDxyDzBS,
1192  _effandfakeDxyDzPV,
1193  _effandfakeHitsLayers,
1194  _effandfakePos,
1195  _effandfakeDeltaRPU,
1196  _duplicateAlgo,
1197 ]
1198 _recoBasedPlots = [
1199  _dupandfakePtEtaPhi,
1200  _dupandfakeDxyDzBS,
1201  _dupandfakeDxyDzPV,
1202  _dupandfakeHitsLayers,
1203  _dupandfakePos,
1204  _dupandfakeDeltaRPU,
1205  _dupandfakeChi2Seeding,
1206  _dupandfakeSeedingTable,
1207  _pvassociation1,
1208  _pvassociation2,
1209  _dedx,
1210 # _chargemisid,
1211  _hitsAndPt,
1212  _pulls,
1213  _resolutionsEta,
1214  _resolutionsPhi,
1215  _resolutionsPt,
1216  _tuning,
1217 ]
1218 _seedingBuildingPlots = _simBasedPlots + [
1219  _dupandfakePtEtaPhi,
1220  _dupandfakeDxyDzBS,
1221  _dupandfakeDxyDzPV,
1222  _dupandfakeHitsLayers,
1223  _dupandfakePos,
1224  _dupandfakeDeltaRPU,
1225  _dupandfakeChi2Seeding,
1226  _dupandfakeSeedingTable,
1227  _hitsAndPt,
1228 ] + _makeMVAPlots(1) \
1229  + _makeMVAPlots(2) \
1230  + _makeMVAPlots(2, hp=True) \
1231  + _makeMVAPlots(3) \
1232  + _makeMVAPlots(3, hp=True)
1233 # add more if needed
1234 _buildingExtendedPlots = [
1235  _pulls,
1236  _resolutionsEta,
1237  _resolutionsPhi,
1238  _resolutionsPt,
1239  _tuning,
1240 ]
1241 _extendedPlots = [
1242  _extDistPtEtaPhi,
1243  _extDistDxyDzBS,
1244  _extDistDxyDzPV,
1245  _extDistHitsLayers,
1246  _extDistPos,
1247  _extDistDeltaR,
1248  _extDistChi2Seeding,
1249  _extDistSeedingTable,
1250  _extResidualEta,
1251  _extResidualPt,
1252  _extNrecVsNsim,
1253  _extHitsLayers,
1254  _extDistSimPtEtaPhi,
1255  _extDistSimDxyDzBS,
1256  _extDistSimDxyDzPV,
1257  _extDistSimHitsLayers,
1258  _extDistSimPos,
1259  _extDistSimDeltaR,
1260 ]
1261 _summaryPlots = [
1262  _summary,
1263  _summaryN,
1264  _summaryByOriginalAlgo,
1265  _summaryByOriginalAlgoN,
1266  _summaryByAlgoMask,
1267  _summaryByAlgoMaskN,
1268  _summaryPt09,
1269  _summaryPt09N,
1270 ]
1271 _summaryPlotsHp = [
1272  _summaryHp,
1273  _summaryNHp,
1274  _summaryByOriginalAlgoHp,
1275  _summaryByOriginalAlgoNHp,
1276  _summaryByAlgoMaskHp,
1277  _summaryByAlgoMaskNHp,
1278  _summaryPt09Hp,
1279  _summaryPt09NHp,
1280 ]
1281 _summaryPlotsSeeds = [
1282  _summarySeeds,
1283  _summarySeedsN,
1284 ]
1285 _packedCandidatePlots = [
1286  _packedCandidateFlow,
1287  _packedCandidateKinematics,
1288  _packedCandidateVertex,
1289  _packedCandidateImpactParameter1,
1290  _packedCandidateImpactParameter2,
1291  _packedCandidateCovarianceMatrix1,
1292  _packedCandidateCovarianceMatrix2,
1293  _packedCandidateHits,
1294  _packedCandidateHitsHitPattern,
1295  _packedCandidateLayers,
1296 ]
1297 plotter = Plotter()
1298 plotterExt = Plotter()
1299 def _appendTrackingPlots(lastDirName, name, algoPlots, onlyForPileup=False, onlyForElectron=False, onlyForConversion=False, onlyForBHadron=False, seeding=False, building=False, rawSummary=False, highPuritySummary=True):
1300  folders = _trackingFolders(lastDirName)
1301  # to keep backward compatibility, this set of plots has empty name
1302  limiters = dict(onlyForPileup=onlyForPileup, onlyForElectron=onlyForElectron, onlyForConversion=onlyForConversion, onlyForBHadron=onlyForBHadron)
1303  commonForTPF = dict(purpose=PlotPurpose.TrackingIteration, fallbackRefFiles=[
1304  _trackingRefFileFallbackSLHC_Phase1PU140
1305  ], **limiters)
1306  common = dict(fallbackDqmSubFolders=[
1307  _trackingSubFoldersFallbackSLHC_Phase1PU140,
1308  _trackingSubFoldersFallbackFromPV, _trackingSubFoldersFallbackConversion,
1309  _trackingSubFoldersFallbackPreSplitting])
1310  plotter.append(name, folders, TrackingPlotFolder(*algoPlots, **commonForTPF), **common)
1311  extendedPlots = []
1312  if building:
1313  extendedPlots.extend(_buildingExtendedPlots)
1314  extendedPlots.extend(_extendedPlots)
1315  plotterExt.append(name, folders, TrackingPlotFolder(*extendedPlots, **commonForTPF), **common)
1316 
1317  summaryName = ""
1318  if name != "":
1319  summaryName += name+"_"
1320  summaryName += "summary"
1321  summaryPlots = []
1322  if rawSummary:
1323  summaryPlots.extend([_summaryRaw, _summaryRawN])
1324  summaryPlots.extend(_summaryPlots)
1325 
1326  common = dict(loopSubFolders=False, purpose=PlotPurpose.TrackingSummary, page="summary",
1327  #numberOfEventsHistogram=_trackingNumberOfEventsHistogram, # FIXME
1328  **limiters)
1329  plotter.append(summaryName, folders,
1330  PlotFolder(*summaryPlots, section=name, **common))
1331  if highPuritySummary:
1332  plotter.append(summaryName+"_highPurity", folders,
1333  PlotFolder(*_summaryPlotsHp, section=name+"_highPurity" if name != "" else "highPurity", **common),
1334  fallbackNames=[summaryName]) # backward compatibility for release validation, the HP plots used to be in the same directory with all-track plots
1335  if seeding:
1336  plotter.append(summaryName+"_seeds", folders,
1337  PlotFolder(*_summaryPlotsSeeds, section=name+"_seeds", **common))
1338 
1339  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section=name))
1340  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section=name+"Pt09", collection=TrackingSummaryTable.GeneralTracksPt09))
1341  if highPuritySummary:
1342  sectionName = name+"_highPurity" if name != "" else "highPurity"
1343  plotter.appendTable(summaryName+"_highPurity", folders, TrackingSummaryTable(section=sectionName, collection=TrackingSummaryTable.HighPurity))
1344  plotter.appendTable(summaryName+"_highPurity", folders, TrackingSummaryTable(section=sectionName+"Pt09", collection=TrackingSummaryTable.HighPurityPt09))
1345  if name == "":
1346  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section="btvLike", collection=TrackingSummaryTable.BTVLike))
1347  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section="ak4PFJets", collection=TrackingSummaryTable.AK4PFJets))
1348 _appendTrackingPlots("Track", "", _simBasedPlots+_recoBasedPlots)
1349 _appendTrackingPlots("TrackTPPtLess09", "tpPtLess09", _simBasedPlots)
1350 _appendTrackingPlots("TrackTPEtaGreater2p7", "tpEtaGreater2p7", _simBasedPlots+_recoBasedPlots)
1351 _appendTrackingPlots("TrackAllTPEffic", "allTPEffic", _simBasedPlots, onlyForPileup=True)
1352 _appendTrackingPlots("TrackFromPV", "fromPV", _simBasedPlots+_recoBasedPlots, onlyForPileup=True)
1353 _appendTrackingPlots("TrackFromPVAllTP", "fromPVAllTP", _simBasedPlots+_recoBasedPlots, onlyForPileup=True)
1354 _appendTrackingPlots("TrackFromPVAllTP2", "fromPVAllTP2", _simBasedPlots+_recoBasedPlots, onlyForPileup=True)
1355 _appendTrackingPlots("TrackSeeding", "seeding", _seedingBuildingPlots, seeding=True)
1356 _appendTrackingPlots("TrackBuilding", "building", _seedingBuildingPlots, building=True)
1357 _appendTrackingPlots("TrackConversion", "conversion", _simBasedPlots+_recoBasedPlots, onlyForConversion=True, rawSummary=True, highPuritySummary=False)
1358 _appendTrackingPlots("TrackGsf", "gsf", _simBasedPlots+_recoBasedPlots, onlyForElectron=True, rawSummary=True, highPuritySummary=False)
1359 _appendTrackingPlots("TrackBHadron", "bhadron", _simBasedPlots+_recoBasedPlots, onlyForBHadron=True)
1360 _appendTrackingPlots("TrackDisplaced", "displaced", _simBasedPlots+_recoBasedPlots)
1361 # Pixel tracks
1362 def _appendPixelTrackingPlots(lastDirName, name):
1363  _common = dict(purpose=PlotPurpose.Pixel, page="pixel")
1364  _folders = _trackingFolders(lastDirName)
1365 
1366  plotter.append(name, _folders, TrackingPlotFolder(*(_simBasedPlots+_recoBasedPlots), **_common))
1367  plotterExt.append(name, _folders, TrackingPlotFolder(*_extendedPlots, **_common))
1368 
1369  plotter.append(name+"_summary", _folders, PlotFolder(_summaryRaw, _summaryRawN, loopSubFolders=False, purpose=PlotPurpose.TrackingSummary, page="summary", section=name))
1370  plotter.append(name+"_summary", _folders, PlotFolder(_summaryRaw, _summaryRawN, loopSubFolders=False, purpose=PlotPurpose.TrackingSummary, page="summary", section=name+"Pt09"))
1371  plotter.appendTable(name+"_summary", _folders, TrackingSummaryTable(section=name, collection=TrackingSummaryTable.Pixel))
1372  plotter.appendTable(name+"_summary", _folders, TrackingSummaryTable(section=name+"Pt09", collection=TrackingSummaryTable.PixelPt09))
1373 _appendPixelTrackingPlots("PixelTrack", "pixel")
1374 _appendPixelTrackingPlots("PixelTrackFromPV", "pixelFromPV")
1375 _appendPixelTrackingPlots("PixelTrackFromPVAllTP", "pixelFromPVAllTP")
1376 _appendPixelTrackingPlots("PixelTrackBHadron", "pixelbhadron")
1377 
1378 
1379 # MiniAOD
1380 plotter.append("packedCandidate", _trackingFolders("PackedCandidate"),
1381  PlotFolder(*_packedCandidatePlots, loopSubFolders=False,
1382  purpose=PlotPurpose.MiniAOD, page="miniaod", section="PackedCandidate"))
1383 plotter.append("packedCandidateLostTracks", _trackingFolders("PackedCandidate/lostTracks"),
1384  PlotFolder(*_packedCandidatePlots, loopSubFolders=False,
1385  purpose=PlotPurpose.MiniAOD, page="miniaod", section="PackedCandidate (lostTracks)"))
1386 
1387 # HLT
1388 _hltFolder = [
1389  "DQMData/Run 1/HLT/Run summary/Tracking/ValidationWRTtp",
1390 ]
1391 plotterHLT = Plotter()
1392 plotterHLTExt = Plotter()
1393 _common = dict(purpose=PlotPurpose.HLT, page="hlt")
1394 plotterHLT.append("hlt", _hltFolder, TrackingPlotFolder(*(_simBasedPlots+_recoBasedPlots), **_common))
1395 plotterHLTExt.append("hlt", _hltFolder, TrackingPlotFolder(*_extendedPlots, **_common))
1396 
1397 # Timing
1398 class Iteration:
1399  def __init__(self, name, clusterMasking=None, seeding=None, building=None, fit=None, selection=None, other=[]):
1400  self._name = name
1401 
1402  def _set(param, name, modules):
1403  if param is not None:
1404  setattr(self, name, param)
1405  else:
1406  setattr(self, name, modules)
1407 
1408  _set(clusterMasking, "_clusterMasking", [self._name+"Clusters"])
1409  # it's fine to include e.g. quadruplets here also for pair
1410  # steps, as non-existing modules are just ignored
1411  _set(seeding, "_seeding", [self._name+"SeedingLayers", self._name+"TrackingRegions", self._name+"HitDoublets", self._name+"HitTriplets", self._name+"HitQuadruplets", self._name+"Seeds"])
1412  _set(building, "_building", [self._name+"TrackCandidates"])
1413  _set(fit, "_fit", [self._name+"Tracks"])
1414  _set(selection, "_selection", [self._name])
1415  self._other = other
1416 
1417  def name(self):
1418  return self._name
1419 
1420  def all(self):
1421  return self._clusterMasking+self._seeding+self._building+self._fit+self._selection+self._other
1422 
1423  def clusterMasking(self):
1424  return self._clusterMasking
1425 
1426  def seeding(self):
1427  return self._seeding
1428 
1429  def building(self):
1430  return self._building
1431 
1432  def fit(self):
1433  return self._fit
1434 
1435  def selection(self):
1436  return self._selection
1437 
1438  def other(self):
1439  return self._other
1440 
1441  def modules(self):
1442  return [("ClusterMask", self.clusterMasking()),
1443  ("Seeding", self.seeding()),
1444  ("Building", self.building()),
1445  ("Fit", self.fit()),
1446  ("Selection", self.selection()),
1447  ("Other", self.other())]
1448 
1449 
1450 _iterations = [
1451  Iteration("initialStepPreSplitting", clusterMasking=[],
1452  seeding=["initialStepSeedLayersPreSplitting",
1453  "initialStepTrackingRegionsPreSplitting",
1454  "initialStepHitDoubletsPreSplitting",
1455  "initialStepHitTripletsPreSplitting",
1456  "initialStepHitQuadrupletsPreSplitting",
1457  "initialStepSeedsPreSplitting"],
1458  building=["initialStepTrackCandidatesPreSplitting"],
1459  fit=["initialStepTracksPreSplitting"],
1460  other=["firstStepPrimaryVerticesPreSplitting",
1461  "initialStepTrackRefsForJetsPreSplitting",
1462  "caloTowerForTrkPreSplitting",
1463  "ak4CaloJetsForTrkPreSplitting",
1464  "jetsForCoreTrackingPreSplitting",
1465  "siPixelClusters",
1466  "siPixelRecHits",
1467  "MeasurementTrackerEvent",
1468  "siPixelClusterShapeCache"]),
1469  Iteration("initialStep", clusterMasking=[],
1470  selection=["initialStepClassifier1",
1471  "initialStepClassifier2",
1472  "initialStepClassifier3",
1473  "initialStep",
1474  "initialStepSelector"],
1475  building=["initialStepTrackCandidatesMkFitInput",
1476  "initialStepTrackCandidatesMkFit",
1477  "initialStepTrackCandidates"],
1478  other=["firstStepPrimaryVerticesUnsorted",
1479  "initialStepTrackRefsForJets",
1480  "caloTowerForTrk",
1481  "ak4CaloJetsForTrk",
1482  "firstStepPrimaryVertices"]),
1483  Iteration("highPtTripletStep",
1484  selection=["highPtTripletStepClassifier1",
1485  "highPtTripletStepClassifier2",
1486  "highPtTripletStepClassifier3",
1487  "highPtTripletStep",
1488  "highPtTripletStepSelector"]),
1489  Iteration("detachedQuadStep",
1490  selection=["detachedQuadStepClassifier1",
1491  "detachedQuadStepClassifier2",
1492  "detachedQuadStep",
1493  "detachedQuadStepSelector"]),
1494  Iteration("detachedTripletStep",
1495  selection=["detachedTripletStepClassifier1",
1496  "detachedTripletStepClassifier2",
1497  "detachedTripletStep",
1498  "detachedTripletStepSelector"]),
1499  Iteration("lowPtQuadStep",
1500  selection=["lowPtQuadStepClassifier1",
1501  "lowPtQuadStepClassifier2",
1502  "lowPtQuadStep",
1503  "lowPtQuadStepSelector"]),
1504  Iteration("lowPtTripletStep",
1505  selection=["lowPtTripletStepClassifier1",
1506  "lowPtTripletStepClassifier2",
1507  "lowPtTripletStep",
1508  "lowPtTripletStepSelector"]),
1509  Iteration("pixelPairStep",
1510  seeding=["pixelPairStepSeedLayers",
1511  "pixelPairStepSeedLayersB",
1512  "pixelPairStepSeedLayersC",
1513  "pixelPairStepTrackingRegions",
1514  "pixelPairStepTrackingRegionsB",
1515  "pixelPairStepTrackingRegionsC",
1516  "pixelPairStepTrackingRegionsSeedLayersB",
1517  "pixelPairStepHitDoublets",
1518  "pixelPairStepHitDoubletsB",
1519  "pixelPairStepHitDoubletsC",
1520  "pixelPairStepSeedsA",
1521  "pixelPairStepSeedsB",
1522  "pixelPairStepSeedsC",
1523  "pixelPairStepSeeds",],
1524  selection=["pixelPairStep",
1525  "pixelPairStepSelector"]),
1526  Iteration("mixedTripletStep",
1527  seeding=["mixedTripletStepSeedLayersA",
1528  "mixedTripletStepSeedLayersB",
1529  "mixedTripletStepTrackingRegionsA",
1530  "mixedTripletStepTrackingRegionsB",
1531  "mixedTripletStepHitDoubletsA",
1532  "mixedTripletStepHitDoubletsB",
1533  "mixedTripletStepHitTripletsA",
1534  "mixedTripletStepHitTripletsB",
1535  "mixedTripletStepSeedsA",
1536  "mixedTripletStepSeedsB",
1537  "mixedTripletStepSeeds"],
1538  selection=["mixedTripletStepClassifier1",
1539  "mixedTripletStepClassifier2",
1540  "mixedTripletStep",
1541  "mixedTripletStepSelector"]),
1542  Iteration("pixelLessStep",
1543  selection=["pixelLessStepClassifier1",
1544  "pixelLessStepClassifier2",
1545  "pixelLessStep",
1546  "pixelLessStepSelector"]),
1547  Iteration("tobTecStep",
1548  seeding=["tobTecStepSeedLayersTripl",
1549  "tobTecStepSeedLayersPair",
1550  "tobTecStepTrackingRegionsTripl",
1551  "tobTecStepTrackingRegionsPair",
1552  "tobTecStepHitDoubletsTripl",
1553  "tobTecStepHitDoubletsPair",
1554  "tobTecStepHitTripletsTripl",
1555  "tobTecStepSeedsTripl",
1556  "tobTecStepSeedsPair",
1557  "tobTecStepSeeds"],
1558  selection=["tobTecStepClassifier1",
1559  "tobTecStepClassifier2",
1560  "tobTecStep",
1561  "tobTecStepSelector"]),
1562  Iteration("displacedGeneralStep",
1563  seeding=["displacedGeneralStepSeedLayers",
1564  "displacedGeneralStepTrackingRegions",
1565  "displacedGeneralStepHitDoublets",
1566  "displacedGeneralStepHitTriplets",
1567  "displacedGeneralStepSeeds"],
1568  selection=["displacedGeneralStepClassifier1",
1569  "displacedGeneralStepClassifier2",
1570  "displacedGeneralStep",
1571  "displacedGeneralStepSelector"]),
1572  Iteration("jetCoreRegionalStep",
1573  clusterMasking=[],
1574  other=["jetsForCoreTracking",
1575  "firstStepGoodPrimaryVertices",
1576  ]),
1577  Iteration("muonSeededSteps",
1578  clusterMasking=[],
1579  seeding=["muonSeededSeedsInOut",
1580  "muonSeededSeedsOutIn"],
1581  building=["muonSeededTrackCandidatesInOut",
1582  "muonSeededTrackCandidatesOutIn"],
1583  fit=["muonSeededTracksInOut",
1584  "muonSeededTracksOutIn"],
1585  selection=["muonSeededTracksInOutClassifier",
1586  "muonSeededTracksInOutSelector",
1587  "muonSeededTracksOutIntClassifier",
1588  "muonSeededTracksOutIntSelector"],
1589 # other=["earlyMuons"]
1590  ),
1591  Iteration("duplicateMerge",
1592  clusterMasking=[], seeding=[],
1593  building=["duplicateTrackCandidates"],
1594  fit=["mergedDuplicateTracks"],
1595  selection=["duplicateTrackClassifier"]),
1596  Iteration("generalTracks",
1597  clusterMasking=[], seeding=[], building=[], fit=[], selection=[],
1598  other=["preDuplicateMergingGeneralTracks",
1599  "generalTracks"]),
1600  Iteration("ConvStep",
1601  clusterMasking=["convClusters"],
1602  seeding=["convLayerPairs",
1603  "photonConvTrajSeedFromSingleLeg"],
1604  building=["convTrackCandidates"],
1605  fit=["convStepTracks"],
1606  selection=["convStepSelector"]),
1607  Iteration("Other", clusterMasking=[], seeding=[], building=[], fit=[], selection=[],
1608  other=["trackerClusterCheckPreSplitting",
1609  "trackerClusterCheck"]),
1610 ]
1611 
1612 def _iterModuleMap(includeConvStep=True, onlyConvStep=False):
1613  iterations = _iterations
1614  if not includeConvStep:
1615  iterations = [i for i in iterations if i.name() != "ConvStep"]
1616  if onlyConvStep:
1617  iterations = [i for i in iterations if i.name() == "ConvStep"]
1618  return collections.OrderedDict([(i.name(), i.all()) for i in iterations])
1619 def _stepModuleMap():
1620  def getProp(prop):
1621  ret = []
1622  for i in _iterations:
1623  if i.name() == "ConvStep":
1624  continue
1625  ret.extend(getattr(i, prop)())
1626  return ret
1627 
1628  return collections.OrderedDict([
1629  ("ClusterMask", getProp("clusterMasking")),
1630  ("Seeding", getProp("seeding")),
1631  ("Building", getProp("building")),
1632  ("Fitting", getProp("fit")),
1633  ("Selection", getProp("selection")),
1634  ("Other", getProp("other"))
1635  ])
1636 
1637 class TimePerEventPlot:
1638  def __init__(self, name, timeHisto):
1639  self._name = name
1640  self._timeHisto = timeHisto
1641  self._eventsHisto = "path time_real"
1642  self._cache = {}
1643 
1644  def __str__(self):
1645  return self._name
1646 
1647  def _create(self, tdirectory):
1648  timeTh1 = plotting._getOrCreateObject(tdirectory, self._timeHisto)
1649  if timeTh1 is None:
1650  return None
1651 
1652  eventsTh1 = plotting._getOrCreateObject(tdirectory, self._eventsHisto)
1653  if eventsTh1 is None:
1654  return None
1655  nevents = eventsTh1.GetEntries()
1656  if nevents == 0:
1657  return None
1658 
1659  ret = timeTh1.Clone(self._name)
1660  xaxis = ret.GetXaxis()
1661  for i in range(1, ret.GetNbinsX()+1):
1662  ret.SetBinContent(i, ret.GetBinContent(i)/nevents)
1663  ret.SetBinError(i, ret.GetBinError(i)/nevents)
1664  xaxis.SetBinLabel(i, xaxis.GetBinLabel(i).replace(" (unscheduled)", ""))
1665  return ret
1666 
1667  def create(self, tdirectory):
1668  path = tdirectory.GetPath()
1669  if path not in self._cache:
1670  self._cache[path] = self._create(tdirectory)
1671  return self._cache[path]
1672 
1673 class TimePerTrackPlot:
1674  def __init__(self, name, timeHisto, selectedTracks=False):
1675  self._name = name
1676  self._timeHisto = timeHisto
1677  self._selectedTracks = selectedTracks
1678 
1679  def __str__(self):
1680  return self._name
1681 
1682  def _getDirectory(self, tfile):
1683  for dirName in _trackingFolders():
1684  tdir = tfile.Get(dirName)
1685  if tdir != None:
1686  return tdir
1687  return None
1688 
1689  def create(self, tdirectory):
1690  timeTh1 = plotting._getOrCreateObject(tdirectory, self._timeHisto)
1691  if timeTh1 is None:
1692  return None
1693 
1694  # this is bit of a hack, but as long as it is needed only
1695  # here, I won't invest in better solution
1696  tfile = tdirectory.GetFile()
1697  trkDir = self._getDirectory(tfile)
1698  if trkDir is None:
1699  return None
1700 
1701  iterMap = copy.copy(_collLabelMapHp)
1702  del iterMap["generalTracks"]
1703  del iterMap["jetCoreRegionalStep"] # this is expensive per track on purpose
1704  if self._selectedTracks:
1705  renameBin = lambda bl: _summaryBinRename(bl, highPurity=True, byOriginalAlgo=False, byAlgoMask=True, ptCut=False, seeds=False)
1706  else:
1707  renameBin = lambda bl: _summaryBinRename(bl, highPurity=False, byOriginalAlgo=False, byAlgoMask=False, ptCut=False, seeds=False)
1708  recoAB = AggregateBins("tmp", "num_reco_coll", mapping=iterMap,ignoreMissingBins=True, renameBin=renameBin)
1709  h_reco_per_iter = recoAB.create(trkDir)
1710  if h_reco_per_iter is None:
1711  return None
1712  values = {}
1713  for i in range(1, h_reco_per_iter.GetNbinsX()+1):
1714  values[h_reco_per_iter.GetXaxis().GetBinLabel(i)] = h_reco_per_iter.GetBinContent(i)
1715 
1716 
1717  result = []
1718  for i in range(1, timeTh1.GetNbinsX()+1):
1719  iterName = timeTh1.GetXaxis().GetBinLabel(i)
1720  if iterName in values:
1721  ntrk = values[iterName]
1722  result.append( (iterName,
1723  timeTh1.GetBinContent(i)/ntrk if ntrk > 0 else 0,
1724  timeTh1.GetBinError(i)/ntrk if ntrk > 0 else 0) )
1725 
1726  if len(result) == 0:
1727  return None
1728 
1729  res = ROOT.TH1F(self._name, self._name, len(result), 0, len(result))
1730  for i, (label, value, error) in enumerate(result):
1731  res.GetXaxis().SetBinLabel(i+1, label)
1732  res.SetBinContent(i+1, value)
1733  res.SetBinError(i+1, error)
1734 
1735  return res
1736 
1737 class TrackingIterationOrder:
1738  def __init__(self):
1739  self._cache = {}
1740 
1741  def _findOrder(self, f):
1742  h = f.Get(_trackingIterationOrderHistogram)
1743  if not h:
1744  return None
1745  xaxis = h.GetXaxis()
1746  def _edit(s):
1747  # remove "Tracks" from the track producer name to get the iteration name
1748  # muonSeeded iterations do not have "Step" in the producer name, so add it here
1749  return s.replace("Tracks", "").replace("muonSeeded", "muonSeededStep")
1750  return [_edit(xaxis.GetBinLabel(i)) for i in range(1, h.GetNbinsX()+1)]
1751 
1752  def __call__(self, tdirectory, labels):
1753  ret = list(range(0, len(labels)))
1754  f = tdirectory.GetFile()
1755  if not f:
1756  return ret
1757 
1758  if not f.GetName() in self._cache:
1759  r = self._findOrder(f)
1760  if r is None:
1761  return ret
1762  self._cache[f.GetName()] = r
1763  order = self._cache[f.GetName()]
1764 
1765  # O(N^2) I know, but we're talking about O(10) elements...
1766  orderIndices = []
1767  for l in order:
1768  try:
1769  orderIndices.append(labels.index(l))
1770  except ValueError:
1771  pass
1772  ret = []
1773  for i, l in enumerate(labels):
1774  if l in order:
1775  try:
1776  found = orderIndices.index(i)
1777  if found == 0:
1778  ret.append(i)
1779  else:
1780  ret.append(orderIndices[0])
1781  except ValueError:
1782  ret.append(orderIndices[0])
1783  orderIndices.pop(0)
1784  else:
1785  ret.append(i)
1786  return ret
1787 
1788 _time_per_event_cpu = TimePerEventPlot("timePerEvent", "module_time_thread_total")
1789 _time_per_event_real = TimePerEventPlot("timePerEvent", "module_time_real_total")
1790 
1791 class TrackingTimingTable:
1792  def __init__(self):
1793  self._purpose = PlotPurpose.Timing
1794  self._page = "timing"
1795  self._section = "timing"
1796 
1797  def getPurpose(self):
1798  return self._purpose
1799 
1800  def getPage(self):
1801  return self._page
1802 
1803  def getSection(self, dqmSubFolder):
1804  return self._section
1805 
1806  def _getValues(self, tdirectory, histo):
1807  h = tdirectory.Get(histo)
1808  totalReco = None
1809  if h:
1810  totalReco = "%.1f" % h.Integral()
1811 
1812  creator = AggregateBins("iteration", histo, _iterModuleMap(includeConvStep=False), ignoreMissingBins=True)
1813  h = creator.create(tdirectory)
1814  totalTracking = None
1815  if h:
1816  totalTracking = "%.1f" % h.Integral()
1817 
1818  creator = AggregateBins("iteration", histo, _iterModuleMap(onlyConvStep=True), ignoreMissingBins=True)
1819  h = creator.create(tdirectory)
1820  totalConvStep = None
1821  if h:
1822  totalConvStep = "%.1f" % h.Integral()
1823 
1824  return [
1825  totalReco,
1826  totalTracking,
1827  totalConvStep,
1828  ]
1829 
1830  def create(self, tdirectory):
1831  cpuValues = self._getValues(tdirectory, _time_per_event_cpu)
1832  realValues = self._getValues(tdirectory, _time_per_event_real)
1833 
1834  return cpuValues + realValues
1835 
1836  def headers(self):
1837  return [
1838  "Average reco CPU time / event (ms)",
1839  "Average tracking (w/o convStep) CPU time / event (ms)",
1840  "Average convStep CPU time / event (ms)",
1841  "Average reco real time / event (ms)",
1842  "Average tracking (w/o convStep) real time / event (ms)",
1843  "Average convStep real time / event (ms)",
1844  ]
1845 
1846 _common = {
1847  "drawStyle": "P",
1848  "xbinlabelsize": 10,
1849  "xbinlabeloption": "d"
1850 }
1851 
1852 _iteration_reorder = TrackingIterationOrder()
1853 _time_per_iter_cpu = AggregateBins("iteration", _time_per_event_cpu, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder)
1854 _time_per_iter_real = AggregateBins("iteration", _time_per_event_real, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder)
1855 
1856 _timing_summaryCPU = PlotGroup("summaryCPU", [
1857  Plot(_time_per_iter_cpu,
1858  ytitle="Average CPU time (ms)", title="Average CPU time / event", legendDx=-0.4, **_common),
1859  Plot(AggregateBins("iteration_fraction", _time_per_event_cpu, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder),
1860  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1861  #
1862  Plot(AggregateBins("step", _time_per_event_cpu, _stepModuleMap(), ignoreMissingBins=True),
1863  ytitle="Average CPU time (ms)", title="Average CPU time / event", **_common),
1864  Plot(AggregateBins("step_fraction", _time_per_event_cpu, _stepModuleMap(), ignoreMissingBins=True),
1865  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1866  #
1867  Plot(TimePerTrackPlot("iteration_track", _time_per_iter_cpu, selectedTracks=False),
1868  ytitle="Average CPU time / built track (ms)", title="Average CPU time / built track", **_common),
1869  Plot(TimePerTrackPlot("iteration_trackhp", _time_per_iter_cpu, selectedTracks=True),
1870  ytitle="Average CPU time / selected track (ms)", title="Average CPU time / selected HP track by algoMask", **_common),
1871  ],
1872 )
1873 _timing_summaryReal = PlotGroup("summaryReal", [
1874  Plot(_time_per_iter_real,
1875  ytitle="Average real time (ms)", title="Average real time / event", legendDx=-0.4, **_common),
1876  Plot(AggregateBins("iteration_fraction", _time_per_event_real, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder),
1877  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1878  #
1879  Plot(AggregateBins("step", _time_per_event_real, _stepModuleMap(), ignoreMissingBins=True),
1880  ytitle="Average real time (ms)", title="Average real time / event", **_common),
1881  Plot(AggregateBins("step_fraction", _time_per_event_real, _stepModuleMap(), ignoreMissingBins=True),
1882  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1883  #
1884  Plot(TimePerTrackPlot("iteration_track", _time_per_iter_real, selectedTracks=False),
1885  ytitle="Average real time / built track (ms)", title="Average real time / built track", **_common),
1886  Plot(TimePerTrackPlot("iteration_trackhp", _time_per_iter_real, selectedTracks=True),
1887  ytitle="Average real time / selected track (ms)", title="Average real time / selected HP track by algoMask", **_common),
1888  ],
1889 )
1890 
1891 _timing_iterationsCPU = PlotGroup("iterationsCPU", [
1892  Plot(AggregateBins(i.name(), _time_per_event_cpu, collections.OrderedDict(i.modules()), ignoreMissingBins=True),
1893  ytitle="Average CPU time (ms)", title=i.name(), **_common)
1894  for i in _iterations
1895 ],
1896  ncols=4, legend=False
1897 )
1898 _timing_iterationsReal = PlotGroup("iterationsReal", [
1899  Plot(AggregateBins(i.name(), _time_per_event_real, collections.OrderedDict(i.modules()), ignoreMissingBins=True),
1900  ytitle="Average real time (ms)", title=i.name(), **_common)
1901  for i in _iterations
1902 ],
1903  ncols=4, legend=False
1904 )
1905 
1906 # TODO: to be updated to new FastTimerService format later
1907 #_pixelTiming = PlotGroup("pixelTiming", [
1908 # Plot(AggregateBins("pixel", "reconstruction_step_module_average", {"pixelTracks": ["pixelTracks"]}), ytitle="Average processing time [ms]", title="Average processing time / event", drawStyle="HIST")
1909 #])
1910 
1911 _timeFolders = [
1912 # "DQMData/Run 1/DQM/Run summary/TimerService/process RECO paths/path reconstruction_step",
1913  "DQMData/Run 1/DQM/Run summary/TimerService/process RECO paths/path prevalidation_step", # because of unscheduled, it's actually prevalidation_step that has all the tracking modules?
1914 ]
1915 timePlotter = Plotter()
1916 timePlotter.append("timing", _timeFolders, PlotFolder(
1917  _timing_summaryCPU,
1918  _timing_iterationsCPU,
1919  _timing_summaryReal,
1920  _timing_iterationsReal,
1921  # _pixelTiming,
1922  loopSubFolders=False, purpose=PlotPurpose.Timing, page="timing"
1923 ))
1924 timePlotter.appendTable("timing", _timeFolders, TrackingTimingTable())
1925 
1926 _common = {"stat": True, "normalizeToUnitArea": True, "drawStyle": "hist"}
1927 _tplifetime = PlotGroup("tplifetime", [
1928  Plot("TPlip", xtitle="TP lip", **_common),
1929  Plot("TPtip", xtitle="TP tip", **_common),
1930 ])
1931 
1932 tpPlotter = Plotter()
1933 tpPlotter.append("tp", [
1934  "DQMData/Run 1/Tracking/Run summary/TrackingMCTruth/TrackingParticle",
1935  "DQMData/Tracking/TrackingMCTruth/TrackingParticle",
1936 ], PlotFolder(
1937  _tplifetime,
1938 ))
trackingPlots.TrackingSeedingLayerTable._fileName
_fileName
Definition: trackingPlots.py:1040
trackingPlots.Iteration.clusterMasking
def clusterMasking(self)
Definition: trackingPlots.py:1423
trackingPlots._makeDistPlots
def _makeDistPlots(postfix, quantity, common={})
Definition: trackingPlots.py:108
trackingPlots.TimePerTrackPlot._selectedTracks
_selectedTracks
Definition: trackingPlots.py:1677
trackingPlots._trackingFolders
def _trackingFolders(lastDirName="Track")
Definition: trackingPlots.py:1181
trackingPlots.Iteration._other
_other
Definition: trackingPlots.py:1415
FastTimerService_cff.range
range
Definition: FastTimerService_cff.py:34
trackingPlots.TrackingSummaryTable.HighPurityPt09
Definition: trackingPlots.py:940
plotting.Plot
Definition: plotting.py:1696
trackingPlots.TrackingSummaryTable._purpose
_purpose
Definition: trackingPlots.py:948
trackingPlots.TimePerTrackPlot.create
def create(self, tdirectory)
Definition: trackingPlots.py:1689
trackingPlots.TrackingSummaryTable._collection
_collection
Definition: trackingPlots.py:947
trackingPlots.TimePerEventPlot._timeHisto
_timeHisto
Definition: trackingPlots.py:1640
plotting.PlotFolder
Definition: plotting.py:2551
trackingPlots.TimePerEventPlot._eventsHisto
_eventsHisto
Definition: trackingPlots.py:1641
plotting.FakeDuplicate
Definition: plotting.py:847
html.PlotPurpose.TrackingIteration
Definition: html.py:342
plotting._mergeBinLabelsX
def _mergeBinLabelsX(histos)
Definition: plotting.py:708
trackingPlots.TrackingPlotFolder.iterSelectionName
def iterSelectionName(self, plotFolderName, translatedDqmSubFolder)
Definition: trackingPlots.py:907
trackingPlots.Iteration.fit
def fit(self)
Definition: trackingPlots.py:1432
trackingPlots.TrackingSeedingLayerTable.create
def create(self, tdirectoryNEvents, requireAllHistograms=False)
Definition: trackingPlots.py:1055
trackingPlots.Iteration.other
def other(self)
Definition: trackingPlots.py:1438
trackingPlots.TrackingTimingTable._purpose
_purpose
Definition: trackingPlots.py:1793
trackingPlots._makeFakeDist
def _makeFakeDist(postfix)
Definition: trackingPlots.py:105
trackingPlots.TrackingSummaryTable.GeneralTracks
Definition: trackingPlots.py:937
trackingPlots._trackingSubFoldersFallbackPreSplitting
def _trackingSubFoldersFallbackPreSplitting(subfolder)
Definition: trackingPlots.py:576
trackingPlots.Iteration.seeding
def seeding(self)
Definition: trackingPlots.py:1426
trackingPlots.Iteration.name
def name(self)
Definition: trackingPlots.py:1417
trackingPlots.Iteration._name
_name
Definition: trackingPlots.py:1400
trackingPlots.TrackingTimingTable
Definition: trackingPlots.py:1791
trackingPlots.TrackingSeedingLayerTable.draw
def draw(self, legendLabels, prefix=None, directory="", *args, **kwargs)
Definition: trackingPlots.py:1060
trackingPlots.TrackingPlotFolder._fallbackRefFiles
_fallbackRefFiles
Definition: trackingPlots.py:897
trackingPlots.TimePerEventPlot.__init__
def __init__(self, name, timeHisto)
Definition: trackingPlots.py:1638
html.PlotPurpose.MiniAOD
Definition: html.py:345
html.PlotPurpose.HLT
Definition: html.py:347
trackingPlots.TrackingSummaryTable.getPage
def getPage(self)
Definition: trackingPlots.py:955
trackingPlots.TrackingSummaryTable._page
_page
Definition: trackingPlots.py:949
plotting.CutEfficiency
Definition: plotting.py:899
plotting.PlotOnSideGroup
Definition: plotting.py:2524
trackingPlots.TrackingSeedingLayerTable._format
_format
Definition: trackingPlots.py:1041
trackingPlots._stepModuleMap
def _stepModuleMap()
Definition: trackingPlots.py:1619
trackingPlots._makeDistSimPlots
def _makeDistSimPlots(postfix, quantity, common={})
Definition: trackingPlots.py:122
trackingPlots.Iteration.modules
def modules(self)
Definition: trackingPlots.py:1441
trackingPlots._summaryBinRename
def _summaryBinRename(binLabel, highPurity, byOriginalAlgo, byAlgoMask, ptCut, seeds)
Definition: trackingPlots.py:654
trackingPlots._iterModuleMap
def _iterModuleMap(includeConvStep=True, onlyConvStep=False)
Definition: trackingPlots.py:1612
trackingPlots.TimePerEventPlot._name
_name
Definition: trackingPlots.py:1639
html.PlotPurpose.Timing
Definition: html.py:346
trackingPlots._collhelper
def _collhelper(name)
Definition: trackingPlots.py:650
trackingPlots.TrackingPlotFolder
Definition: trackingPlots.py:895
trackingPlots.TrackingTimingTable.__init__
def __init__(self)
Definition: trackingPlots.py:1792
trackingPlots.TrackingSeedingLayerTable.__init__
def __init__(self, fileName, plots, titles, isRate, **kwargs)
Definition: trackingPlots.py:1037
html.Table
Definition: html.py:294
trackingPlots.TimePerTrackPlot.__init__
def __init__(self, name, timeHisto, selectedTracks=False)
Definition: trackingPlots.py:1674
trackingPlots.TimePerEventPlot.__str__
def __str__(self)
Definition: trackingPlots.py:1644
trackingPlots.TrackingTimingTable.getSection
def getSection(self, dqmSubFolder)
Definition: trackingPlots.py:1803
trackingPlots.TrackingPlotFolder.isAlgoIterative
def isAlgoIterative(self, algo)
Definition: trackingPlots.py:933
trackingPlots.TrackingPlotFolder.translateSubFolder
def translateSubFolder(self, dqmSubFolderName)
Definition: trackingPlots.py:900
trackingPlots.TrackingSeedingLayerTable._titles
_titles
Definition: trackingPlots.py:1039
trackingPlots.Iteration.building
def building(self)
Definition: trackingPlots.py:1429
plotting._th1IncludeOnlyBins
def _th1IncludeOnlyBins(histos, xbinlabels)
Definition: plotting.py:745
trackingPlots.TrackingSummaryTable.BTVLike
Definition: trackingPlots.py:941
trackingPlots._mapCollectionToAlgoQuality
def _mapCollectionToAlgoQuality(collName)
Definition: trackingPlots.py:586
str
#define str(s)
Definition: TestProcessor.cc:52
trackingPlots.TrackingPlotFolder.__init__
def __init__(self, *args, **kwargs)
Definition: trackingPlots.py:896
trackingPlots.TrackingIterationOrder._findOrder
def _findOrder(self, f)
Definition: trackingPlots.py:1741
trackingPlots.Iteration.all
def all(self)
Definition: trackingPlots.py:1420
html.PlotPurpose.Pixel
Definition: html.py:348
html.PlotPurpose.TrackingSummary
Definition: html.py:343
plotting._th1RemoveEmptyBins
def _th1RemoveEmptyBins(histos, xbinlabels)
Definition: plotting.py:608
plotting.Plotter
Definition: plotting.py:2972
trackingPlots.TrackingSummaryTable
Definition: trackingPlots.py:936
trackingPlots.TrackingSummaryTable.Pixel
Definition: trackingPlots.py:943
trackingPlots.TrackingIterationOrder.__init__
def __init__(self)
Definition: trackingPlots.py:1738
trackingPlots._minMaxResidual
def _minMaxResidual(ma)
Definition: trackingPlots.py:46
trackingPlots._trackingSubFoldersFallbackSLHC_Phase1PU140
def _trackingSubFoldersFallbackSLHC_Phase1PU140(subfolder)
Definition: trackingPlots.py:546
plotting.Subtract
Definition: plotting.py:762
trackingPlots.TrackingSummaryTable.create
def create(self, tdirectory)
Definition: trackingPlots.py:961
trackingPlots.TrackingSeedingLayerTable._plots
_plots
Definition: trackingPlots.py:1038
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
trackingPlots.Iteration.__init__
def __init__(self, name, clusterMasking=None, seeding=None, building=None, fit=None, selection=None, other=[])
Definition: trackingPlots.py:1399
Exception
trackingPlots.TrackingTimingTable._section
_section
Definition: trackingPlots.py:1795
trackingPlots.TrackingIterationOrder
Definition: trackingPlots.py:1737
trackingPlots.TimePerEventPlot.create
def create(self, tdirectory)
Definition: trackingPlots.py:1667
trackingPlots.TimePerTrackPlot._timeHisto
_timeHisto
Definition: trackingPlots.py:1676
trackingPlots.TrackingIterationOrder.__call__
def __call__(self, tdirectory, labels)
Definition: trackingPlots.py:1752
trackingPlots.Iteration.selection
def selection(self)
Definition: trackingPlots.py:1435
trackingPlots._trackingSubFoldersFallbackConversion
def _trackingSubFoldersFallbackConversion(subfolder)
Definition: trackingPlots.py:574
trackingPlots._appendTrackingPlots
def _appendTrackingPlots(lastDirName, name, algoPlots, onlyForPileup=False, onlyForElectron=False, onlyForConversion=False, onlyForBHadron=False, seeding=False, building=False, rawSummary=False, highPuritySummary=True)
Definition: trackingPlots.py:1299
trackingPlots.TrackingSummaryTable.PixelPt09
Definition: trackingPlots.py:944
trackingPlots.TrackingSummaryTable.HighPurity
Definition: trackingPlots.py:939
trackingPlots.TimePerTrackPlot._name
_name
Definition: trackingPlots.py:1675
TrackCollections2monitor_cff.func
func
Definition: TrackCollections2monitor_cff.py:359
trackingPlots.TrackingTimingTable.getPurpose
def getPurpose(self)
Definition: trackingPlots.py:1797
trackingPlots._trackingSubFoldersFallbackFromPV
def _trackingSubFoldersFallbackFromPV(subfolder)
Definition: trackingPlots.py:572
ComparisonHelper::zip
OutputIterator zip(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
Definition: L1TStage2CaloLayer1.h:41
plotting.ROC
Definition: plotting.py:1122
plotting._getOrCreateObject
def _getOrCreateObject(tdirectory, nameOrCreator)
Definition: plotting.py:58
plotting.Transform
Definition: plotting.py:810
trackingPlots.TrackingPlotFolder.limitSubFolder
def limitSubFolder(self, limitOnlyTo, translatedDqmSubFolder)
Definition: trackingPlots.py:922
trackingPlots.TrackingSummaryTable.headers
def headers(self)
Definition: trackingPlots.py:1020
trackingPlots.TimePerEventPlot._create
def _create(self, tdirectory)
Definition: trackingPlots.py:1647
trackingPlots._appendPixelTrackingPlots
def _appendPixelTrackingPlots(lastDirName, name)
Definition: trackingPlots.py:1362
plotting.AggregateBins
Definition: plotting.py:949
trackingPlots.TrackingSummaryTable.getSection
def getSection(self, dqmSubFolder)
Definition: trackingPlots.py:958
trackingPlots.TrackingTimingTable._page
_page
Definition: trackingPlots.py:1794
trackingPlots._makeMVAPlots
def _makeMVAPlots(num, hp=False)
Definition: trackingPlots.py:134
trackingPlots.TrackingSummaryTable.GeneralTracksPt09
Definition: trackingPlots.py:938
trackingPlots._trackingRefFileFallbackSLHC_Phase1PU140
def _trackingRefFileFallbackSLHC_Phase1PU140(path)
Definition: trackingPlots.py:560
pileupCalc.upper
upper
Definition: pileupCalc.py:214
trackingPlots.TrackingSeedingLayerTable
Definition: trackingPlots.py:1036
trackingPlots.TrackingTimingTable.create
def create(self, tdirectory)
Definition: trackingPlots.py:1830
trackingPlots.TimePerTrackPlot._getDirectory
def _getDirectory(self, tfile)
Definition: trackingPlots.py:1682
trackingPlots.TrackingTimingTable._getValues
def _getValues(self, tdirectory, histo)
Definition: trackingPlots.py:1806
plotting._th1ToOrderedDict
def _th1ToOrderedDict(th1, renameBin=None)
Definition: plotting.py:101
trackingPlots.TrackingTimingTable.getPage
def getPage(self)
Definition: trackingPlots.py:1800
trackingPlots.TimePerEventPlot
Definition: trackingPlots.py:1637
trackingPlots.fallback
fallback
Definition: trackingPlots.py:342
trackingPlots.TrackingSummaryTable._section
_section
Definition: trackingPlots.py:950
plotting.PlotEmpty
Definition: plotting.py:1676
trackingPlots.TimePerTrackPlot.__str__
def __str__(self)
Definition: trackingPlots.py:1679
genParticles_cff.map
map
Definition: genParticles_cff.py:11
trackingPlots._constructSummary
def _constructSummary(mapping=None, highPurity=False, byOriginalAlgo=False, byAlgoMask=False, ptCut=False, seeds=False, midfix="")
Definition: trackingPlots.py:689
trackingPlots.TimePerTrackPlot
Definition: trackingPlots.py:1673
trackingPlots.TrackingIterationOrder._cache
_cache
Definition: trackingPlots.py:1739
trackingPlots.TrackingSeedingLayerTable.onlyForPileup
def onlyForPileup(self)
Definition: trackingPlots.py:1051
trackingPlots.TrackingSummaryTable.__init__
def __init__(self, section, collection=GeneralTracks)
Definition: trackingPlots.py:946
trackingPlots._makeFakeDupPileupPlots
def _makeFakeDupPileupPlots(postfix, quantity, unit="", xquantity="", xtitle=None, common={})
Definition: trackingPlots.py:87
trackingPlots.Iteration
Definition: trackingPlots.py:1398
trackingPlots.TimePerEventPlot._cache
_cache
Definition: trackingPlots.py:1642
trackingPlots.TrackingSummaryTable.AK4PFJets
Definition: trackingPlots.py:942
plotting.PlotGroup
Definition: plotting.py:2252
trackingPlots._makeEffFakeDupPlots
def _makeEffFakeDupPlots(postfix, quantity, unit="", common={}, effopts={}, fakeopts={})
Definition: trackingPlots.py:68
trackingPlots.TrackingSummaryTable.getPurpose
def getPurpose(self)
Definition: trackingPlots.py:952
python.rootplot.root2matplotlib.replace
def replace(string, replacements)
Definition: root2matplotlib.py:444
trackingPlots.TrackingTimingTable.headers
def headers(self)
Definition: trackingPlots.py:1836
Generated for CMSSW Reference Manual by doxygen 1.8.16