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 _buildingExtendedPlots = [
1227  _pulls,
1228  _resolutionsEta,
1229  _resolutionsPt,
1230  _tuning,
1231 ]
1232 _extendedPlots = [
1233  _extDistPtEtaPhi,
1234  _extDistDxyDzBS,
1235  _extDistDxyDzPV,
1236  _extDistHitsLayers,
1237  _extDistPosDeltaR,
1238  _extDistChi2Seeding,
1239  _extDistSeedingTable,
1240  _extResidualEta,
1241  _extResidualPt,
1242  _extNrecVsNsim,
1243  _extHitsLayers,
1244  _extDistSimPtEtaPhi,
1245  _extDistSimDxyDzBS,
1246  _extDistSimDxyDzPV,
1247  _extDistSimHitsLayers,
1248  _extDistSimPosDeltaR,
1249 ]
1250 _summaryPlots = [
1251  _summary,
1252  _summaryN,
1253  _summaryByOriginalAlgo,
1254  _summaryByOriginalAlgoN,
1255  _summaryByAlgoMask,
1256  _summaryByAlgoMaskN,
1257  _summaryPt09,
1258  _summaryPt09N,
1259 ]
1260 _summaryPlotsHp = [
1261  _summaryHp,
1262  _summaryNHp,
1263  _summaryByOriginalAlgoHp,
1264  _summaryByOriginalAlgoNHp,
1265  _summaryByAlgoMaskHp,
1266  _summaryByAlgoMaskNHp,
1267  _summaryPt09Hp,
1268  _summaryPt09NHp,
1269 ]
1270 _summaryPlotsSeeds = [
1271  _summarySeeds,
1272  _summarySeedsN,
1273 ]
1274 _packedCandidatePlots = [
1275  _packedCandidateFlow,
1276  _packedCandidateKinematics,
1277  _packedCandidateVertex,
1278  _packedCandidateImpactParameter1,
1279  _packedCandidateImpactParameter2,
1280  _packedCandidateCovarianceMatrix1,
1281  _packedCandidateCovarianceMatrix2,
1282  _packedCandidateHits,
1283  _packedCandidateHitsHitPattern,
1284  _packedCandidateLayers,
1285 ]
1286 plotter = Plotter()
1287 plotterExt = Plotter()
1288 def _appendTrackingPlots(lastDirName, name, algoPlots, onlyForPileup=False, onlyForElectron=False, onlyForConversion=False, onlyForBHadron=False, seeding=False, building=False, rawSummary=False, highPuritySummary=True):
1289  folders = _trackingFolders(lastDirName)
1290  # to keep backward compatibility, this set of plots has empty name
1291  limiters = dict(onlyForPileup=onlyForPileup, onlyForElectron=onlyForElectron, onlyForConversion=onlyForConversion, onlyForBHadron=onlyForBHadron)
1292  commonForTPF = dict(purpose=PlotPurpose.TrackingIteration, fallbackRefFiles=[
1293  _trackingRefFileFallbackSLHC_Phase1PU140
1294  ], **limiters)
1295  common = dict(fallbackDqmSubFolders=[
1296  _trackingSubFoldersFallbackSLHC_Phase1PU140,
1297  _trackingSubFoldersFallbackFromPV, _trackingSubFoldersFallbackConversion])
1298  plotter.append(name, folders, TrackingPlotFolder(*algoPlots, **commonForTPF), **common)
1299  extendedPlots = []
1300  if building:
1301  extendedPlots.extend(_buildingExtendedPlots)
1302  extendedPlots.extend(_extendedPlots)
1303  plotterExt.append(name, folders, TrackingPlotFolder(*extendedPlots, **commonForTPF), **common)
1304 
1305  summaryName = ""
1306  if name != "":
1307  summaryName += name+"_"
1308  summaryName += "summary"
1309  summaryPlots = []
1310  if rawSummary:
1311  summaryPlots.extend([_summaryRaw, _summaryRawN])
1312  summaryPlots.extend(_summaryPlots)
1313 
1314  common = dict(loopSubFolders=False, purpose=PlotPurpose.TrackingSummary, page="summary",
1315  #numberOfEventsHistogram=_trackingNumberOfEventsHistogram, # FIXME
1316  **limiters)
1317  plotter.append(summaryName, folders,
1318  PlotFolder(*summaryPlots, section=name, **common))
1319  if highPuritySummary:
1320  plotter.append(summaryName+"_highPurity", folders,
1321  PlotFolder(*_summaryPlotsHp, section=name+"_highPurity" if name != "" else "highPurity", **common),
1322  fallbackNames=[summaryName]) # backward compatibility for release validation, the HP plots used to be in the same directory with all-track plots
1323  if seeding:
1324  plotter.append(summaryName+"_seeds", folders,
1325  PlotFolder(*_summaryPlotsSeeds, section=name+"_seeds", **common))
1326 
1327  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section=name))
1328  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section=name+"Pt09", collection=TrackingSummaryTable.GeneralTracksPt09))
1329  if highPuritySummary:
1330  sectionName = name+"_highPurity" if name != "" else "highPurity"
1331  plotter.appendTable(summaryName+"_highPurity", folders, TrackingSummaryTable(section=sectionName, collection=TrackingSummaryTable.HighPurity))
1332  plotter.appendTable(summaryName+"_highPurity", folders, TrackingSummaryTable(section=sectionName+"Pt09", collection=TrackingSummaryTable.HighPurityPt09))
1333  if name == "":
1334  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section="btvLike", collection=TrackingSummaryTable.BTVLike))
1335  plotter.appendTable(summaryName, folders, TrackingSummaryTable(section="ak4PFJets", collection=TrackingSummaryTable.AK4PFJets))
1336 _appendTrackingPlots("Track", "", _simBasedPlots+_recoBasedPlots)
1337 _appendTrackingPlots("TrackTPPtLess09", "tpPtLess09", _simBasedPlots)
1338 _appendTrackingPlots("TrackAllTPEffic", "allTPEffic", _simBasedPlots, onlyForPileup=True)
1339 _appendTrackingPlots("TrackFromPV", "fromPV", _simBasedPlots+_recoBasedPlots, onlyForPileup=True)
1340 _appendTrackingPlots("TrackFromPVAllTP", "fromPVAllTP", _simBasedPlots+_recoBasedPlots, onlyForPileup=True)
1341 _appendTrackingPlots("TrackFromPVAllTP2", "fromPVAllTP2", _simBasedPlots+_recoBasedPlots, onlyForPileup=True)
1342 _appendTrackingPlots("TrackSeeding", "seeding", _seedingBuildingPlots, seeding=True)
1343 _appendTrackingPlots("TrackBuilding", "building", _seedingBuildingPlots, building=True)
1344 _appendTrackingPlots("TrackConversion", "conversion", _simBasedPlots+_recoBasedPlots, onlyForConversion=True, rawSummary=True, highPuritySummary=False)
1345 _appendTrackingPlots("TrackGsf", "gsf", _simBasedPlots+_recoBasedPlots, onlyForElectron=True, rawSummary=True, highPuritySummary=False)
1346 _appendTrackingPlots("TrackBHadron", "bhadron", _simBasedPlots+_recoBasedPlots, onlyForBHadron=True)
1347 # Pixel tracks
1348 _common = dict(purpose=PlotPurpose.Pixel, page="pixel")
1349 plotter.append("pixelTrack", _trackingFolders("PixelTrack"), TrackingPlotFolder(*(_simBasedPlots+_recoBasedPlots), **_common))
1350 plotterExt.append("pixelTrack", _trackingFolders("PixelTrack"), TrackingPlotFolder(*_extendedPlots, **_common))
1351 plotter.append("pixelTrack_summary", _trackingFolders("PixelTrack"), PlotFolder(_summaryRaw, _summaryRawN, loopSubFolders=False, purpose=PlotPurpose.TrackingSummary, page="summary", section="pixel"))
1352 plotter.appendTable("pixelTrack_summary", _trackingFolders("PixelTrack"), TrackingSummaryTable(section="pixel", collection=TrackingSummaryTable.Pixel))
1353 
1354 
1355 # MiniAOD
1356 plotter.append("packedCandidate", _trackingFolders("PackedCandidate"),
1357  PlotFolder(*_packedCandidatePlots, loopSubFolders=False,
1358  purpose=PlotPurpose.MiniAOD, page="miniaod", section="PackedCandidate"))
1359 plotter.append("packedCandidateLostTracks", _trackingFolders("PackedCandidate/lostTracks"),
1360  PlotFolder(*_packedCandidatePlots, loopSubFolders=False,
1361  purpose=PlotPurpose.MiniAOD, page="miniaod", section="PackedCandidate (lostTracks)"))
1362 
1363 # HLT
1364 _hltFolder = [
1365  "DQMData/Run 1/HLT/Run summary/Tracking/ValidationWRTtp",
1366 ]
1367 plotterHLT = Plotter()
1368 plotterHLTExt = Plotter()
1369 _common = dict(purpose=PlotPurpose.HLT, page="hlt")
1370 plotterHLT.append("hlt", _hltFolder, TrackingPlotFolder(*(_simBasedPlots+_recoBasedPlots), **_common))
1371 plotterHLTExt.append("hlt", _hltFolder, TrackingPlotFolder(*_extendedPlots, **_common))
1372 
1373 # Timing
1374 class Iteration:
1375  def __init__(self, name, clusterMasking=None, seeding=None, building=None, fit=None, selection=None, other=[]):
1376  self._name = name
1377 
1378  def _set(param, name, modules):
1379  if param is not None:
1380  setattr(self, name, param)
1381  else:
1382  setattr(self, name, modules)
1383 
1384  _set(clusterMasking, "_clusterMasking", [self._name+"Clusters"])
1385  # it's fine to include e.g. quadruplets here also for pair
1386  # steps, as non-existing modules are just ignored
1387  _set(seeding, "_seeding", [self._name+"SeedingLayers", self._name+"TrackingRegions", self._name+"HitDoublets", self._name+"HitTriplets", self._name+"HitQuadruplets", self._name+"Seeds"])
1388  _set(building, "_building", [self._name+"TrackCandidates"])
1389  _set(fit, "_fit", [self._name+"Tracks"])
1390  _set(selection, "_selection", [self._name])
1391  self._other = other
1392 
1393  def name(self):
1394  return self._name
1395 
1396  def all(self):
1397  return self._clusterMasking+self._seeding+self._building+self._fit+self._selection+self._other
1398 
1399  def clusterMasking(self):
1400  return self._clusterMasking
1401 
1402  def seeding(self):
1403  return self._seeding
1404 
1405  def building(self):
1406  return self._building
1407 
1408  def fit(self):
1409  return self._fit
1410 
1411  def selection(self):
1412  return self._selection
1413 
1414  def other(self):
1415  return self._other
1416 
1417  def modules(self):
1418  return [("ClusterMask", self.clusterMasking()),
1419  ("Seeding", self.seeding()),
1420  ("Building", self.building()),
1421  ("Fit", self.fit()),
1422  ("Selection", self.selection()),
1423  ("Other", self.other())]
1424 
1425 
1426 _iterations = [
1427  Iteration("initialStepPreSplitting", clusterMasking=[],
1428  seeding=["initialStepSeedLayersPreSplitting",
1429  "initialStepTrackingRegionsPreSplitting",
1430  "initialStepHitDoubletsPreSplitting",
1431  "initialStepHitTripletsPreSplitting",
1432  "initialStepHitQuadrupletsPreSplitting",
1433  "initialStepSeedsPreSplitting"],
1434  building=["initialStepTrackCandidatesPreSplitting"],
1435  fit=["initialStepTracksPreSplitting"],
1436  other=["firstStepPrimaryVerticesPreSplitting",
1437  "initialStepTrackRefsForJetsPreSplitting",
1438  "caloTowerForTrkPreSplitting",
1439  "ak4CaloJetsForTrkPreSplitting",
1440  "jetsForCoreTrackingPreSplitting",
1441  "siPixelClusters",
1442  "siPixelRecHits",
1443  "MeasurementTrackerEvent",
1444  "siPixelClusterShapeCache"]),
1445  Iteration("initialStep", clusterMasking=[],
1446  selection=["initialStepClassifier1",
1447  "initialStepClassifier2",
1448  "initialStepClassifier3",
1449  "initialStep",
1450  "initialStepSelector"],
1451  other=["firstStepPrimaryVerticesUnsorted",
1452  "initialStepTrackRefsForJets",
1453  "caloTowerForTrk",
1454  "ak4CaloJetsForTrk",
1455  "firstStepPrimaryVertices"]),
1456  Iteration("highPtTripletStep",
1457  selection=["highPtTripletStepClassifier1",
1458  "highPtTripletStepClassifier2",
1459  "highPtTripletStepClassifier3",
1460  "highPtTripletStep",
1461  "highPtTripletStepSelector"]),
1462  Iteration("detachedQuadStep",
1463  selection=["detachedQuadStepClassifier1",
1464  "detachedQuadStepClassifier2",
1465  "detachedQuadStep",
1466  "detachedQuadStepSelector"]),
1467  Iteration("detachedTripletStep",
1468  selection=["detachedTripletStepClassifier1",
1469  "detachedTripletStepClassifier2",
1470  "detachedTripletStep",
1471  "detachedTripletStepSelector"]),
1472  Iteration("lowPtQuadStep",
1473  selection=["lowPtQuadStepClassifier1",
1474  "lowPtQuadStepClassifier2",
1475  "lowPtQuadStep",
1476  "lowPtQuadStepSelector"]),
1477  Iteration("lowPtTripletStep",
1478  selection=["lowPtTripletStepClassifier1",
1479  "lowPtTripletStepClassifier2",
1480  "lowPtTripletStep",
1481  "lowPtTripletStepSelector"]),
1482  Iteration("pixelPairStep",
1483  seeding=["pixelPairStepSeedLayers",
1484  "pixelPairStepSeedLayersB",
1485  "pixelPairStepSeedLayersC",
1486  "pixelPairStepTrackingRegions",
1487  "pixelPairStepTrackingRegionsB",
1488  "pixelPairStepTrackingRegionsC",
1489  "pixelPairStepTrackingRegionsSeedLayersB",
1490  "pixelPairStepHitDoublets",
1491  "pixelPairStepHitDoubletsB",
1492  "pixelPairStepHitDoubletsC",
1493  "pixelPairStepSeedsA",
1494  "pixelPairStepSeedsB",
1495  "pixelPairStepSeedsC",
1496  "pixelPairStepSeeds",],
1497  selection=["pixelPairStep",
1498  "pixelPairStepSelector"]),
1499  Iteration("mixedTripletStep",
1500  seeding=["mixedTripletStepSeedLayersA",
1501  "mixedTripletStepSeedLayersB",
1502  "mixedTripletStepTrackingRegionsA",
1503  "mixedTripletStepTrackingRegionsB",
1504  "mixedTripletStepHitDoubletsA",
1505  "mixedTripletStepHitDoubletsB",
1506  "mixedTripletStepHitTripletsA",
1507  "mixedTripletStepHitTripletsB",
1508  "mixedTripletStepSeedsA",
1509  "mixedTripletStepSeedsB",
1510  "mixedTripletStepSeeds"],
1511  selection=["mixedTripletStepClassifier1",
1512  "mixedTripletStepClassifier2",
1513  "mixedTripletStep",
1514  "mixedTripletStepSelector"]),
1515  Iteration("pixelLessStep",
1516  selection=["pixelLessStepClassifier1",
1517  "pixelLessStepClassifier2",
1518  "pixelLessStep",
1519  "pixelLessStepSelector"]),
1520  Iteration("tobTecStep",
1521  seeding=["tobTecStepSeedLayersTripl",
1522  "tobTecStepSeedLayersPair",
1523  "tobTecStepTrackingRegionsTripl",
1524  "tobTecStepTrackingRegionsPair",
1525  "tobTecStepHitDoubletsTripl",
1526  "tobTecStepHitDoubletsPair",
1527  "tobTecStepHitTripletsTripl",
1528  "tobTecStepSeedsTripl",
1529  "tobTecStepSeedsPair",
1530  "tobTecStepSeeds"],
1531  selection=["tobTecStepClassifier1",
1532  "tobTecStepClassifier2",
1533  "tobTecStep",
1534  "tobTecStepSelector"]),
1535  Iteration("jetCoreRegionalStep",
1536  clusterMasking=[],
1537  other=["jetsForCoreTracking",
1538  "firstStepGoodPrimaryVertices",
1539  ]),
1540  Iteration("muonSeededSteps",
1541  clusterMasking=[],
1542  seeding=["muonSeededSeedsInOut",
1543  "muonSeededSeedsOutIn"],
1544  building=["muonSeededTrackCandidatesInOut",
1545  "muonSeededTrackCandidatesOutIn"],
1546  fit=["muonSeededTracksInOut",
1547  "muonSeededTracksOutIn"],
1548  selection=["muonSeededTracksInOutClassifier",
1549  "muonSeededTracksInOutSelector",
1550  "muonSeededTracksOutIntClassifier",
1551  "muonSeededTracksOutIntSelector"],
1552 # other=["earlyMuons"]
1553  ),
1554  Iteration("duplicateMerge",
1555  clusterMasking=[], seeding=[],
1556  building=["duplicateTrackCandidates"],
1557  fit=["mergedDuplicateTracks"],
1558  selection=["duplicateTrackClassifier"]),
1559  Iteration("generalTracks",
1560  clusterMasking=[], seeding=[], building=[], fit=[], selection=[],
1561  other=["preDuplicateMergingGeneralTracks",
1562  "generalTracks"]),
1563  Iteration("ConvStep",
1564  clusterMasking=["convClusters"],
1565  seeding=["convLayerPairs",
1566  "photonConvTrajSeedFromSingleLeg"],
1567  building=["convTrackCandidates"],
1568  fit=["convStepTracks"],
1569  selection=["convStepSelector"]),
1570  Iteration("Other", clusterMasking=[], seeding=[], building=[], fit=[], selection=[],
1571  other=["trackerClusterCheckPreSplitting",
1572  "trackerClusterCheck"]),
1573 ]
1574 
1575 def _iterModuleMap(includeConvStep=True, onlyConvStep=False):
1576  iterations = _iterations
1577  if not includeConvStep:
1578  iterations = [i for i in iterations if i.name() != "ConvStep"]
1579  if onlyConvStep:
1580  iterations = [i for i in iterations if i.name() == "ConvStep"]
1581  return collections.OrderedDict([(i.name(), i.all()) for i in iterations])
1582 def _stepModuleMap():
1583  def getProp(prop):
1584  ret = []
1585  for i in _iterations:
1586  if i.name() == "ConvStep":
1587  continue
1588  ret.extend(getattr(i, prop)())
1589  return ret
1590 
1591  return collections.OrderedDict([
1592  ("ClusterMask", getProp("clusterMasking")),
1593  ("Seeding", getProp("seeding")),
1594  ("Building", getProp("building")),
1595  ("Fitting", getProp("fit")),
1596  ("Selection", getProp("selection")),
1597  ("Other", getProp("other"))
1598  ])
1599 
1600 class TimePerEventPlot:
1601  def __init__(self, name, timeHisto):
1602  self._name = name
1603  self._timeHisto = timeHisto
1604  self._eventsHisto = "path time_real"
1605  self._cache = {}
1606 
1607  def __str__(self):
1608  return self._name
1609 
1610  def _create(self, tdirectory):
1611  timeTh1 = plotting._getOrCreateObject(tdirectory, self._timeHisto)
1612  if timeTh1 is None:
1613  return None
1614 
1615  eventsTh1 = plotting._getOrCreateObject(tdirectory, self._eventsHisto)
1616  if eventsTh1 is None:
1617  return None
1618  nevents = eventsTh1.GetEntries()
1619  if nevents == 0:
1620  return None
1621 
1622  ret = timeTh1.Clone(self._name)
1623  xaxis = ret.GetXaxis()
1624  for i in xrange(1, ret.GetNbinsX()+1):
1625  ret.SetBinContent(i, ret.GetBinContent(i)/nevents)
1626  ret.SetBinError(i, ret.GetBinError(i)/nevents)
1627  xaxis.SetBinLabel(i, xaxis.GetBinLabel(i).replace(" (unscheduled)", ""))
1628  return ret
1629 
1630  def create(self, tdirectory):
1631  path = tdirectory.GetPath()
1632  if path not in self._cache:
1633  self._cache[path] = self._create(tdirectory)
1634  return self._cache[path]
1635 
1636 class TimePerTrackPlot:
1637  def __init__(self, name, timeHisto, selectedTracks=False):
1638  self._name = name
1639  self._timeHisto = timeHisto
1640  self._selectedTracks = selectedTracks
1641 
1642  def __str__(self):
1643  return self._name
1644 
1645  def _getDirectory(self, tfile):
1646  for dirName in _trackingFolders():
1647  tdir = tfile.Get(dirName)
1648  if tdir != None:
1649  return tdir
1650  return None
1651 
1652  def create(self, tdirectory):
1653  timeTh1 = plotting._getOrCreateObject(tdirectory, self._timeHisto)
1654  if timeTh1 is None:
1655  return None
1656 
1657  # this is bit of a hack, but as long as it is needed only
1658  # here, I won't invest in better solution
1659  tfile = tdirectory.GetFile()
1660  trkDir = self._getDirectory(tfile)
1661  if trkDir is None:
1662  return None
1663 
1664  iterMap = copy.copy(_collLabelMapHp)
1665  del iterMap["generalTracks"]
1666  del iterMap["jetCoreRegionalStep"] # this is expensive per track on purpose
1667  if self._selectedTracks:
1668  renameBin = lambda bl: _summaryBinRename(bl, highPurity=True, byOriginalAlgo=False, byAlgoMask=True, ptCut=False, seeds=False)
1669  else:
1670  renameBin = lambda bl: _summaryBinRename(bl, highPurity=False, byOriginalAlgo=False, byAlgoMask=False, ptCut=False, seeds=False)
1671  recoAB = AggregateBins("tmp", "num_reco_coll", mapping=iterMap,ignoreMissingBins=True, renameBin=renameBin)
1672  h_reco_per_iter = recoAB.create(trkDir)
1673  if h_reco_per_iter is None:
1674  return None
1675  values = {}
1676  for i in xrange(1, h_reco_per_iter.GetNbinsX()+1):
1677  values[h_reco_per_iter.GetXaxis().GetBinLabel(i)] = h_reco_per_iter.GetBinContent(i)
1678 
1679 
1680  result = []
1681  for i in xrange(1, timeTh1.GetNbinsX()+1):
1682  iterName = timeTh1.GetXaxis().GetBinLabel(i)
1683  if iterName in values:
1684  ntrk = values[iterName]
1685  result.append( (iterName,
1686  timeTh1.GetBinContent(i)/ntrk if ntrk > 0 else 0,
1687  timeTh1.GetBinError(i)/ntrk if ntrk > 0 else 0) )
1688 
1689  if len(result) == 0:
1690  return None
1691 
1692  res = ROOT.TH1F(self._name, self._name, len(result), 0, len(result))
1693  for i, (label, value, error) in enumerate(result):
1694  res.GetXaxis().SetBinLabel(i+1, label)
1695  res.SetBinContent(i+1, value)
1696  res.SetBinError(i+1, error)
1697 
1698  return res
1699 
1700 class TrackingIterationOrder:
1701  def __init__(self):
1702  self._cache = {}
1703 
1704  def _findOrder(self, f):
1705  h = f.Get(_trackingIterationOrderHistogram)
1706  if not h:
1707  return None
1708  xaxis = h.GetXaxis()
1709  def _edit(s):
1710  # remove "Tracks" from the track producer name to get the iteration name
1711  # muonSeeded iterations do not have "Step" in the producer name, so add it here
1712  return s.replace("Tracks", "").replace("muonSeeded", "muonSeededStep")
1713  return [_edit(xaxis.GetBinLabel(i)) for i in xrange(1, h.GetNbinsX()+1)]
1714 
1715  def __call__(self, tdirectory, labels):
1716  ret = range(0, len(labels))
1717  f = tdirectory.GetFile()
1718  if not f:
1719  return ret
1720 
1721  if not f.GetName() in self._cache:
1722  r = self._findOrder(f)
1723  if r is None:
1724  return ret
1725  self._cache[f.GetName()] = r
1726  order = self._cache[f.GetName()]
1727 
1728  # O(N^2) I know, but we're talking about O(10) elements...
1729  orderIndices = []
1730  for l in order:
1731  try:
1732  orderIndices.append(labels.index(l))
1733  except ValueError:
1734  pass
1735  ret = []
1736  for i, l in enumerate(labels):
1737  if l in order:
1738  try:
1739  found = orderIndices.index(i)
1740  if found == 0:
1741  ret.append(i)
1742  else:
1743  ret.append(orderIndices[0])
1744  except ValueError:
1745  ret.append(orderIndices[0])
1746  orderIndices.pop(0)
1747  else:
1748  ret.append(i)
1749  return ret
1750 
1751 _time_per_event_cpu = TimePerEventPlot("timePerEvent", "module_time_thread_total")
1752 _time_per_event_real = TimePerEventPlot("timePerEvent", "module_time_real_total")
1753 
1754 class TrackingTimingTable:
1755  def __init__(self):
1756  self._purpose = PlotPurpose.Timing
1757  self._page = "timing"
1758  self._section = "timing"
1759 
1760  def getPurpose(self):
1761  return self._purpose
1762 
1763  def getPage(self):
1764  return self._page
1765 
1766  def getSection(self, dqmSubFolder):
1767  return self._section
1768 
1769  def _getValues(self, tdirectory, histo):
1770  h = tdirectory.Get(histo)
1771  totalReco = None
1772  if h:
1773  totalReco = "%.1f" % h.Integral()
1774 
1775  creator = AggregateBins("iteration", histo, _iterModuleMap(includeConvStep=False), ignoreMissingBins=True)
1776  h = creator.create(tdirectory)
1777  totalTracking = None
1778  if h:
1779  totalTracking = "%.1f" % h.Integral()
1780 
1781  creator = AggregateBins("iteration", histo, _iterModuleMap(onlyConvStep=True), ignoreMissingBins=True)
1782  h = creator.create(tdirectory)
1783  totalConvStep = None
1784  if h:
1785  totalConvStep = "%.1f" % h.Integral()
1786 
1787  return [
1788  totalReco,
1789  totalTracking,
1790  totalConvStep,
1791  ]
1792 
1793  def create(self, tdirectory):
1794  cpuValues = self._getValues(tdirectory, _time_per_event_cpu)
1795  realValues = self._getValues(tdirectory, _time_per_event_real)
1796 
1797  return cpuValues + realValues
1798 
1799  def headers(self):
1800  return [
1801  "Average reco CPU time / event (ms)",
1802  "Average tracking (w/o convStep) CPU time / event (ms)",
1803  "Average convStep CPU time / event (ms)",
1804  "Average reco real time / event (ms)",
1805  "Average tracking (w/o convStep) real time / event (ms)",
1806  "Average convStep real time / event (ms)",
1807  ]
1808 
1809 _common = {
1810  "drawStyle": "P",
1811  "xbinlabelsize": 10,
1812  "xbinlabeloption": "d"
1813 }
1814 
1815 _iteration_reorder = TrackingIterationOrder()
1816 _time_per_iter_cpu = AggregateBins("iteration", _time_per_event_cpu, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder)
1817 _time_per_iter_real = AggregateBins("iteration", _time_per_event_real, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder)
1818 
1819 _timing_summaryCPU = PlotGroup("summaryCPU", [
1820  Plot(_time_per_iter_cpu,
1821  ytitle="Average CPU time (ms)", title="Average CPU time / event", legendDx=-0.4, **_common),
1822  Plot(AggregateBins("iteration_fraction", _time_per_event_cpu, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder),
1823  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1824  #
1825  Plot(AggregateBins("step", _time_per_event_cpu, _stepModuleMap(), ignoreMissingBins=True),
1826  ytitle="Average CPU time (ms)", title="Average CPU time / event", **_common),
1827  Plot(AggregateBins("step_fraction", _time_per_event_cpu, _stepModuleMap(), ignoreMissingBins=True),
1828  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1829  #
1830  Plot(TimePerTrackPlot("iteration_track", _time_per_iter_cpu, selectedTracks=False),
1831  ytitle="Average CPU time / built track (ms)", title="Average CPU time / built track", **_common),
1832  Plot(TimePerTrackPlot("iteration_trackhp", _time_per_iter_cpu, selectedTracks=True),
1833  ytitle="Average CPU time / selected track (ms)", title="Average CPU time / selected HP track by algoMask", **_common),
1834  ],
1835 )
1836 _timing_summaryReal = PlotGroup("summaryReal", [
1837  Plot(_time_per_iter_real,
1838  ytitle="Average real time (ms)", title="Average real time / event", legendDx=-0.4, **_common),
1839  Plot(AggregateBins("iteration_fraction", _time_per_event_real, _iterModuleMap(), ignoreMissingBins=True, reorder=_iteration_reorder),
1840  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1841  #
1842  Plot(AggregateBins("step", _time_per_event_real, _stepModuleMap(), ignoreMissingBins=True),
1843  ytitle="Average real time (ms)", title="Average real time / event", **_common),
1844  Plot(AggregateBins("step_fraction", _time_per_event_real, _stepModuleMap(), ignoreMissingBins=True),
1845  ytitle="Fraction", title="", normalizeToUnitArea=True, **_common),
1846  #
1847  Plot(TimePerTrackPlot("iteration_track", _time_per_iter_real, selectedTracks=False),
1848  ytitle="Average real time / built track (ms)", title="Average real time / built track", **_common),
1849  Plot(TimePerTrackPlot("iteration_trackhp", _time_per_iter_real, selectedTracks=True),
1850  ytitle="Average real time / selected track (ms)", title="Average real time / selected HP track by algoMask", **_common),
1851  ],
1852 )
1853 
1854 _timing_iterationsCPU = PlotGroup("iterationsCPU", [
1855  Plot(AggregateBins(i.name(), _time_per_event_cpu, collections.OrderedDict(i.modules()), ignoreMissingBins=True),
1856  ytitle="Average CPU time (ms)", title=i.name(), **_common)
1857  for i in _iterations
1858 ],
1859  ncols=4, legend=False
1860 )
1861 _timing_iterationsReal = PlotGroup("iterationsReal", [
1862  Plot(AggregateBins(i.name(), _time_per_event_real, collections.OrderedDict(i.modules()), ignoreMissingBins=True),
1863  ytitle="Average real time (ms)", title=i.name(), **_common)
1864  for i in _iterations
1865 ],
1866  ncols=4, legend=False
1867 )
1868 
1869 # TODO: to be updated to new FastTimerService format later
1870 #_pixelTiming = PlotGroup("pixelTiming", [
1871 # Plot(AggregateBins("pixel", "reconstruction_step_module_average", {"pixelTracks": ["pixelTracks"]}), ytitle="Average processing time [ms]", title="Average processing time / event", drawStyle="HIST")
1872 #])
1873 
1874 _timeFolders = [
1875 # "DQMData/Run 1/DQM/Run summary/TimerService/process RECO paths/path reconstruction_step",
1876  "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?
1877 ]
1878 timePlotter = Plotter()
1879 timePlotter.append("timing", _timeFolders, PlotFolder(
1880  _timing_summaryCPU,
1881  _timing_iterationsCPU,
1882  _timing_summaryReal,
1883  _timing_iterationsReal,
1884  # _pixelTiming,
1885  loopSubFolders=False, purpose=PlotPurpose.Timing, page="timing"
1886 ))
1887 timePlotter.appendTable("timing", _timeFolders, TrackingTimingTable())
1888 
1889 _common = {"stat": True, "normalizeToUnitArea": True, "drawStyle": "hist"}
1890 _tplifetime = PlotGroup("tplifetime", [
1891  Plot("TPlip", xtitle="TP lip", **_common),
1892  Plot("TPtip", xtitle="TP tip", **_common),
1893 ])
1894 
1895 tpPlotter = Plotter()
1896 tpPlotter.append("tp", [
1897  "DQMData/Run 1/Tracking/Run summary/TrackingMCTruth/TrackingParticle",
1898  "DQMData/Tracking/TrackingMCTruth/TrackingParticle",
1899 ], PlotFolder(
1900  _tplifetime,
1901 ))
1902 
1903 
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:1601
plotting._getOrCreateObject
def _getOrCreateObject(tdirectory, nameOrCreator)
Definition: plotting.py:56
trackingPlots._iterModuleMap
def _iterModuleMap(includeConvStep=True, onlyConvStep=False)
Definition: trackingPlots.py:1575
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:38
pfDeepBoostedJetPreprocessParams_cfi.upper
upper
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:13
trackingPlots.TrackingTimingTable.getSection
def getSection(self, dqmSubFolder)
Definition: trackingPlots.py:1766
trackingPlots.TimePerEventPlot.create
def create(self, tdirectory)
Definition: trackingPlots.py:1630
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:1715
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:1288
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:1637
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:604
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:1610
trackingPlots.TimePerTrackPlot.create
def create(self, tdirectory)
Definition: trackingPlots.py:1652
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:1375
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:99
trackingPlots.TrackingSeedingLayerTable.draw
def draw(self, legendLabels, prefix=None, directory="", args, kwargs)
Definition: trackingPlots.py:1052
plotting._mergeBinLabelsX
def _mergeBinLabelsX(histos)
Definition: plotting.py:704
plotting._th1IncludeOnlyBins
def _th1IncludeOnlyBins(histos, xbinlabels)
Definition: plotting.py:741
trackingPlots.TrackingTimingTable._getValues
def _getValues(self, tdirectory, histo)
Definition: trackingPlots.py:1769
Generated for CMSSW Reference Manual by doxygen 1.8.11