estimatePileup_makeJSON_2015 Namespace Reference

Functions
def	CalcPileup

Variables
int	aveLumi = 0
dictionary	csvDict = {}
tuple	events = open(options.csvInput, 'r')
dictionary	GapDict = {}
string	help = 'Use CSV file from lumiCalc.py instead of lumiDB'
int	InGap = 0
tuple	inputGroup = optparse.OptionGroup(parser, "Input Options")
int	ipiece = 0
int	LastDelivered = 0
tuple	lastindex = len(OUTPUTLINE)
int	lastLumiS = 0
list	LastValidLumi = []
tuple	LumiArray
tuple	luminometer = str( pieces[14] )
string	LumiString = "[%d,%2.4e,%2.4e,%2.4e],"
int	OldRun = -1
list	output = args[0]
tuple	outputfile = open(output,'w')
string	OUTPUTLINE = ""
	Let's start the fun. More...
tuple	parameters = LumiQueryAPI.ParametersObject()
	## Main Program More...
tuple	parser
list	peakratio = lumiInfo[0]
tuple	pieces = sepRE.split(line.strip())
list	pileup = LastValidLumi[3]
tuple	pileupGroup = optparse.OptionGroup(parser, "Pileup Options")
list	record = lumiInfo[1]
dictionary	runLumiDict = {}
tuple	sepRE = re.compile(r'[\]\[\s,;:]+')
list	trunc = OUTPUTLINE[0:lastindex]
list	xingInstLumiArray

Function Documentation

def estimatePileup_makeJSON_2015.CalcPileup	(		deadTable,
			parameters,
			luminometer,
			mode = 'deadtable'
	)

Given a deadtable, will calculate parameters of pileup distribution. Return formatted
string with LumiSection, LS integrated lumi, RMS of bunch to bunch lumi and pileup.

Definition at line 13 of file estimatePileup_makeJSON_2015.py.

References mathSSE.sqrt().

def CalcPileup (deadTable, parameters, luminometer, mode='deadtable'):
    '''Given a deadtable, will calculate parameters of pileup distribution. Return formatted
    string with LumiSection, LS integrated lumi, RMS of bunch to bunch lumi and pileup.'''

    LumiString = ""
    LumiArray = []

    for lumiSection, deadArray in sorted (deadTable.iteritems()):
        numerator = 0
    if luminometer == "HFOC":
        threshold = 8.
    else:
        threshold = 1.2
        if mode == 'csv':
            numerator     = float (deadArray[1])
            denominator   = float (deadArray[0])
            instLumiArray =        deadArray[2]
            livetime = 1
            if numerator < 0:
                numerator = 0
            if denominator:
                livetime = numerator / denominator
        
    

            #print "params", parameters.lumiSectionLen, parameters.rotationTime

        else:
            print "no csv input! Doh!"
            return
        # totalInstLumi = reduce(lambda x, y: x+y, instLumiArray) # not needed
        if lumiSection > 0:
             TotalLumi = 0 
             TotalInt = 0
             TotalInt2 = 0
             TotalWeight = 0
             TotalWeight2 = 0
             FilledXings = 0
             for xing, xingInstLumi, xingDelvLumi in instLumiArray:
                 #print "Inputs: lum %d: idx %d IntL %f DelivL %f" % (lumiSection, xing, xingInstLumi, xingDelvLumi)
                 xingIntLumi = xingInstLumi * livetime  # * parameters.lumiSectionLen
                 mean = xingInstLumi * parameters.rotationTime / parameters.lumiSectionLen
                 if mean > 100:
                    if runNumber:
                        print "mean number of pileup events > 100 for run %d, lum %d : m %f l %f" % \
                          (runNumber, lumiSection, mean, xingInstLumi)
                    else:
                        print "mean number of pileup events > 100 for lum %d: m %f l %f" % \
                          (lumiSection, mean, xingInstLumi)
                 #print "mean number of pileup events for lum %d: m %f idx %d l %f" % (lumiSection, mean, xing, xingIntLumi)

                 if xingInstLumi > threshold:

                    TotalLumi = TotalLumi+xingIntLumi
                    TotalInt+= mean*xingIntLumi
                    FilledXings = FilledXings+1
                    #print "xing inst lumi %f %f %d" % (xingIntLumi,TotalLumi,FilledXings)

             #compute weighted mean, then loop again to get weighted RMS       
             MeanInt = 0
             if TotalLumi >0:
                 MeanInt = TotalInt/TotalLumi
             for xing, xingInstLumi, xingDelvlumi in instLumiArray:
                 if xingInstLumi > threshold:
                     xingIntLumi = xingInstLumi * livetime # * parameters.lumiSectionLen
                     mean = xingInstLumi * parameters.rotationTime / parameters.lumiSectionLen
                     TotalInt2+= xingIntLumi*(mean-MeanInt)*(mean-MeanInt)
                     TotalWeight+= xingIntLumi
                     TotalWeight2+= xingIntLumi*xingIntLumi



        if ((lumiSection > 0)):
            #print " LS, Total lumi, filled xings %d, %f, %d" %(lumiSection,TotalLumi,FilledXings)
            if FilledXings > 0:
                AveLumi = TotalLumi/FilledXings
            else:
                AveLumi = 0
            RMSLumi = 0
            Denom = TotalWeight*TotalWeight-TotalWeight2
            if TotalLumi > 0 and Denom > 0:
                RMSLumi = sqrt(TotalWeight/(TotalWeight*TotalWeight-TotalWeight2)*TotalInt2)
            LumiString = "[%d,%2.4e,%2.4e,%2.4e]," % (lumiSection, TotalLumi, RMSLumi, MeanInt)
            LumiArray.append(lumiSection)
            LumiArray.append(TotalLumi)  # should really weight by total lumi in LS
            LumiArray.append(RMSLumi)
            LumiArray.append(MeanInt)
            lumiX=MeanInt*parameters.lumiSectionLen*FilledXings*(1./parameters.rotationTime)
    
    #print lumiX
   # if TotalLumi<(lumiX*0.8):
#   print lumiSection
#        print FilledXings
#        print TotalLumi  
#        print lumiX  
#        print numerator
#   print denominator 

    #print FilledXings
    return LumiArray