The Gaudi Framework  v29r0 (ff2e7097)
Functions | Variables
compareRootHistos Namespace Reference

Functions

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

Variables

 backupArgv = sys.argv[:]
 
 argv
 
list gRegexBlackList = []
 
list histos = ['TH1D', 'TH1F', 'TH2D', 'TH2F', 'TProfile']
 
string ref = 'REFERENCE'
 
string test = 'TEST'
 
string usage = "usage: %prog testFile.root referenceFile.root [options]"
 
 parser = OptionParser()
 
 dest
 
 help
 
 action
 
 default
 
 options
 
 args
 
 testFile
 
 referenceFile
 
string tfs = TFile(testFile, 'REC');print'opening Test File : %s'
 
string tfp = TFile(referenceFile, 'REC');print'opening Reference File : %s'
 
 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

def compareRootHistos.bin2binIdentity (   h1,
  h2 
)

Definition at line 145 of file compareRootHistos.py.

145 def bin2binIdentity(h1, h2):
146  def getNbins(h):
147  biny = h.GetNbinsY()
148  if biny > 1:
149  biny += 1
150  binz = h.GetNbinsZ()
151  if binz > 1:
152  binz += 1
153  return (h.GetNbinsX() + 1) * (biny) * (binz)
154 
155  nbins = getNbins(h1)
156  diffbins = 0
157  for ibin in xrange(0, nbins):
158  h1bin = h1.GetBinContent(ibin)
159  h2bin = h2.GetBinContent(ibin)
160  diffbins += (h1bin != h2bin)
161  return diffbins
162 
163 
164 # =============================================================================
165 # Method : compareHistos( t1, t2 )
166 #
167 # @param t1, t2 : a tuple of ( type, d ) where type is either 'REFERENCE' or 'TEST'
168 # and d is a dictionary of ROOT objects, with each key = ROOT path
169 #
170 # function : compare the histograms in Reference/Test ROOT files. First, go through each
171 # dict to collect the histos (ignore TDirectory objects, etc). Then the histos
172 # in the test file (experimental) are compared to their equivalents in the
173 # reference file (definitely correct) using 3 methods.
174 # 1) The entries are checked, they should be equal
175 # 2) If entries are equal, check the Integral(); should be equal
176 # 3) If integrals are equal, check the KolmogorovTest() ; should be 1
177 # 4) If identity flag is there and KS test is performed, perform bin2bin identity test
178 # Arguments t1 and t2 are checked and the test/reference auto-detected
179 #
compareRootHistos.bin2binIdentity
def bin2binIdentity(h1, h2)
Definition: compareRootHistos.py:145
def compareRootHistos.compareHistos (   t1,
  t2,
  state,
  checkBin2BinIdentity 
)

Definition at line 180 of file compareRootHistos.py.

180 def compareHistos(t1, t2, state, checkBin2BinIdentity):
181 
182  (((referenceObjects, referenceHistos), (parallObjects, parallHistos)),
183  (uniqueSerPaths, uniqueSerHistos), (uniqueParPaths, uniqueParHistos), mh) = state
184 
185  # deduce which one is test, which reference
186  if t1[0] == ref:
187  ds = t1[1]
188  dp = t2[1]
189  elif t2[0] == ref:
190  ds = t2[1]
191  dp = t1[1]
192  else:
193  print 'Neither tuple is Reference Root file reference?'
194  return
195 
196  # histocount, objectcount for test/reference
197  hcp = 0
198  pHistos = []
199  hcs = 0
200  sHistos = []
201 
202  omit = [re.compile(regex) for regex in gRegexBlackList]
203 
204  # find the histos in the reference file
205  for k in ds.keys():
206  if not any(regex.search(k) != None for regex in omit):
207  if ds[k].__class__.__name__ in histos:
208  hcs += 1
209  sHistos.append(k)
210  # same for test
211  for k in dp.keys():
212  if not any(regex.search(k) != None for regex in omit):
213  if dp[k].__class__.__name__ in histos:
214  hcp += 1
215  pHistos.append(k)
216 
217  cEntries = 0
218  xEntries = 0
219  diffEntries = []
220  cIntegrals = 0
221  xIntegrals = 0
222  diffIntegrals = []
223  passedKol = 0
224  failedKol = 0
225  diffKols = []
226  zeroIntegrals = 0
227  passedIdentity = 0
228  failedIdentity = 0
229  diffIdentity = []
230  identityDiffBins = {}
231  kTested = 0
232  kTestResults = {}
233  notfound = 0
234  integralMatch = 0
235  otherTest = 0
236  zeroIntegralMatch = 0
237  for h in sHistos:
238  if h in pHistos:
239  # matching histos to check
240  cEntries += 1
241  sh = ds[h]
242  ph = dp[h]
243  # first check entries
244  if sh.GetEntries() != ph.GetEntries():
245  diffEntries.append(h)
246  xEntries += 1
247  continue
248  # check for (non-zero sum of bin error) && (non-zero integrals) for K-Test
249  sBinError = 0.0
250  pBinError = 0.0
251  for i in xrange(sh.GetNbinsX()):
252  sBinError += sh.GetBinError(i)
253  for i in xrange(ph.GetNbinsX()):
254  pBinError += ph.GetBinError(i)
255  sint = sh.Integral()
256  pint = ph.Integral()
257  doKS = (bool(sint) and bool(pint)) and (
258  sBinError > 0 and pBinError > 0)
259  if checkBin2BinIdentity and doKS:
260  diffBins = bin2binIdentity(sh, ph)
261  if diffBins == 0:
262  passedIdentity += 1
263  else:
264  failedIdentity += 1
265  diffIdentity.append(h)
266  identityDiffBins[h] = diffBins
267  if (bool(sint) and bool(pint)) and (sBinError > 0 and pBinError > 0):
268  kTested += 1
269  kTest = sh.KolmogorovTest(ph)
270  kTestResults[h] = kTest
271  if int(kTest):
272  passedKol += 1
273  else:
274  # ; print 'KTest result : ', kTest
275  failedKol += 1
276  diffKols.append(h)
277  else:
278  # try the integral test?
279  otherTest += 1
280  if all((sint, pint)) and (sint == pint):
281  integralMatch += 1
282  elif (sint == pint):
283  zeroIntegralMatch += 1
284  else:
285  diffIntegrals.append(h)
286  xIntegrals += 1
287  else:
288  notfound += 1
289  print 'not found? ', h
290 
291  # report on Failed Entry-Checks
292  print '\n\n' + '-' * 80
293  print 'Summary of histos with different Entries'
294  print '-' * 80
295  if diffEntries:
296  diffEntries.sort()
297  for e in diffEntries:
298  print '\t\t\t%s:\t%i != %i' % (e, int(ds[e].GetEntries()), int(dp[e].GetEntries()))
299  print '-' * 80
300 
301  # report on Failed Kolmogorov Tests
302  print '\n\n' + '-' * 60
303  print 'Summary of histos which failed Kolmogorov Test'
304  print '-' * 60
305  if diffKols:
306  diffKols.sort()
307  for e in diffKols:
308  result = kTestResults[e] # DP Calculated twice ARGH!!
309  print '%s\t\t%s :\tK-Test Result :\t %5.16f' % (ds[e].ClassName(), e, result)
310  print '-' * 60
311 
312  # report on Failed Integral Checks
313  print '\n\n' + '-' * 60
314  print 'Summary of histos which failed Integral Check'
315  print '-' * 60
316  if diffIntegrals:
317  diffIntegrals.sort()
318  for e in diffIntegrals:
319  diff = dp[e].Integral() - ds[e].Integral()
320  pc = (diff * 100) / ds[e].Integral()
321  print '%s\t\t%s:\t Diff = %5.6f\tPercent Diff to Reference : %5.6f ' % (ds[e].ClassName(), e, diff, pc)
322  print '-' * 60 + '\n'
323  print '=' * 80 + '\n'
324 
325  # Report on failed bin2bin identity
326  if checkBin2BinIdentity:
327  # report on b2b checks
328  print '\n\n' + '-' * 80
329  print 'Summary of histos with at least one bin with different Entries'
330  print '-' * 80
331  if diffIdentity:
332  diffIdentity.sort()
333  for e in diffIdentity:
334  print '%s\t\t%s: %i different bins' % (ds[e].ClassName(), e, identityDiffBins[e])
335  print '-' * 80
336 
337  print '\n' + '=' * 80
338  print 'Comparison : Reference/Test ROOT Histo files'
339  print '\n\t\tReference\tTest'
340  print '\tObjects : %i\t%i\t\t( p-s = %i )' % (referenceObjects, parallObjects, parallObjects - referenceObjects)
341  print '\tHistos : %i\t%i\t\t( p-s = %i )' % (referenceHistos, parallHistos, parallHistos - referenceHistos)
342  print '\t __________'
343  print '\tTotal : %i\t%i\n' % (referenceHistos + referenceObjects, parallHistos + parallObjects)
344  print 'Objects/Histos unique to Reference File : %i / %i' % (len(uniqueSerPaths) - uniqueSerHistos, uniqueSerHistos)
345  print 'Objects/Histos unique to Test File : %i / %i' % (len(uniqueParPaths) - uniqueParHistos, uniqueParHistos)
346  print '\nMatching Histograms valid for Comparison : %i' % (mh)
347  print '\nOmissions\' patterns : '
348  for entry in gRegexBlackList:
349  print '\t%s' % (entry)
350  print '\nHistograms for Comparison (after Omissions) : %i' % (mh - len(gRegexBlackList))
351  print '\n\tHISTOGRAM TESTS : '
352  print '\t\tKOLMOGOROV TEST : %i' % (kTested)
353  print '\t\tINTEGRAL TEST : %i' % (otherTest)
354  print '\t\tENTRIES TEST : %i' % (xEntries)
355  if checkBin2BinIdentity:
356  print '\t\tBIN2BIN TEST : %i' % (passedIdentity)
357  print '\t\t ____'
358  print '\t\tTested : %i' % (cEntries)
359 
360  print '\n\tDISCREPANCIES : '
361  print '\t\tK-Test : %i' % (failedKol)
362  print '\t\tIntegrals : %i' % (xIntegrals)
363  print '\t\tEntries : %i' % (xEntries)
364  retval = failedKol + xIntegrals + xEntries + failedIdentity
365  if retval != 0:
366  print '\nThe two sets of histograms were not identical'
367  print '\n' + '=' * 80
368  return retval
369 
370 # =============================================================================
371 
372 
compareRootHistos.compareHistos
def compareHistos(t1, t2, state, checkBin2BinIdentity)
Definition: compareRootHistos.py:180
compareRootHistos.bin2binIdentity
def bin2binIdentity(h1, h2)
Definition: compareRootHistos.py:145
GaudiMath::Integral
GAUDI_API double Integral(const Genfun::AbsFunction &function, const double a, const double b, const GaudiMath::Integration::Type type=GaudiMath::Integration::Adaptive, const GaudiMath::Integration::KronrodRule rule=GaudiMath::Integration::Default, const double epsabs=1.e-10, const double epsrel=1.e-7, const size_t size=1000)
Definition: Integral.cpp:26
def compareRootHistos.comparePaths (   t1,
  t2 
)

Definition at line 83 of file compareRootHistos.py.

83 def comparePaths(t1, t2):
84  if t1[0] == ref:
85  ds = t1[1]
86  dp = t2[1]
87  elif t2[0] == ref:
88  ds = t2[1]
89  dp = t1[1]
90  else:
91  print 'Neither tuple is Reference Root file reference?'
92  return
93 
94  dsks = ds.keys()
95  dpks = dp.keys()
96  dsks.sort()
97  dpks.sort()
98 
99  sset = set(dsks)
100  pset = set(dpks)
101  os, hs = composition((ref, ds))
102  op, hp = composition((test, dp))
103  print '\n' + '=' * 80
104  print 'Comparison of Paths : Reference vs Test ROOT files'
105  print '-' * 80
106  print 'Number of paths in Reference file : %i (objects, histos) = ( %i, %i )' % (len(dsks), os, hs)
107  print 'Number of paths in Test file : %i (objects, histos) = ( %i, %i )' % (len(dpks), op, hp)
108  matching = sset.intersection(pset)
109  matchingHistos = 0
110  for n in matching:
111  if ds[n].__class__.__name__ in histos:
112  matchingHistos += 1
113  print '\nMatching paths : %i' % (len(matching))
114  uSer = sset - pset
115  # work out histos unique to test file
116  uniqueReferenceHistos = 0
117  for n in uSer:
118  if ds[n].__class__.__name__ in histos:
119  uniqueReferenceHistos += 1
120  print 'Paths unique to Reference file : %i ( %i Histos )' % (len(uSer), uniqueReferenceHistos)
121  if uSer:
122  for n in uSer:
123  print '\t%s : \t%s' % (ds[n], n)
124  uPar = pset - sset
125  uniqueTestHistos = 0
126  for n in uPar:
127  if dp[n].__class__.__name__ in histos:
128  uniqueTestHistos += 1
129  print 'Paths unique to Test file : %i ( %i Histos )' % (len(uPar), uniqueTestHistos)
130  if uPar:
131  for n in uPar:
132  print '\t%s : \t%s' % (dp[n], n)
133  print 'Matching Histos to test : %i' % (matchingHistos)
134  print '=' * 80 + '\n'
135  return (((os, hs), (op, hp)), (uSer, uniqueReferenceHistos), (uPar, uniqueTestHistos), matchingHistos)
136 # =============================================================================
137 
138 # =============================================================================
139 # Method : bin2binIdentity(h1,h2)
140 #
141 # @param h1, h2 : The two histogtams to compare
142 # function : Return the number of different bins
143 
144 
compareRootHistos.comparePaths
def comparePaths(t1, t2)
Definition: compareRootHistos.py:83
def compareRootHistos.composition (   t)

Definition at line 57 of file compareRootHistos.py.

57 def composition(t):
58  typ, d = t
59  hists = 0
60  objs = 0
61  for k in d.keys():
62  if d[k].__class__.__name__ in histos:
63  hists += 1
64  else:
65  objs += 1
66  return objs, hists
67 # =============================================================================
68 
69 # =============================================================================
70 # Method : comparePaths( t1, t2 )
71 #
72 # @param t1, t2 : a tuple of ( type, d ) where type is either 'REFERENCE' or 'TEST'
73 # and d is a dictionary of ROOT objects, with each key = ROOT path
74 #
75 # function : compare the paths between the two histo files. If the files are identical, they
76 # should have the same set of paths. The Test file should definitely have the
77 # same paths as the Reference. Perhaps the Reference file will have some more paths due
78 # to extra histos added as part of Application Sequencer finalisation
79 # Arguments t1 and t2 are checked and the test/reference auto-detected
80 #
81 
82 
def compareRootHistos.extractBlacklist (   listString)

Definition at line 373 of file compareRootHistos.py.

373 def extractBlacklist(listString):
374  global gRegexBlackList
375  if listString:
376  for blackRegexp in listString.split(","):
377  gRegexBlackList.append(blackRegexp)
378  else:
379  gBlackList = []
380 
381 # =============================================================================
382 
383 
compareRootHistos.extractBlacklist
def extractBlacklist(listString)
Definition: compareRootHistos.py:373
def compareRootHistos.rec (   o,
  path = None,
  lst = None 
)

Definition at line 30 of file compareRootHistos.py.

30 def rec(o, path=None, lst=None):
31  if not path:
32  path = '/stat'
33  lst = []
34  else:
35  path = path + '/' + o.GetName()
36  lst.append((path, o))
37  if 'GetListOfKeys' in dir(o):
38  keys = o.GetListOfKeys()
39  for k in keys:
40  name = k.GetName()
41  rec(o.Get(name), path, lst)
42  else:
43  pass
44  return lst
45 # =============================================================================
46 
47 # =============================================================================
48 # Method : composition( t )
49 #
50 # @param t : a tuple of ( type, d ) where type is either 'REFERENCE' or 'TEST'
51 # and d is a dictionary of ROOT objects, with each key = ROOT path
52 #
53 # function : deduce the composition, (objects/histos) counts
54 #
55 
56 
compareRootHistos.rec
def rec(o, path=None, lst=None)
Definition: compareRootHistos.py:30

Variable Documentation

compareRootHistos.action

Definition at line 391 of file compareRootHistos.py.

compareRootHistos.args

Definition at line 393 of file compareRootHistos.py.

compareRootHistos.argv

Definition at line 7 of file compareRootHistos.py.

compareRootHistos.backupArgv = sys.argv[:]

Definition at line 6 of file compareRootHistos.py.

compareRootHistos.default

Definition at line 391 of file compareRootHistos.py.

compareRootHistos.dest

Definition at line 387 of file compareRootHistos.py.

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

Definition at line 411 of file compareRootHistos.py.

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

Definition at line 412 of file compareRootHistos.py.

list compareRootHistos.gRegexBlackList = []

Definition at line 12 of file compareRootHistos.py.

compareRootHistos.help

Definition at line 388 of file compareRootHistos.py.

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

Definition at line 13 of file compareRootHistos.py.

compareRootHistos.lref = rec(tfs)

Definition at line 408 of file compareRootHistos.py.

compareRootHistos.ltest = rec(tfp)

Definition at line 409 of file compareRootHistos.py.

compareRootHistos.options

Definition at line 393 of file compareRootHistos.py.

compareRootHistos.parser = OptionParser()

Definition at line 386 of file compareRootHistos.py.

string compareRootHistos.ref = 'REFERENCE'

Definition at line 14 of file compareRootHistos.py.

compareRootHistos.referenceFile

Definition at line 402 of file compareRootHistos.py.

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

Definition at line 425 of file compareRootHistos.py.

compareRootHistos.state = comparePaths(ts, tp)

Definition at line 422 of file compareRootHistos.py.

string compareRootHistos.test = 'TEST'

Definition at line 15 of file compareRootHistos.py.

compareRootHistos.testFile

Definition at line 402 of file compareRootHistos.py.

string compareRootHistos.tfp = TFile(referenceFile, 'REC');print'opening Reference File : %s'

Definition at line 405 of file compareRootHistos.py.

string compareRootHistos.tfs = TFile(testFile, 'REC');print'opening Test File : %s'

Definition at line 404 of file compareRootHistos.py.

tuple compareRootHistos.tp = (test, dtest)

Definition at line 415 of file compareRootHistos.py.

tuple compareRootHistos.ts = (ref, dref)

Definition at line 414 of file compareRootHistos.py.

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

Definition at line 385 of file compareRootHistos.py.