Functions
def	recurse (rdir, dqregion, ignorepath, modelrefs=[], displaystring='Draw=PE', displaystring2D='Draw=COLZ', regex=None, startpath=None, hists=None, manglefunc=None)

def	prune (dqregion)

def	paramcount (dqregion)

def	process (infname, confname, options, refs=None)

def	super_process (fname, options)

Variables
	repeatalgorithm

	worst = DQAlgorithm(id='WorstCaseSummary',libname='libdqm_summaries.so')

list	algorithmparameters
	SOME THINGS YOU MIGHT WANT TO EDIT Edit this to change what algorithm is applied (AuxAlgName–xxx) or to disable printing the number of entries for each reference algorithmparameters = [DQAlgorithmParameter('AuxAlgName–Chi2Test_Prob', 1),. More...

	norefalgorithm

	thresh = make_thresholds('Chi2_per_NDF', 1.0, 1.50, 'Chi2Thresholds')

	parser = optparse.OptionParser(usage='usage: %prog [options] inputfile')

	default

	help

	action

	False

	type

	None

	options

	args

	fname = args[0]

def	rv = super_process(fname, options)

Function Documentation

◆ paramcount()

def physval_make_web_display.paramcount ( dqregion )

Definition at line 129 of file physval_make_web_display.py.

 def paramcount(dqregion):
     params = dqregion.getDQParameters()
     if params is None:
         params = []
     subregions = dqregion.getSubRegions()
     if subregions is None:
         subregions = []
     
     return len(params) + sum([paramcount(region) for region in subregions])
  

◆ process()

def physval_make_web_display.process	(	infname,
		confname,
		options,
		refs = `None`
	)

Definition at line 139 of file physval_make_web_display.py.

 def process(infname, confname, options, refs=None):
     import re
     f = ROOT.TFile.Open(infname, 'READ')
     if not f.IsOpen():
         print('ERROR: cannot open %s' % infname)
         return
     
     top_level = DQRegion(id='topRegion',algorithm=worst)
     print('Building tree...')
     refpairs = refs.split(',') if refs else []
     try:
         refdict = dict(_.split(':', 1) for _ in refpairs)
     except Exception as e:
         print(e)
     # "Model" references
     dqrs = [DQReference(reference='%s:same_name' % v, id=k)
             for k, v in list(refdict.items())]
     displaystring = options.drawopt
     if options.refdrawopt:
         displaystring += ',' + (','.join('DrawRef=%s' % _ for _ in options.refdrawopt.split(',')))
     displaystring2D = options.drawopt2D
     if options.drawrefopt2D:
         displaystring2D += ',' + (','.join('DrawRef2D=%s' % _ for _ in options.drawrefopt2D.split(',')))
  
     if options.startpath:
         topindir = f.Get(options.startpath)
         if not topindir:
             raise ValueError("Path %s doesn't exist in input file" % options.startpath)
         topindirname = f.GetPath() + options.startpath.strip('/')
         startpath = options.startpath.strip('/')
     else:
         topindir = f
         topindirname = f.GetPath()
         startpath = None
  
     # make a map for the reference path names
     refstartpaths = options.refstartpath.split(',') if options.refstartpath else []
     try:
         refstartpathdict = dict(_.split(':') for _ in refstartpaths)
         for k, v in refstartpathdict.items():
             refstartpathdict[k] = v.strip('/')
     except Exception as e:
         print(e)
     def refpath_manglefunc(path, id):
         try:
             pfx = refstartpathdict[id]
             # consider also the case where pfx is ''
             return path.replace(':' + (startpath + '/' if startpath else ''), ':' + (pfx +'/' if pfx else ''), 1) 
         except KeyError:
             return path
             
     hists = []
     if options.histlistfile:
         hists = [re.compile(line.rstrip('\n')) for line in open(options.histlistfile)]
         if options.pathregex: print("histlistfile given, pathregex is ignored")
     if options.refmangle:
         import sys
         sys.path.append(os.getcwd())
         import importlib
         manglefunc = importlib.import_module(options.refmangle).mangle
     else:
         manglefunc = refpath_manglefunc
     recurse(topindir, top_level, topindirname, dqrs, displaystring, displaystring2D,
             re.compile(options.pathregex), startpath, hists, manglefunc=manglefunc)
     print('Pruning dead branches...')
     prune(top_level)
     pc = paramcount(top_level)
  
     sublevel = top_level.getSubRegions()[:]
     for x in sublevel:
         top_level.delRelation('DQRegions', x)
         
     print('Writing output')
     writeHanConfiguration( filename = confname , roots = sublevel)
     return pc
  

◆ prune()

def physval_make_web_display.prune ( dqregion )

returns True if we should kill this node
False if we should not

Definition at line 102 of file physval_make_web_display.py.

 def prune(dqregion):
     """
     returns True if we should kill this node
     False if we should not
     """
     params = dqregion.getDQParameters()
     if params is None:
         params = []
     subregions = dqregion.getSubRegions()
     if subregions is None:
         subregions = []
     else:
         subregions = subregions[:]
     # kill subregions
     for sr in subregions:
         if sr is None:
             continue
         if prune(sr):
             dqregion.delRelation('DQRegions', sr)
     subregions = dqregion.getSubRegions()
     if subregions is None:
         subregions = []
     if len(subregions) + len(params) == 0:
         return True
     else:
         return False
  

◆ recurse()

def physval_make_web_display.recurse	(	rdir,
		dqregion,
		ignorepath,
		modelrefs = `[]`,
		displaystring = `'Draw=PE'`,
		displaystring2D = `'Draw=COLZ'`,
		regex = `None`,
		startpath = `None`,
		hists = `None`,
		manglefunc = `None`
	)

Definition at line 38 of file physval_make_web_display.py.

 def recurse(rdir, dqregion, ignorepath, modelrefs=[], displaystring='Draw=PE', displaystring2D='Draw=COLZ', regex=None, startpath=None, hists=None, manglefunc=None):
     if manglefunc is None:
         manglefunc = lambda a, b: a  # noqa: E731
     for key in rdir.GetListOfKeys():
         cl = key.GetClassName(); rcl = ROOT.TClass.GetClass(cl)
         if ' ' in key.GetName():
             print('WARNING: cannot have spaces in histogram names for han config; not including %s %s' % (cl, key.GetName()))
             continue
         if rcl.InheritsFrom('TH1') or rcl.InheritsFrom('TGraph') or rcl.InheritsFrom('TEfficiency'):
             if '/' in key.GetName():
                 print('WARNING: cannot have slashes in histogram names, encountered in directory %s, histogram %s' % (rdir.GetPath(), key.GetName()))
                 continue
             if key.GetName() == 'summary':
                 print('WARNING: cannot have histogram named summary, encountered in %s' % rdir.GetPath())
                 continue
             fpath = rdir.GetPath().replace(ignorepath, '')
             name = (fpath + '/' + key.GetName()).lstrip('/')
             #print rdir.GetPath(), ignorepath, name
             if hists:
                 match = False
                 for hist in hists:
                     if hist.match(name):
                         match = True
                 if not match: continue
             elif regex:
                 if not regex.match(name): continue
             dqpargs = { 'id' : ('' if fpath else 'top_level/') + name,
                         'inputdatasource': (startpath + '/' if startpath else '') + name,
                         }
             if modelrefs:
                 lnewrefs = []
                 for mref in modelrefs:
                     newref = DQReference(manglefunc(mref.getReference().replace('same_name', (startpath + '/' if startpath else '') + name), mref.id))
                     newref.addAnnotation('info', mref.id)
                     lnewrefs.append(newref)
                 dqpargs.update({'algorithm': repeatalgorithm,
                                 'algorithmparameters': algorithmparameters,
                                 'thresholds': thresh,
                                 'references': lnewrefs
                                 })
             else:
                 dqpargs['algorithm'] = norefalgorithm
             dqpar = dqregion.newDQParameter( **dqpargs)
             drawstrs = []
             if not options.normalize: drawstrs.append('NoNorm')
             if options.logy and (cl.startswith('TH1') or cl=='TProfile'): drawstrs.append('LogY')
             if options.logy and (cl.startswith('TH2') or cl=='TProfile2D'): drawstrs.append('LogZ')
             if cl.startswith('TH1'): drawstrs.append(displaystring)
             if cl == 'TProfile': drawstrs.append(displaystring)
             if cl.startswith('TH2') or cl=='TProfile2D': drawstrs.append(displaystring2D)
             if options.scaleref != 1: drawstrs.append('ScaleRef=%f' % options.scaleref)
             if options.ratio: drawstrs.append('RatioPad')
             #if options.ratio: drawstrs.append('Ref2DSignif')
             if options.ratio2D: drawstrs.append('Ref2DRatio')
             if options.ratiorange is not None:
               drawstrs.append('delta(%f)' % options.ratiorange)
  
             drawstrs.append('DataName=%s' % options.title)
             dqpar.addAnnotation('display', ','.join(drawstrs))
             
         elif rcl.InheritsFrom('TDirectory'):
             newregion = dqregion.newDQRegion( key.GetName(), algorithm=worst )
             recurse(key.ReadObj(), newregion, ignorepath, modelrefs, displaystring, displaystring2D, regex, startpath, hists, manglefunc)
  

◆ super_process()

def physval_make_web_display.super_process	(	fname,
		options
	)

Definition at line 215 of file physval_make_web_display.py.

 def super_process(fname, options):
     import shutil, os, sys, contextlib
     import ROOT
     han_is_found = (ROOT.gSystem.Load('libDataQualityInterfaces') != 1)
     if not han_is_found:
         print('ERROR: unable to load offline DQMF; unable to proceed')
         sys.exit(1)
     bname = os.path.basename(fname)
  
     hanconfig = None
     hanhcfg = None
     hanoutput = None
  
     failed = False
     prebuilt_hcfg = False
  
     @contextlib.contextmanager
     def tmpdir():
         import tempfile
         td = tempfile.mkdtemp()
         yield td
         shutil.rmtree(td)
  
     with tmpdir() as hantmpdir:
         try:
             print('====> Processing file %s' % (fname))
             print('====> Generating han configuration file')
             hantmpinput = os.path.join(hantmpdir, bname)
             shutil.copyfile(fname, hantmpinput)
             haninput = hantmpinput
             hanconfig = os.path.join(hantmpdir, 'han.config')
             rv = process(hantmpinput, hanconfig, options, options.reffile)
             #shutil.copy(hanconfig, os.getcwd())
             
             # bad hack. rv = number of histogram nodes
             if rv == 0:
                 print('No histograms to display; exiting with code 0')
                 sys.exit(0)
  
             print('====> Compiling han configuration')
             hanhcfg = os.path.join(hantmpdir, 'han.hcfg')
             ROOT.dqi.HanConfig().AssembleAndSave( hanconfig, hanhcfg )
             print('====> Executing han')
             import resource
             memlimit = resource.getrlimit(resource.RLIMIT_AS)
             resource.setrlimit(resource.RLIMIT_AS, (memlimit[1], memlimit[1]))
             hanoutput = haninput.rpartition('.')[0] + '_han.root'
  
             rv = ROOT.dqi.HanApp().Analyze( hanhcfg, haninput, hanoutput )
             if rv != 0:
                 raise Exception('failure in han')
             if options.amitag:
                 rf = ROOT.TFile.Open(hanoutput, 'UPDATE')
                 HanMetadata.addMetadata(rf, 'AMI', {'AMI Tag': options.amitag})
                 rf.Close()
             if not options.hanonly:
                 print('====> Dumping web display output')
                 from DataQualityUtils import handimod
                 handimod.handiWithComparisons( options.title,
                                             hanoutput,
                                             options.outdir,
                                             '', False, False, 
                                             'https://atlasdqm.web.cern.ch/atlasdqm/js/',
                                             3 if options.jsRoot else 1)
             if options.hanoutput:
                 from pathlib import Path
                 print('====> Copying han output to', options.hanoutput)
                 target = Path(options.hanoutput)
                 try:
                     target.parent.mkdir(parents=True, exist_ok=True)
                 except Exception as e:
                     print('Unable to create %s for some reason: %s' % (target.parent, e))
                     raise Exception('Error during execute') from e
                 shutil.copy2(hanoutput, options.hanoutput)
             print('====> Cleaning up')
             os.unlink(hanoutput)
         except Exception as e:
             print(e)
             import traceback
             traceback.print_exc()
             if 'canonical format' not in str(e):
                 failed = True
         finally:
             try:
                 if not prebuilt_hcfg:
                     os.unlink(hantmpinput)
                     os.unlink(hanconfig)
                     os.unlink(hanhcfg)
                 os.unlink(hanoutput)
             except Exception:
                 pass
         
     return not failed
  
         

Variable Documentation

◆ action

physval_make_web_display.action

Definition at line 320 of file physval_make_web_display.py.

◆ algorithmparameters

list physval_make_web_display.algorithmparameters

Initial value:

1 = [DQAlgorithmParameter('AuxAlgName--Chi2Test_Chi2_per_NDF', 1),

2 DQAlgorithmParameter('RepeatAlgorithm--ResultsNEntries', 1)]

SOME THINGS YOU MIGHT WANT TO EDIT Edit this to change what algorithm is applied (AuxAlgName–xxx) or to disable printing the number of entries for each reference algorithmparameters = [DQAlgorithmParameter('AuxAlgName–Chi2Test_Prob', 1),.

Definition at line 27 of file physval_make_web_display.py.