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