Functions
def	genObjectDef (mylist, tuple, alias, label, type, etaPhiFound)

def	genObjNameDef (line)

def	getObjectList (objectName, base, verbose=False, memberData=False)

Variables
	action

	alphaRE

	args

	colonRE

	default

	defsDict

	defTemplate

	dest

	dotRE

	etaPhiFound

	genDef

	goName

	help

	mylist

	nonAlphaRE

	objectName

	options

	outputFile

	parser

	root2GOtypeDict

	startString

	targetFile

	tupleDef

	type

	vetoedTypes

Function Documentation

◆ genObjectDef()

def useReflexToDescribeForGenObject.genObjectDef	(	mylist,
		tuple,
		alias,
		label,
		type,
		etaPhiFound
	)

Does something, but I can't remembrer what...

Definition at line 161 of file useReflexToDescribeForGenObject.py.

 def genObjectDef (mylist, tuple, alias, label, type, etaPhiFound):
     """Does something, but I can't remembrer what... """
     print("tuple %s alias %s label %s type %s" % (tuple, alias, label, type))
     # first get the name of the object
     firstName = mylist[0][0]
     match = alphaRE.match (firstName)
     if not match:
         raise RuntimeError("firstName doesn't parse correctly. (%s)" \
               % firstName)
     genName = match.group (1)
     genDef =  " ## GenObject %s Definition ##\n[%s]\n" % \
              (genName, genName)
     if options.index or not etaPhiFound:
         # either we told it to always use index OR either eta or phi
         # is missing.
         genDef += "-equiv: index,0\n";
     else:
         genDef += "-equiv: eta,0.1 phi,0.1 index,100000\n";
     tupleDef = '[%s:%s:%s label=%s type=%s]\n' % \
                (genName, tuple, alias, label, type)
  
     for variable in mylist:
         name, func = genObjNameDef (variable[0])
         typeInfo   = variable[1]
         form = defsDict[ typeInfo ]
         genDef   += form % name + '\n'
         tupleDef += "%-40s : %s\n" % (name, func)
     return genDef, tupleDef
  
  

References print().

◆ genObjNameDef()

def useReflexToDescribeForGenObject.genObjNameDef ( line )

Returns GenObject name and ntuple definition function

Definition at line 152 of file useReflexToDescribeForGenObject.py.

 def genObjNameDef (line):
     """Returns GenObject name and ntuple definition function"""
     words = dotRE.split (line)[1:]
     func = ".".join (words)
     name =  "_".join (words)
     name = nonAlphaRE.sub ('', name)
     return name, func
  
  

◆ getObjectList()

def useReflexToDescribeForGenObject.getObjectList	(	objectName,
		base,
		verbose = `False`,
		memberData = `False`
	)

Get a list of interesting things from this object

Definition at line 65 of file useReflexToDescribeForGenObject.py.

 def getObjectList (objectName, base, verbose = False, memberData = False):
     """Get a list of interesting things from this object"""
     # The autoloader needs an object before it loads its dictionary.
     # So let's give it one.
     try:
         rootObjConstructor = getattr (ROOT, objectName)
     except AttributeError as missingAttr:
         if str(missingAttr) in ['double', 'int']:
             print("Do not need to describe doubles or ints")
             sys.exit(0)
         else:
             raise
  
     obj = rootObjConstructor()
     alreadySeenFunction = set()
     vetoedFunction = set()
     etaFound, phiFound = False, False
     global vetoedTypes
     retval = []
     # Put the current class on the queue and start the while loop
     classList = [ ROOT.TClass.GetClass(objectName) ]
     if verbose: print(classList)
     # Uses while because reflixList is really a stack
     while classList:
         alreadySeenFunction.update(vetoedFunction) # skip functions hidden by derived class
         vetoedFunction.clear()
         oneclass = classList.pop (0) # get first element
         print("Looking at %s" % oneclass.GetName ())
         bases = oneclass.GetListOfBases()
         funcs = oneclass.GetListOfMethods()
         if verbose:
             print("baseSize", bases.GetSize())
             print("FunctionMemberSize", funcs.GetSize())
         for baseIndex in range( bases.GetSize() ) :
             classList.append( bases.At(baseIndex).GetClassPointer() )
         for index in range( funcs.GetSize() ):
             funcMember = funcs.At (index)
             # if we've already seen this, don't bother again
             name = funcMember.GetName()
             if verbose:
                 print("name", name)
             if name == 'eta':
                 etaFound = True
             elif name == 'phi':
                 phiFound = True
             if name in alreadySeenFunction:
                 continue
             # make sure this is an allowed return type
             returnType = funcMember.GetReturnTypeName()
             goType     = root2GOtypeDict.get (returnType, None)
             if verbose:
                 print("   type", returnType, goType)
             if not goType:
                 vetoedTypes.add (returnType)
                 if verbose:
                     print("     skipped")
                 continue
             elif verbose:
                 print("     good")
             # only bother printout out lines where it is a const function
             # and has no input parameters.
             if funcMember.Property() & ROOT.kIsConstMethod and not funcMember.GetNargs():
                 retval.append( ("%s.%s()" % (base, name), goType))
                 alreadySeenFunction.add( name )
                 if verbose:
                     print("     added")
             else :
                 vetoedFunction.add( name )
                 if verbose:
                     print("      failed IsConst() and GetNargs()")
         if not memberData:
             continue
         dataList = oneclass.GetListOfDataMembers()
         for index in range( dataList.GetSize() ):
             data = dataList.At( index );
             name = data.GetName()
             dataType = data.GetTypeName()
             goType = root2GOtypeDict.get (dataType, None)
             if not goType:
                 continue
             if verbose:
                 print("name", name, "dataType", dataType, "goType", goType)
             retval.append ( ("%s.%s" % (base, name), goType) )
     retval.sort()
     return retval, etaFound and phiFound
  
  