GaudiProfiling::GenerateGaudiOpts Namespace Reference

Classes
class	XmlDictObject
Functions
def	generateOptions
def	_ConvertDictToXmlRecurse
def	ConvertDictToXml
def	_ConvertXmlToDictRecurse
def	ConvertXmlToDict

---

Function Documentation

def GaudiProfiling::GenerateGaudiOpts::_ConvertDictToXmlRecurse	(		parent,
			dictitem
	)		[private]

Definition at line 93 of file GenerateGaudiOpts.py.

00094                                               :
00095     assert type(dictitem) is not type([])
00096 
00097     if isinstance(dictitem, dict):
00098         for (tag, child) in dictitem.iteritems():
00099             if str(tag) == '_text':
00100                 parent.text = str(child)
00101             elif type(child) is type([]):
00102                 # iterate through the array and convert
00103                 for listchild in child:
00104                     elem = ElementTree.Element(tag)
00105                     parent.append(elem)
00106                     _ConvertDictToXmlRecurse(elem, listchild)
00107             else:                
00108                 elem = ElementTree.Element(tag)
00109                 parent.append(elem)
00110                 _ConvertDictToXmlRecurse(elem, child)
00111     else:
00112         parent.text = str(dictitem)
    

def GaudiProfiling::GenerateGaudiOpts::_ConvertXmlToDictRecurse	(		node,
			dictclass
	)		[private]

Definition at line 123 of file GenerateGaudiOpts.py.

00124                                              :
00125     nodedict = dictclass()
00126     
00127     if len(node.items()) > 0:
00128         # if we have attributes, set them
00129         nodedict.update(dict(node.items()))
00130     
00131     for child in node:
00132         # recursively add the element's children
00133         newitem = _ConvertXmlToDictRecurse(child, dictclass)
00134         if nodedict.has_key(child.tag):
00135             # found duplicate tag, force a list
00136             if type(nodedict[child.tag]) is type([]):
00137                 # append to existing list
00138                 nodedict[child.tag].append(newitem)
00139             else:
00140                 # convert to list
00141                 nodedict[child.tag] = [nodedict[child.tag], newitem]
00142         else:
00143             # only one, directly set the dictionary
00144             nodedict[child.tag] = newitem
00145 
00146     if node.text is None: 
00147         text = ''
00148     else: 
00149         text = node.text.strip()
00150     
00151     if len(nodedict) > 0:            
00152         # if we have a dictionary add the text as a dictionary value (if there is any)
00153         if len(text) > 0:
00154             nodedict['_text'] = text
00155     else:
00156         # if we don't have child nodes or attributes, just set the text
00157         nodedict = text
00158         
00159     return nodedict
        

def GaudiProfiling::GenerateGaudiOpts::ConvertDictToXml

(

xmldict )

Converts a dictionary to an XML ElementTree Element 

Definition at line 113 of file GenerateGaudiOpts.py.

                             :
    """
    Converts a dictionary to an XML ElementTree Element 
    """

    roottag = xmldict.keys()[0]
    root = ElementTree.Element(roottag)
    _ConvertDictToXmlRecurse(root, xmldict[roottag])
    return root

def GaudiProfiling::GenerateGaudiOpts::ConvertXmlToDict	(		root,
			dictclass = XmlDictObject
	)

Converts an XML file or ElementTree Element to a dictionary

Definition at line 160 of file GenerateGaudiOpts.py.

                                                   :
    """
    Converts an XML file or ElementTree Element to a dictionary
    """

    # If a string is passed in, try to open it as a file
    if type(root) == type(''):
        root = ElementTree.parse(root).getroot()
    elif not isinstance(root, ElementTree.Element):
        raise TypeError, 'Expected ElementTree.Element or file path string'

    return dictclass({root.tag: _ConvertXmlToDictRecurse(root, dictclass)})

def GaudiProfiling::GenerateGaudiOpts::generateOptions	(		counter,
			cmask,
			invmask,
			sampling_period,
			startatevent,
			storeresultsat,
			family
	)

Definition at line 4 of file GenerateGaudiOpts.py.

                                                                                                   :
    cmask = map(int, cmask)
    invmask = map(int, invmask)
    sampling_period = map(int, sampling_period)
    startatevent = int(startatevent)

    from Configurables import ApplicationMgr, AuditorSvc, PerfMonAuditor
    app = ApplicationMgr()
    app.AuditAlgorithms = 1
    pfaud = PerfMonAuditor()
    try:
        pfaud.EVENT0 = counter[0]
        pfaud.SP0 = sampling_period[0]
        pfaud.INV0 = int(invmask[0])
        pfaud.CMASK0 = int(cmask[0])
        pfaud.EVENT1 = counter[1]
        pfaud.SP1 = sampling_period[1]
        pfaud.INV1 = int(invmask[1])
        pfaud.CMASK1 = int(cmask[1])
        pfaud.EVENT2 = counter[2]
        pfaud.SP2 = sampling_period[2]
        pfaud.INV2 = int(invmask[2])
        pfaud.CMASK2 = int(cmask[2])
        pfaud.EVENT3 = counter[3]
        pfaud.SP3 = sampling_period[3]
        pfaud.INV3 = int(invmask[3])
        pfaud.CMASK3 = int(cmask[3])
    except IndexError:
        pass
    pfaud.FAMILY = family
    pfaud.PREFIX = "%s_%s" % (storeresultsat, "S" if sampling_period[0] > 0 else "C") # for <2.5 Python use: test and true_value or false_value
    pfaud.SAMPLE = int(sampling_period[0] > 0)
    pfaud.START_AT_EVENT = startatevent
    #pfaud.LEVEL = 5
    AuditorSvc().Auditors.append(pfaud)
    print pfaud