The Gaudi Framework  master (ff829712)
Loading...
Searching...
No Matches
Functions | Variables
compareRootHistos Namespace Reference

Functions

 rec (o, path=None, lst=None)
 
 composition (t)
 
 comparePaths (t1, t2)
 
 bin2binIdentity (h1, h2)
 
 compareHistos (t1, t2, state, checkBin2BinIdentity)
 
 extractBlacklist (listString)
 

Variables

 backupArgv = sys.argv[:]
 
 argv
 
list gRegexBlackList = []
 
list histos = ["TH1D", "TH1F", "TH2D", "TH2F", "TProfile"]
 
str ref = "REFERENCE"
 
str test = "TEST"
 
str usage = "usage: %prog testFile.root referenceFile.root [options]"
 
 parser = OptionParser()
 
 dest
 
 help
 
 action
 
 default
 
 options
 
 args
 
 testFile
 
 referenceFile
 
 tfs = TFile(testFile, "REC")
 
 tfp = TFile(referenceFile, "REC")
 
 lref = rec(tfs)
 
 ltest = rec(tfp)
 
 dref = dict([(n, o) for n, o in lref])
 
 dtest = dict([(n, o) for n, o in ltest])
 
tuple ts = (ref, dref)
 
tuple tp = (test, dtest)
 
 state = comparePaths(ts, tp)
 
 retval = compareHistos(ts, tp, state, checkBin2BinIdentity=options.bin2bin)
 

Function Documentation

◆ bin2binIdentity()

compareRootHistos.bin2binIdentity ( h1,
h2 )

Definition at line 180 of file compareRootHistos.py.

180def bin2binIdentity(h1, h2):
181 def getNbins(h):
182 biny = h.GetNbinsY()
183 if biny > 1:
184 biny += 1
185 binz = h.GetNbinsZ()
186 if binz > 1:
187 binz += 1
188 return (h.GetNbinsX() + 1) * (biny) * (binz)
189
190 nbins = getNbins(h1)
191 diffbins = 0
192 for ibin in range(0, nbins):
193 h1bin = h1.GetBinContent(ibin)
194 h2bin = h2.GetBinContent(ibin)
195 diffbins += h1bin != h2bin
196 return diffbins
197
198
199# =============================================================================
200# Method : compareHistos( t1, t2 )
201#
202# @param t1, t2 : a tuple of ( type, d ) where type is either 'REFERENCE' or 'TEST'
203# and d is a dictionary of ROOT objects, with each key = ROOT path
204#
205# function : compare the histograms in Reference/Test ROOT files. First, go through each
206# dict to collect the histos (ignore TDirectory objects, etc). Then the histos
207# in the test file (experimental) are compared to their equivalents in the
208# reference file (definitely correct) using 3 methods.
209# 1) The entries are checked, they should be equal
210# 2) If entries are equal, check the Integral(); should be equal
211# 3) If integrals are equal, check the KolmogorovTest() ; should be 1
212# 4) If identity flag is there and KS test is performed, perform bin2bin identity test
213# Arguments t1 and t2 are checked and the test/reference auto-detected
214#

◆ compareHistos()

compareRootHistos.compareHistos ( t1,
t2,
state,
checkBin2BinIdentity )

Definition at line 215 of file compareRootHistos.py.

215def compareHistos(t1, t2, state, checkBin2BinIdentity):
216 (
217 ((referenceObjects, referenceHistos), (parallObjects, parallHistos)),
218 (uniqueSerPaths, uniqueSerHistos),
219 (uniqueParPaths, uniqueParHistos),
220 mh,
221 ) = state
222
223 # deduce which one is test, which reference
224 if t1[0] == ref:
225 ds = t1[1]
226 dp = t2[1]
227 elif t2[0] == ref:
228 ds = t2[1]
229 dp = t1[1]
230 else:
231 print("Neither tuple is Reference Root file reference?")
232 return
233
234 # histocount, objectcount for test/reference
235 hcp = 0
236 pHistos = []
237 hcs = 0
238 sHistos = []
239
240 omit = [re.compile(regex) for regex in gRegexBlackList]
241
242 # find the histos in the reference file
243 for k in ds.keys():
244 if not any(regex.search(k) is not None for regex in omit):
245 if ds[k].__class__.__name__ in histos:
246 hcs += 1
247 sHistos.append(k)
248 # same for test
249 for k in dp.keys():
250 if not any(regex.search(k) is not None for regex in omit):
251 if dp[k].__class__.__name__ in histos:
252 hcp += 1
253 pHistos.append(k)
254
255 cEntries = 0
256 xEntries = 0
257 diffEntries = []
258 xIntegrals = 0
259 diffIntegrals = []
260 passedKol = 0
261 failedKol = 0
262 diffKols = []
263 passedIdentity = 0
264 failedIdentity = 0
265 diffIdentity = []
266 identityDiffBins = {}
267 kTested = 0
268 kTestResults = {}
269 notfound = 0
270 integralMatch = 0
271 otherTest = 0
272 zeroIntegralMatch = 0
273 for h in sHistos:
274 if h in pHistos:
275 # matching histos to check
276 cEntries += 1
277 sh = ds[h]
278 ph = dp[h]
279 # first check entries
280 if sh.GetEntries() != ph.GetEntries():
281 diffEntries.append(h)
282 xEntries += 1
283 continue
284 # check for (non-zero sum of bin error) && (non-zero integrals) for K-Test
285 sBinError = 0.0
286 pBinError = 0.0
287 for i in range(sh.GetNbinsX()):
288 sBinError += sh.GetBinError(i)
289 for i in range(ph.GetNbinsX()):
290 pBinError += ph.GetBinError(i)
291 sint = sh.Integral()
292 pint = ph.Integral()
293 doKS = (bool(sint) and bool(pint)) and (sBinError > 0 and pBinError > 0)
294 if checkBin2BinIdentity and doKS:
295 diffBins = bin2binIdentity(sh, ph)
296 if diffBins == 0:
297 passedIdentity += 1
298 else:
299 failedIdentity += 1
300 diffIdentity.append(h)
301 identityDiffBins[h] = diffBins
302 if (bool(sint) and bool(pint)) and (sBinError > 0 and pBinError > 0):
303 kTested += 1
304 kTest = sh.KolmogorovTest(ph)
305 kTestResults[h] = kTest
306 if int(kTest):
307 passedKol += 1
308 else:
309 # ; print 'KTest result : ', kTest
310 failedKol += 1
311 diffKols.append(h)
312 else:
313 # try the integral test?
314 otherTest += 1
315 if all((sint, pint)) and (sint == pint):
316 integralMatch += 1
317 elif sint == pint:
318 zeroIntegralMatch += 1
319 else:
320 diffIntegrals.append(h)
321 xIntegrals += 1
322 else:
323 notfound += 1
324 print("not found? ", h)
325
326 # report on Failed Entry-Checks
327 print("\n\n" + "-" * 80)
328 print("Summary of histos with different Entries")
329 print("-" * 80)
330 if diffEntries:
331 diffEntries.sort()
332 for e in diffEntries:
333 print(
334 "\t\t\t%s:\t%i != %i"
335 % (e, int(ds[e].GetEntries()), int(dp[e].GetEntries()))
336 )
337 print("-" * 80)
338
339 # report on Failed Kolmogorov Tests
340 print("\n\n" + "-" * 60)
341 print("Summary of histos which failed Kolmogorov Test")
342 print("-" * 60)
343 if diffKols:
344 diffKols.sort()
345 for e in diffKols:
346 result = kTestResults[e] # DP Calculated twice ARGH!!
347 print(
348 "%s\t\t%s :\tK-Test Result :\t %5.16f" % (ds[e].ClassName(), e, result)
349 )
350 print("-" * 60)
351
352 # report on Failed Integral Checks
353 print("\n\n" + "-" * 60)
354 print("Summary of histos which failed Integral Check")
355 print("-" * 60)
356 if diffIntegrals:
357 diffIntegrals.sort()
358 for e in diffIntegrals:
359 diff = dp[e].Integral() - ds[e].Integral()
360 pc = (diff * 100) / ds[e].Integral()
361 print(
362 "%s\t\t%s:\t Diff = %5.6f\tPercent Diff to Reference : %5.6f "
363 % (ds[e].ClassName(), e, diff, pc)
364 )
365 print("-" * 60 + "\n")
366 print("=" * 80 + "\n")
367
368 # Report on failed bin2bin identity
369 if checkBin2BinIdentity:
370 # report on b2b checks
371 print("\n\n" + "-" * 80)
372 print("Summary of histos with at least one bin with different Entries")
373 print("-" * 80)
374 if diffIdentity:
375 diffIdentity.sort()
376 for e in diffIdentity:
377 print(
378 "%s\t\t%s: %i different bins"
379 % (ds[e].ClassName(), e, identityDiffBins[e])
380 )
381 print("-" * 80)
382
383 print("\n" + "=" * 80)
384 print("Comparison : Reference/Test ROOT Histo files")
385 print("\n\t\tReference\tTest")
386 print(
387 "\tObjects : %i\t%i\t\t( p-s = %i )"
388 % (referenceObjects, parallObjects, parallObjects - referenceObjects)
389 )
390 print(
391 "\tHistos : %i\t%i\t\t( p-s = %i )"
392 % (referenceHistos, parallHistos, parallHistos - referenceHistos)
393 )
394 print("\t __________")
395 print(
396 "\tTotal : %i\t%i\n"
397 % (referenceHistos + referenceObjects, parallHistos + parallObjects)
398 )
399 print(
400 "Objects/Histos unique to Reference File : %i / %i"
401 % (len(uniqueSerPaths) - uniqueSerHistos, uniqueSerHistos)
402 )
403 print(
404 "Objects/Histos unique to Test File : %i / %i"
405 % (len(uniqueParPaths) - uniqueParHistos, uniqueParHistos)
406 )
407 print("\nMatching Histograms valid for Comparison : %i" % (mh))
408 print("\nOmissions' patterns : ")
409 for entry in gRegexBlackList:
410 print("\t%s" % (entry))
411 print(
412 "\nHistograms for Comparison (after Omissions) : %i"
413 % (mh - len(gRegexBlackList))
414 )
415 print("\n\tHISTOGRAM TESTS : ")
416 print("\t\tKOLMOGOROV TEST : %i" % (kTested))
417 print("\t\tINTEGRAL TEST : %i" % (otherTest))
418 print("\t\tENTRIES TEST : %i" % (xEntries))
419 if checkBin2BinIdentity:
420 print("\t\tBIN2BIN TEST : %i" % (passedIdentity))
421 print("\t\t ____")
422 print("\t\tTested : %i" % (cEntries))
423
424 print("\n\tDISCREPANCIES : ")
425 print("\t\tK-Test : %i" % (failedKol))
426 print("\t\tIntegrals : %i" % (xIntegrals))
427 print("\t\tEntries : %i" % (xEntries))
428 retval = failedKol + xIntegrals + xEntries + failedIdentity
429 if retval != 0:
430 print("\nThe two sets of histograms were not identical")
431 print("\n" + "=" * 80)
432 return retval
433
434
435# =============================================================================
436
437

◆ comparePaths()

compareRootHistos.comparePaths ( t1,
t2 )

Definition at line 100 of file compareRootHistos.py.

100def comparePaths(t1, t2):
101 if t1[0] == ref:
102 ds = t1[1]
103 dp = t2[1]
104 elif t2[0] == ref:
105 ds = t2[1]
106 dp = t1[1]
107 else:
108 print("Neither tuple is Reference Root file reference?")
109 return
110
111 dsks = list(ds.keys())
112 dpks = list(dp.keys())
113 dsks.sort()
114 dpks.sort()
115
116 sset = set(dsks)
117 pset = set(dpks)
118 os, hs = composition((ref, ds))
119 op, hp = composition((test, dp))
120 print("\n" + "=" * 80)
121 print("Comparison of Paths : Reference vs Test ROOT files")
122 print("-" * 80)
123 print(
124 "Number of paths in Reference file : %i (objects, histos) = ( %i, %i )"
125 % (len(dsks), os, hs)
126 )
127 print(
128 "Number of paths in Test file : %i (objects, histos) = ( %i, %i )"
129 % (len(dpks), op, hp)
130 )
131 matching = sset.intersection(pset)
132 matchingHistos = 0
133 for n in matching:
134 if ds[n].__class__.__name__ in histos:
135 matchingHistos += 1
136 print("\nMatching paths : %i" % (len(matching)))
137 uSer = sset - pset
138 # work out histos unique to test file
139 uniqueReferenceHistos = 0
140 for n in uSer:
141 if ds[n].__class__.__name__ in histos:
142 uniqueReferenceHistos += 1
143 print(
144 "Paths unique to Reference file : %i ( %i Histos )"
145 % (len(uSer), uniqueReferenceHistos)
146 )
147 if uSer:
148 for n in uSer:
149 print("\t%s : \t%s" % (ds[n], n))
150 uPar = pset - sset
151 uniqueTestHistos = 0
152 for n in uPar:
153 if dp[n].__class__.__name__ in histos:
154 uniqueTestHistos += 1
155 print(
156 "Paths unique to Test file : %i ( %i Histos )" % (len(uPar), uniqueTestHistos)
157 )
158 if uPar:
159 for n in uPar:
160 print("\t%s : \t%s" % (dp[n], n))
161 print("Matching Histos to test : %i" % (matchingHistos))
162 print("=" * 80 + "\n")
163 return (
164 ((os, hs), (op, hp)),
165 (uSer, uniqueReferenceHistos),
166 (uPar, uniqueTestHistos),
167 matchingHistos,
168 )
169
170
171# =============================================================================
172
173# =============================================================================
174# Method : bin2binIdentity(h1,h2)
175#
176# @param h1, h2 : The two histogtams to compare
177# function : Return the number of different bins
178
179

◆ composition()

compareRootHistos.composition ( t)

Definition at line 72 of file compareRootHistos.py.

72def composition(t):
73 typ, d = t
74 hists = 0
75 objs = 0
76 for k in d.keys():
77 if d[k].__class__.__name__ in histos:
78 hists += 1
79 else:
80 objs += 1
81 return objs, hists
82
83
84# =============================================================================
85
86# =============================================================================
87# Method : comparePaths( t1, t2 )
88#
89# @param t1, t2 : a tuple of ( type, d ) where type is either 'REFERENCE' or 'TEST'
90# and d is a dictionary of ROOT objects, with each key = ROOT path
91#
92# function : compare the paths between the two histo files. If the files are identical, they
93# should have the same set of paths. The Test file should definitely have the
94# same paths as the Reference. Perhaps the Reference file will have some more paths due
95# to extra histos added as part of Application Sequencer finalisation
96# Arguments t1 and t2 are checked and the test/reference auto-detected
97#
98
99

◆ extractBlacklist()

compareRootHistos.extractBlacklist ( listString)

Definition at line 438 of file compareRootHistos.py.

438def extractBlacklist(listString):
439 global gRegexBlackList
440 if listString:
441 for blackRegexp in listString.split(","):
442 gRegexBlackList.append(blackRegexp)
443 else:
444 gRegexBlackList = []
445
446
447# =============================================================================
448

◆ rec()

compareRootHistos.rec ( o,
path = None,
lst = None )

Definition at line 43 of file compareRootHistos.py.

43def rec(o, path=None, lst=None):
44 if not path:
45 path = "/stat"
46 lst = []
47 else:
48 path = path + "/" + o.GetName()
49 lst.append((path, o))
50 if "GetListOfKeys" in dir(o):
51 keys = o.GetListOfKeys()
52 for k in keys:
53 name = k.GetName()
54 rec(o.Get(name), path, lst)
55 else:
56 pass
57 return lst
58
59
60# =============================================================================
61
62# =============================================================================
63# Method : composition( t )
64#
65# @param t : a tuple of ( type, d ) where type is either 'REFERENCE' or 'TEST'
66# and d is a dictionary of ROOT objects, with each key = ROOT path
67#
68# function : deduce the composition, (objects/histos) counts
69#
70
71

Variable Documentation

◆ action

compareRootHistos.action

Definition at line 460 of file compareRootHistos.py.

◆ args

compareRootHistos.args

Definition at line 465 of file compareRootHistos.py.

◆ argv

compareRootHistos.argv

Definition at line 19 of file compareRootHistos.py.

◆ backupArgv

compareRootHistos.backupArgv = sys.argv[:]

Definition at line 18 of file compareRootHistos.py.

◆ default

compareRootHistos.default

Definition at line 462 of file compareRootHistos.py.

◆ dest

compareRootHistos.dest

Definition at line 454 of file compareRootHistos.py.

◆ dref

compareRootHistos.dref = dict([(n, o) for n, o in lref])

Definition at line 485 of file compareRootHistos.py.

◆ dtest

compareRootHistos.dtest = dict([(n, o) for n, o in ltest])

Definition at line 486 of file compareRootHistos.py.

◆ gRegexBlackList

list compareRootHistos.gRegexBlackList = []

Definition at line 25 of file compareRootHistos.py.

◆ help

compareRootHistos.help

Definition at line 455 of file compareRootHistos.py.

◆ histos

list compareRootHistos.histos = ["TH1D", "TH1F", "TH2D", "TH2F", "TProfile"]

Definition at line 26 of file compareRootHistos.py.

◆ lref

compareRootHistos.lref = rec(tfs)

Definition at line 482 of file compareRootHistos.py.

◆ ltest

compareRootHistos.ltest = rec(tfp)

Definition at line 483 of file compareRootHistos.py.

◆ options

compareRootHistos.options

Definition at line 465 of file compareRootHistos.py.

◆ parser

compareRootHistos.parser = OptionParser()

Definition at line 451 of file compareRootHistos.py.

◆ ref

str compareRootHistos.ref = "REFERENCE"

Definition at line 27 of file compareRootHistos.py.

◆ referenceFile

compareRootHistos.referenceFile

Definition at line 474 of file compareRootHistos.py.

◆ retval

compareRootHistos.retval = compareHistos(ts, tp, state, checkBin2BinIdentity=options.bin2bin)

Definition at line 499 of file compareRootHistos.py.

◆ state

compareRootHistos.state = comparePaths(ts, tp)

Definition at line 496 of file compareRootHistos.py.

◆ test

str compareRootHistos.test = "TEST"

Definition at line 28 of file compareRootHistos.py.

◆ testFile

compareRootHistos.testFile

Definition at line 474 of file compareRootHistos.py.

◆ tfp

compareRootHistos.tfp = TFile(referenceFile, "REC")

Definition at line 478 of file compareRootHistos.py.

◆ tfs

compareRootHistos.tfs = TFile(testFile, "REC")

Definition at line 476 of file compareRootHistos.py.

◆ tp

tuple compareRootHistos.tp = (test, dtest)

Definition at line 489 of file compareRootHistos.py.

◆ ts

tuple compareRootHistos.ts = (ref, dref)

Definition at line 488 of file compareRootHistos.py.

◆ usage

str compareRootHistos.usage = "usage: %prog testFile.root referenceFile.root [options]"

Definition at line 450 of file compareRootHistos.py.