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