Public Member Functions
def	__init__ (self, name, baseObjectTypes=[], mcOnly=[], variables=[])

def	__repr__ (self)

def	addSubObjects (self, sos)

def	addVariables (self, newvars)

def	allBases (self)

def	allVars (self, isMC)

def	ownVars (self, isMC)

def	removeVariable (self, name)

Public Attributes
	baseObjectTypes

	mcOnly

	name

	subObjects

	variables

Private Attributes
	_subObjectVars

Detailed Description

Type defining a collection of variables associated to a single object. Contans NTupleVariable and NTupleSubObject

Definition at line 36 of file autovars.py.

Constructor & Destructor Documentation

def core.autovars.NTupleObjectType.__init__	(	self,
		name,
		baseObjectTypes = `[]`,
		mcOnly = `[]`,
		variables = `[]`
	)

Definition at line 38 of file autovars.py.

     def __init__(self,name,baseObjectTypes=[],mcOnly=[],variables=[]):
         self.name = name
         self.baseObjectTypes = baseObjectTypes
         self.mcOnly = mcOnly
         self.variables = []
         self.subObjects = []
         for v in variables:
            if issubclass(v.__class__,NTupleSubObject):
                 self.subObjects.append(v)
            else:
                 self.variables.append(v)
         self._subObjectVars = {}

Member Function Documentation

def core.autovars.NTupleObjectType.__repr__ ( self )

Definition at line 118 of file autovars.py.

     def __repr__(self):
         return "<NTupleObjectType[%s]>" % self.name

def core.autovars.NTupleObjectType.addSubObjects	(	self,
		sos
	)

Definition at line 103 of file autovars.py.

     def addSubObjects(self,sos):
         currentnames = [v.name for v in self.subObjects]
         uniquenewobjs = []
         for ob in sos:
             if ob.name in uniquenewobjs: raise RuntimeError("Duplicate definition of sub-object %s while adding it to object type %s" % (ob.name,self.name))
             uniquenewobjs.append(ob.name)
             if ob.name not in currentnames:
                 self.subObjects.append(ob)
             else:
               raise RuntimeError("Sub-object %s is already present in object type %s" % (ob.name,self.name))
         self._subObjectVars.clear() # clear and update cache of subobj variables
         mynewvars = self.allVars(True)
         mynewvars = self.allVars(False)

def core.autovars.NTupleObjectType.addVariables	(	self,
		newvars
	)

Definition at line 93 of file autovars.py.

     def addVariables(self,newvars):
         currentnames = [v.name for v in self.allVars(True)] # require no conflict with all variables, including mcOnly ones
         uniquenewvars = []
         for var in newvars:
             if var.name in uniquenewvars: raise RuntimeError("Duplicate definition of variable %s while adding variables to object type %s" % (var.name,self.name))
             uniquenewvars.append(var.name)
             if var.name not in currentnames:
                 self.variables.append(var)
             else:
               raise RuntimeError("Variable %s is already present in object type %s" % (var.name,self.name))

def core.autovars.NTupleObjectType.allBases ( self )

Definition at line 84 of file autovars.py.

References core.autovars.NTupleObjectType.baseObjectTypes.

Referenced by core.autovars.NTupleObjectType.allVars().

     def allBases(self):
         ret = []
         for b in self.baseObjectTypes:
             if b not in ret: 
                 ret.append(b)
             for b2 in b.allBases():
                 if b2 not in ret:
                     ret.append(b2)
         return ret

def core.autovars.NTupleObjectType.allVars	(	self,
		isMC
	)

Return all vars, including the base ones. Duplicate bases are not added twice

Definition at line 69 of file autovars.py.

Referenced by core.autovars.NTupleObjectType.addSubObjects(), and core.autovars.NTupleObjectType.addVariables().

     def allVars(self,isMC):
         """Return all vars, including the base ones. Duplicate bases are not added twice"""
         ret = []; names = {}
         if not isMC and self.mcOnly: return []
         for base in self.allBases():
             if not isMC and base.mcOnly: continue
             for var in base.ownVars(isMC):
                 if var.name in names: raise RuntimeError("Duplicate definition of variable %s from %s and %s" % (var.name, base.name, names[var.name]))
                 names[var.name] = base.name
                 ret.append(var)
         for var in self.ownVars(isMC):
             if var.name in names: raise RuntimeError("Duplicate definition of variable %s from %s and %s" % (var.name, self.name, names[var.name]))
             names[var.name] = self.name
             ret.append(var)
         return ret

def core.autovars.NTupleObjectType.ownVars	(	self,
		isMC
	)

Return only my vars, not including the ones from the bases

Definition at line 50 of file autovars.py.

References core.autovars.NTupleObjectType._subObjectVars, core.autovars.NTupleObjectType.subObjects, core.autovars.NTupleObjectType.variables, and TaggingVariablePlotter.variables.

Referenced by core.autovars.NTupleObjectType.allVars().

     def ownVars(self,isMC):
         """Return only my vars, not including the ones from the bases"""
         vars = [ v for v in self.variables if (isMC or not v.mcOnly) ]
         if self.subObjects:
             if isMC not in self._subObjectVars:
                 subvars = []
                 for so in self.subObjects:
                     if so.mcOnly and not isMC: continue
                     for subvar in so.objectType.allVars(isMC):
                         subvars.append(NTupleVariable(so.name+"_"+subvar.name,
                                   #DebugComposer(so,subvar),#lambda object : subvar(so(object)),
                                   lambda object, subvar=subvar, so=so : subvar(so(object)), 
                                   # ^-- lambda object : subvar(so(object)) doesn't work due to scoping, see
                                   #     http://stackoverflow.com/questions/2295290/what-do-lambda-function-closures-capture-in-python/2295372#2295372
                                   type = subvar.type, help = subvar.help, default = subvar.default, mcOnly = subvar.mcOnly,
                                   filler = subvar.filler))
                 self._subObjectVars[isMC] = subvars
             vars += self._subObjectVars[isMC]
         return vars