generateEDF.LumiInfoCont Class Reference

LumiInfoCont Class

More...

Inheritance diagram for generateEDF.LumiInfoCont:

Public Member Functions
def	__init__ (self, filename, kwargs)
def	__str__ (self)
def	iteritems (self)
def	keys (self)
def	max (self, key)
def	min (self, key)

Public Attributes
	allowNoXing
	invunits
	Now that everything is setup, switch integrated ## luminosity to more reasonable units. More...
	maxIntLum
	maxRun
	minIntLum
	minMaxKeys
	minRun
	noWarnings
	totalRecLum
	xingInfo

Private Member Functions
def	_integrateContainer (self)

Private Attributes
	_max
	_min

Detailed Description

LumiInfoCont Class

Definition at line 105 of file generateEDF.py.

Constructor & Destructor Documentation

def generateEDF.LumiInfoCont.__init__	(		self,
			filename,
			kwargs
	)

Definition at line 107 of file generateEDF.py.

    def __init__ (self, filename, **kwargs):
        print "loading luminosity information from '%s'." % filename
        source = open (filename, 'r')
        self.minMaxKeys = ['totInstLum', 'aveInstLum', 'numXings',
                     'delivered', 'recorded']
        self._min = {}
        self._max = {}
        self.totalRecLum = 0.
        self.xingInfo    = False
        self.allowNoXing = kwargs.get ('ignore')
        self.noWarnings  = kwargs.get ('noWarnings')
        self.minRun      = 0
        self.maxRun      = 0
        self.minIntLum   = 0
        self.maxIntLum   = 0
        
        for key in self.minMaxKeys:
            self._min[key] = -1
            self._max[key] =  0
        for line in source:
            try:
                lumi = LumiInfo (line)
            except:
                continue
            self[lumi.key] = lumi
            self.totalRecLum += lumi.recorded
            if not self.xingInfo and lumi.xingInfo:
                self.xingInfo = True
            if lumi.xingInfo:
                #print "yes", lumi.keyString
                if not self.xingInfo:
                    print "huh?"
            for key in self.minMaxKeys:
                val = getattr (lumi, key)
                if val < self._min[key] or self._min[key] < 0:
                    self._min[key] = val
                if val > self._max[key] or not self._max[key]:
                    self._max[key] = val
        source.close()
        ######################################################
        ## Now that everything is setup, switch integrated  ##
        ## luminosity to more reasonable units.             ##
        ######################################################
        # the default is '1/mb', but that's just silly.
        self.invunits = 'nb'
        lumFactor = 1e3        
        if   self.totalRecLum > 1e9:
            lumFactor = 1e9
            self.invunits = 'fb'
        elif self.totalRecLum > 1e6:
            lumFactor = 1e6
            self.invunits = 'pb'
        # use lumFactor to make everything consistent
        #print "units", self.invunits, "factor", lumFactor
        self.totalRecLum /= lumFactor
        for lumis in self.values():
            lumis.delivered /= lumFactor
            lumis.recorded  /= lumFactor
        # Probably want to rename this next subroutine, but I'll leave
        # it alone for now...
        self._integrateContainer()

Member Function Documentation

def generateEDF.LumiInfoCont.__str__

(

self

)

Definition at line 171 of file generateEDF.py.

    def __str__ (self):
        retval = 'run,     lum     del ( dt  ) inst (#xng)\n'
        for key, value in sorted (six.iteritems(self)):
            retval += "%s\n" % value
        return retval

def generateEDF.LumiInfoCont._integrateContainer (   self )

private

Definition at line 194 of file generateEDF.py.

References generateEDF.LumiInfoCont.allowNoXing, generateEDF.LumiInfoCont.noWarnings, generateEDF.LumiInfoCont.totalRecLum, generateEDF.LumiInfo.xingInfo, and generateEDF.LumiInfoCont.xingInfo.

    def _integrateContainer (self):
        # calculate numbers for recorded integrated luminosity
        total = 0.
        for key, lumi in six.iteritems(self):
            total += lumi.recorded
            lumi.totalRecorded = total
            lumi.fracRecorded  = total / self.totalRecLum
        # calculate numbers for average xing instantaneous luminosity
        if not self.xingInfo:
            # nothing to do here
            return
        xingKeyList = []
        maxAveInstLum = 0.
        for key, lumi in six.iteritems(self):
            if not lumi.xingInfo and not lumi.fixXingInfo():
                if not self.noWarnings:
                    print "Do not have lumi xing info for %s" % lumi.keyString
                if not self.allowNoXing:
                    print "Setting no Xing info flag"
                    self.xingInfo = False
                    return
                continue
            xingKeyList.append( (lumi.aveInstLum, key) )
            if lumi.aveInstLum > maxAveInstLum:
                maxAveInstLum = lumi.aveInstLum
        xingKeyList.sort()
        total = 0.
        for tup in xingKeyList:
            lumi = self[tup[1]]
            total += lumi.recorded
            lumi.totalAXILrecorded = total
            lumi.fracAXILrecorded  = total / self.totalRecLum
            lumi.fracAXIL = lumi.aveInstLum / maxAveInstLum

def generateEDF.LumiInfoCont.iteritems

(

self

)

Definition at line 190 of file generateEDF.py.

    def iteritems (self):
        return sorted (dict.iteritems (self))

def generateEDF.LumiInfoCont.keys

(

self

)

Definition at line 186 of file generateEDF.py.

Referenced by psClasses.queueList.__init__(), psClasses.queueList.smallestQueue(), and psClasses.queueList.thinerQueue().

    def keys (self):
        return sorted (dict.keys (self))

def generateEDF.LumiInfoCont.max	(		self,
			key
	)

Definition at line 182 of file generateEDF.py.

References GeometryComparisonPlotter._max, generateEDF.LumiInfoCont._max, CompareToMedian._max, and CompareLastFilledBin._max.

    def max (self, key):
        return self._max[key]

def generateEDF.LumiInfoCont.min	(		self,
			key
	)

Definition at line 178 of file generateEDF.py.

References GeometryComparisonPlotter._min, generateEDF.LumiInfoCont._min, CompareToMedian._min, and CompareLastFilledBin._min.

    def min (self, key):
        return self._min[key]

Member Data Documentation

generateEDF.LumiInfoCont._max

private

Definition at line 113 of file generateEDF.py.

Referenced by generateEDF.LumiInfoCont.max().

generateEDF.LumiInfoCont._min

private

Definition at line 112 of file generateEDF.py.

Referenced by generateEDF.LumiInfoCont.min().

generateEDF.LumiInfoCont.allowNoXing

Definition at line 116 of file generateEDF.py.

Referenced by generateEDF.LumiInfoCont._integrateContainer().

generateEDF.LumiInfoCont.invunits

Now that everything is setup, switch integrated ## luminosity to more reasonable units.

the default is '1/mb', but that's just silly.

Definition at line 151 of file generateEDF.py.

generateEDF.LumiInfoCont.maxIntLum

Definition at line 121 of file generateEDF.py.

generateEDF.LumiInfoCont.maxRun

Definition at line 119 of file generateEDF.py.

generateEDF.LumiInfoCont.minIntLum

Definition at line 120 of file generateEDF.py.

generateEDF.LumiInfoCont.minMaxKeys

Definition at line 110 of file generateEDF.py.

generateEDF.LumiInfoCont.minRun

Definition at line 118 of file generateEDF.py.

generateEDF.LumiInfoCont.noWarnings

Definition at line 117 of file generateEDF.py.

Referenced by generateEDF.LumiInfoCont._integrateContainer().

generateEDF.LumiInfoCont.totalRecLum

Definition at line 114 of file generateEDF.py.

Referenced by generateEDF.LumiInfoCont._integrateContainer().

generateEDF.LumiInfoCont.xingInfo

Definition at line 115 of file generateEDF.py.

Referenced by generateEDF.LumiInfoCont._integrateContainer().