compareRootHistos Namespace Reference

Functions
def	rec
def	composition
def	comparePaths
def	compareHistos

Variables
list	histos = ['TH1D', 'TH2D', 'TProfile']
string	ser = 'SERIAL'
string	par = 'PARALL'
list	pFile = sys.argv[0]
list	sFile = sys.argv[1]
tuple	tfs = TFile( sFile, 'REC' )
tuple	tfp = TFile( pFile, 'REC' )
tuple	lser = rec(tfs)
tuple	dserial = dict( [(n, o) for n, o in lser] )
tuple	dparall = dict( [(n, o) for n, o in lpar] )
tuple	ts = ( ser, dserial )
tuple	state = comparePaths( ts, tp )

Function Documentation

def compareRootHistos.compareHistos	(		t1,
			t2,
			state
	)

Definition at line 121 of file compareRootHistos.py.

def compareHistos(t1, t2, state) :
  
  ( ((serialObjects,serialHistos),(parallObjects, parallHistos)), (uniqueSerPaths,uniqueSerHistos), (uniqueParPaths,uniqueParHistos), mh ) = state
 
  # deduce which one is parallel, which serial
  if   t1[0]  == ser : ds = t1[1] ; dp = t2[1]
  elif t2[0]  == ser : ds = t2[1] ; dp = t1[1]
  else : print 'Neither tuple is Serial Root file reference?' ; return

  # histocount, objectcount for parallel/serial
  hcp = 0 ; pHistos = []
  hcs = 0 ; sHistos = []
  
  omit = ['/stat/Brunel/MemoryTool/Virtual mem, all entries',
          '/stat/Brunel/MemoryTool/Virtual mem, downscaled']
  omit = []
  
  # find the histos in the serial file
  for k in ds.keys() : 
    if k not in omit : 
      if ds[k].__class__.__name__ in histos : hcs += 1 ; sHistos.append( k )
  # same for parallel
  for k in dp.keys() : 
    if k not in omit : 
      if dp[k].__class__.__name__ in histos : hcp += 1 ; pHistos.append( k )
      

  cEntries   = 0 ; xEntries   = 0 ; diffEntries   = []
  cIntegrals = 0 ; xIntegrals = 0 ; diffIntegrals = []
  passedKol  = 0 ; failedKol  = 0 ; diffKols      = [] ; zeroIntegrals = 0
  kTested    = 0
  notfound   = 0 ; integralMatch = 0 ; otherTest = 0 ; zeroIntegralMatch = 0
  for h in sHistos :
    if h in pHistos : 
      # matching histos to check
      cEntries += 1
      sh = ds[h] ; ph = dp[h]
      # first check entries
      if sh.GetEntries() != ph.GetEntries() : diffEntries.append(h) ; xEntries += 1 ; continue
      # check for (non-zero sum of bin error) && (non-zero integrals) for K-Test
      sBinError = 0.0 ; pBinError = 0.0
      for i in xrange(sh.GetNbinsX()) : sBinError += sh.GetBinError(i)
      for i in xrange(ph.GetNbinsX()) : pBinError += ph.GetBinError(i)
      sint = sh.Integral() ; pint = ph.Integral()
      if (bool(sint) and bool(pint)) and ( sBinError>0 and pBinError>0 ) : 
        kTested += 1
        kTest = sh.KolmogorovTest(ph)
        if int(kTest) : passedKol += 1 
        else          : failedKol += 1 ; diffKols.append(h) # ; print 'KTest result : ', kTest        
      else : 
        # try the integral test?
        otherTest += 1
        if all((sint, pint)) and (sint==pint) : 
          integralMatch += 1
        elif (sint==pint) :
          zeroIntegralMatch += 1
        else : 
            diffIntegrals.append( h )
            xIntegrals += 1
    else :
      notfound += 1 ; print 'not found? ', h

  # report on Failed Entry-Checks      
  print '\n\n'+'-'*80
  print 'Summary of histos with different Entries'
  print '-'*80
  if diffEntries :
    diffEntries.sort()  
    for e in diffEntries : print '\t\t\t%s:\t%i != %i'%( e, int(ds[e].GetEntries()), int(dp[e].GetEntries()) )  
  print '-'*80
  
  # report on Failed Kolmogorov Tests    
  print '\n\n'+'-'*60
  print 'Summary of histos which failed Kolmogorov Test'
  print '-'*60
  if diffKols :
    diffKols.sort()  
    for e in diffKols : 
      result = ds[e].KolmogorovTest(dp[e])
      print '%s\t\t%s :\tK-Test Result :\t %5.16f'%( type(ds[e]), e, result )  
  print '-'*60
  
  # report on Failed Integral Checks
  print '\n\n'+'-'*60
  print 'Summary of histos which failed Integral Check'
  print '-'*60
  if diffIntegrals :
    diffIntegrals.sort()
    for e in diffIntegrals : 
      diff = dp[e].Integral()-ds[e].Integral()
      pc   = (diff*100)/ds[e].Integral()
      print '%s\t\t%s:\t Diff = %5.6f\tPercent Diff to Serial : %5.6f '%( type(ds[e]), e, diff, pc  )
  print '-'*60 + '\n' 
  print '='*80 + '\n'
  
  print '\n' + '='*80
  print 'Comparison : Serial/Parallel ROOT Histo files'
  print '\n\t\tSerial\tParall'
  print '\tObjects : %i\t%i\t\t( p-s = %i )'%( serialObjects, parallObjects, parallObjects-serialObjects )  
  print '\tHistos  : %i\t%i\t\t( p-s = %i )'%( serialHistos,  parallHistos,  parallHistos-serialHistos  )
  print '\t          __________'
  print '\tTotal   : %i\t%i\n'%( serialHistos+serialObjects,  parallHistos+parallObjects  )  
  print 'Objects/Histos unique to Serial File : %i / %i'%( len(uniqueSerPaths)-uniqueSerHistos, uniqueSerHistos )
  print 'Objects/Histos unique to Parall File : %i / %i'%( len(uniqueParPaths)-uniqueParHistos, uniqueParHistos )
  print '\nMatching Histograms valid for Comparison : %i'%( mh )
  print '\nOmissions : '
  for entry in omit : print '\t%s'%( entry )   
  print '\nHistograms for Comparison (after Omissions) : %i'%( mh-len(omit) )  
  print '\n\tHISTOGRAM TESTS : '
  print '\t\tKOLMOGOROV TEST      : %i'%( kTested )
  print '\t\tINTEGRAL TEST        : %i'%( otherTest )
  print '\t\tENTRIES TEST         : %i'%( xEntries )
  print '\t\t                       ____'
  print '\t\tTested               : %i'%( cEntries )  

  print '\n\tDISCREPANCIES : '
  print '\t\tK-Test      : %i'%( failedKol  )
  print '\t\tIntegrals   : %i'%( xIntegrals )    
  print '\t\tEntries     : %i'%( xEntries   )  
  print '\n'+'='*80  

# =================================================================================================