Classes
class	LumiInfo

class	LumiInfoCont

Functions
def	loadEvents (filename, cont, options)

def	makeEDFplot (lumiCont, eventsDict, totalWeight, outputFile, options)

Variables
	action

	allowedEDF
	command line options ## More...

	args

	cont
	load Luminosity info ## More...

	default

	description

	dest

	done

	eventsDict
	make EDF plots ## More...

	help

	inputGroup

	maxIntLum

	maxRun

	minIntLum

	minRun

	modeGroup

	nonSpaceRE

	options

	parser

	pieces

	plotGroup

	prevRecLumi

	rangeGroup

	recLumIndex

	recLumis
	look for which runs correspond to what total ## recorded integrated luminosity ## More...

	recLumValue

	sepRE

	totalWeight

	type

Function Documentation

◆ loadEvents()

def generateEDF.loadEvents	(	filename,
		cont,
		options
	)

General Functions

Definition at line 241 of file generateEDF.py.

 def loadEvents (filename, cont, options):
     eventsDict = {}
     print("loading events from '%s'" % filename)
     events = open (filename, 'r')
     runIndex, lumiIndex, eventIndex, weightIndex = 0, 1, 2, 3
     if options.relOrder:
         lumiIndex, eventIndex = 2,1
     minPieces = 3
     totalWeight = 0.
     if options.weights:
         minPieces = 4
     for line in events:
         pieces = sepRE.split (line.strip())
         if len (pieces) < minPieces:
             if nonSpaceRE.search (line):
                 print("skipping", line)
             continue
         try:
             run, lumi, event = int( pieces[runIndex]   ), \
                                int( pieces[lumiIndex]  ), \
                                int( pieces[eventIndex] )
         except:
             continue
         key = (run, lumi)
         if key not in cont:
             if options.ignore:
                 print("Warning, %s is not found in the lumi information" \
                       % key.__str__())
                 continue
             else:
                 raise RuntimeError("%s is not found in lumi information.  Use '--ignoreNoLumiEvents' option to ignore these events and continue." \
                       % key.__str__())
         if options.edfMode != 'time' and not cont[key].xingInfo:
             if options.ignore:
                 print("Warning, %s does not have Xing information" \
                       % key.__str__())
                 continue
             else:
                 raise RuntimeError("%s  does not have Xing information.  Use '--ignoreNoLumiEvents' option to ignore these events and continue." \
                       % key.__str__())            
         if options.weights:
             weight = float (pieces[weightIndex])
         else:
             weight = 1
         eventsDict.setdefault( key, []).append( (event, weight) )
         totalWeight += weight
     events.close()
     return eventsDict, totalWeight
  
  

References mps_setup.append, createfilelist.int, and edm.print().

◆ makeEDFplot()

def generateEDF.makeEDFplot	(	lumiCont,
		eventsDict,
		totalWeight,
		outputFile,
		options
	)

Definition at line 291 of file generateEDF.py.

 def makeEDFplot (lumiCont, eventsDict, totalWeight, outputFile, options):
     # make TGraph
     xVals      = [0]
     yVals      = [0]
     expectedVals = [0]
     predVals   = [0]
     weight = 0
     expectedChunks = []
     
     if 'time' == options.edfMode:
         # if we have a minimum run number, clear the lists
         if lumiCont.minRun or lumiCont.minIntLum:
             xVals      = []
             yVals      = []
             expectedVals = []
             predVals   = []
         # loop over events
         for key, eventList in sorted( six.iteritems(eventsDict) ):
             usePoints = True
             # should we add this point?
             if lumiCont.minRun and lumiCont.minRun > key[0] or \
                lumiCont.maxRun and lumiCont.maxRun < key[0]:
                 usePoints = False
             for event in eventList:
                 weight += event[1]
                 if not usePoints:
                     continue
                 factor = old_div(weight, totalWeight)
                 try:
                     intLum = lumiCont[key].totalRecorded
                 except:
                     raise RuntimeError("key %s not found in lumi information" \
                           % key.__str__())
                 if lumiCont.minIntLum and lumiCont.minIntLum > intLum or \
                    lumiCont.maxIntLum and lumiCont.maxIntLum < intLum:
                     continue
                 lumFrac = old_div(intLum, lumiCont.totalRecLum)
                 xVals.append( lumiCont[key].totalRecorded)
                 yVals.append (factor)
                 expectedVals.append (lumFrac)
                 predVals.append   (lumFrac * options.pred)
         # put on the last point if we aren't giving a maximum run
         if not lumiCont.maxRun and not lumiCont.maxIntLum:
             xVals.append (lumiCont.totalRecLum)
             yVals.append (1)
             expectedVals.append (1)
             predVals.append (options.pred)
         
         if options.resetExpected:
             slope = old_div((yVals[-1] - yVals[0]), (xVals[-1] - xVals[0]))
             print("slope", slope)
             for index, old in enumerate (expectedVals):
                 expectedVals[index] = yVals[0] + \
                                     slope * (xVals[index] - xVals[0])
         
         if options.breakExpectedIntLum:
             breakExpectedIntLum = []
             for chunk in options.breakExpectedIntLum:
                 pieces = sepRE.split (chunk)
                 try:
                     for piece in pieces:
                         breakExpectedIntLum.append( float(piece) )
                 except:
                     raise RuntimeError("'%s' from '%s' is not a valid float" \
                           % (piece, chunk))
             breakExpectedIntLum.sort()
             boundaries = []
             breakIndex = 0
             done = False
             for index, xPos in enumerate (xVals):
                 if xPos > breakExpectedIntLum[breakIndex]:
                     boundaries.append (index)
                     while breakIndex < len (breakExpectedIntLum):
                         breakIndex += 1
                         if breakIndex >= len (breakExpectedIntLum):
                             done = True
                             break
                         # If this next position is different, than
                         # we're golden.  Otherwise, let it go through
                         # the loop again.
                         if xPos <= breakExpectedIntLum[breakIndex]:
                             break
                     if done:
                         break
             # do we have any boundaries?
             if not boundaries:
                 raise RuntimeError("No values of 'breakExpectedIntLum' are in current range.")
             # is the first boundary at 0?  If not, add 0
             if boundaries[0]:
                 boundaries.insert (0, 0)
             # is the last boundary at the end?  If not, make the end a
             # boundary
             if boundaries[-1] != len (xVals) - 1:
                 boundaries.append( len (xVals) - 1 )
             rangeList = list(zip (boundaries, boundaries[1:]))
             for thisRange in rangeList:
                 upper = thisRange[1]
                 lower = thisRange[0]
                 slope = old_div((yVals[upper] - yVals[lower]), \
                         (xVals[upper] - xVals[lower]))
                 print("slope", slope)
                 # now go over the range inclusively
                 pairList = []
                 for index in range (lower, upper + 1):
                     newExpected = yVals[lower] + \
                                 slope * (xVals[index] - xVals[lower])
                     pairList.append( (xVals[index], newExpected) )
                     expectedVals[index] = newExpected
                 expectedChunks.append (pairList)
     
     elif 'instLum' == options.edfMode or 'instIntLum' == options.edfMode:
         eventTupList = []
         if not lumiCont.xingInfo:
             raise RuntimeError("Luminosity Xing information missing.")
         for key, eventList in sorted( six.iteritems(eventsDict) ):
             try:
                 lumi =  lumiCont[key]
                 instLum   = lumi.aveInstLum
                 fracAXIL  = lumi.fracAXILrecorded
                 totalAXIL = lumi.totalAXILrecorded
             except:
                 raise RuntimeError("key %s not found in lumi information" \
                       % key.__str__())
             for event in eventList:
                 eventTupList.append( (instLum, fracAXIL, totalAXIL, key,
                                       event[0], event[1], ) )
         eventTupList.sort()
         for eventTup in eventTupList:
             weight += eventTup[5]
             factor = old_div(weight, totalWeight)
             if 'instLum' == options.edfMode:
                 xVals.append (eventTup[0])
             else:
                 xVals.append (eventTup[2])
             yVals.append (factor)
             expectedVals.append (eventTup[1])
             predVals.append   (eventTup[1] * options.pred)
     else:
         raise RuntimeError("It looks like Charles screwed up if you are seeing this.")
  
     size = len (xVals)
     step = int (old_div(math.sqrt(size), 2) + 1)
     if options.printValues:
         for index in range (size):
             print("%8f %8f %8f" % (xVals[index], yVals[index], expectedVals[index]), end=' ')
             if index > step:
                 denom = xVals[index] - xVals[index - step]
                 numer = yVals[index] - yVals[index - step]
                 if denom:
                     print(" %8f" % (old_div(numer, denom)), end=' ')
             if 0 == index % step:
                 print(" **", end=' ') 
             print()
         print()
  
     xArray = array.array ('d', xVals)
     yArray = array.array ('d', yVals)
     expected = array.array ('d', expectedVals)
     graph = ROOT.TGraph( size, xArray, yArray)
     graph.SetTitle (options.title)
     graph.SetMarkerStyle (20)
     expectedGraph = ROOT.TGraph( size, xArray, expected)
     expectedGraph.SetLineColor (ROOT.kRed)
     expectedGraph.SetLineWidth (3)
     if options.noDataPoints:
         expectedGraph.SetLineStyle (2)
  
     # run statistical tests
     if options.weights:
         print("average weight per event:", old_div(weight, ( size - 1)))
     maxDistance = ROOT.TMath.KolmogorovTest (size, yArray,
                                              size, expected,
                                              "M")
     prob = ROOT.TMath.KolmogorovProb( maxDistance * math.sqrt( size ) )
  
     # display everything
     ROOT.gROOT.SetStyle('Plain')
     ROOT.gROOT.SetBatch()
     c1 = ROOT.TCanvas()
     graph.GetXaxis().SetRangeUser (min (xVals), max (xVals))
     minValue = min (min(yVals), min(expected))
     if options.pred:
         minValue = min (minValue, min (predVals))
     graph.GetYaxis().SetRangeUser (minValue,
                                    max (max(yVals), max(expected), max(predVals)))
     graph.SetLineWidth (3)
     if options.noDataPoints:
         graph.Draw ("AL")
     else:
         graph.Draw ("ALP")
     if 'instLum' == options.edfMode:
         graph.GetXaxis().SetTitle ("Average Xing Inst. Luminosity (1/ub/s)")
         graph.GetXaxis().SetRangeUser (0., lumiCont.max('aveInstLum'))
     else:
         if 'instIntLum' == options.edfMode:
             graph.GetXaxis().SetTitle ("Integrated Luminosity - Inst. Lum. Ordered (1/%s)" \
                                        % lumiCont.invunits)
         else:
             graph.GetXaxis().SetTitle ("Integrated Luminosity (1/%s)" \
                                        % lumiCont.invunits)
     graph.GetYaxis().SetTitle ("Fraction of Events Seen")
     expectedGraphs = []
     if expectedChunks:
         for index, chunk in enumerate (expectedChunks):
             expectedXarray = array.array ('d', [item[0] for item in chunk])
             expectedYarray = array.array ('d', [item[1] for item in chunk])
             expectedGraph = ROOT.TGraph( len(chunk),
                                          expectedXarray,
                                          expectedYarray )
             expectedGraph.SetLineWidth (3)
             if options.noDataPoints:
                 expectedGraph.SetLineStyle (2)
             if index % 2:
                 expectedGraph.SetLineColor (ROOT.kBlue)
             else:
                 expectedGraph.SetLineColor (ROOT.kRed)
             expectedGraph.Draw("L")
             expectedGraphs.append (expectedGraph)
         exptectedGraph = expectedGraphs[0]
     else:
         expectedGraph.Draw ("L")
     green = 0
     if options.pred:
         predArray = array.array ('d', predVals)
         green = ROOT.TGraph (size, xArray, predArray)
         green.SetLineWidth (3)
         green.SetLineColor (8)
         green.Draw ('l')
     legend = ROOT.TLegend(0.15, 0.65, 0.50, 0.85)
     legend.SetFillStyle (0)
     legend.SetLineColor(ROOT.kWhite)
     observed = 'Observed'
     if options.weights:
         observed += ' (weighted)'
     legend.AddEntry(graph, observed,"PL")
     if options.resetExpected:
         legend.AddEntry(expectedGraph,  "Expected from partial yield","L")
     else:
         legend.AddEntry(expectedGraph,  "Expected from total yield","L")
     if options.pred:
         legend.AddEntry(green, options.predLabel,"L")
     legend.AddEntry("","D_{stat}=%.3f, N=%d" % (maxDistance, size),"")
     legend.AddEntry("","P_{KS}=%.3f" % prob,"")
     legend.Draw()
  
     # save file
     c1.Print (outputFile)
  
  

References dqmMemoryStats.float, list(), SiStripPI.max, min(), and edm.print().

Variable Documentation

◆ action

generateEDF.action

Definition at line 577 of file generateEDF.py.

◆ allowedEDF

generateEDF.allowedEDF

command line options ##

autotoc_md295

## Main

autotoc_md297

Definition at line 561 of file generateEDF.py.

◆ args

generateEDF.args

Definition at line 616 of file generateEDF.py.

◆ cont

generateEDF.cont

load Luminosity info ##

Definition at line 629 of file generateEDF.py.

Referenced by UHTRpacker.addChannel(), GeometricTimingDet.addComponents(), GeometricDet.addComponents(), CaloTowersClient.CaloTowersEndjob(), CaloTowersDQMClient.CaloTowersEndjob(), DTHVStatusHandler.checkForPeriod(), BPHPlusMinusVertex.chkName(), BPHPlusMinusVertex.chkSize(), GeometricTimingDet.deepComponents(), GeometricDet.deepComponents(), HcalObjRepresent::HcalDataContainer< Items, Item >.fillValConts(), SymmetryFit.findUsableMinMax(), MuScleFitUtils.fitMass(), MuScleFitUtils.fitReso(), DirectMTDNavigation.inOutBackward(), DirectMuonNavigation.inOutBackward(), DirectMTDNavigation.inOutBarrel(), DirectMuonNavigation.inOutBarrel(), DirectMTDNavigation.inOutForward(), DirectMuonNavigation.inOutForward(), DQMGenericClient.limitedFit(), hcaldqm::ContainerXXX< int >.load(), DirectMuonNavigation.outInBackward(), DirectMTDNavigation.outInBackward(), DirectMuonNavigation.outInBarrel(), DirectMTDNavigation.outInBarrel(), DirectMuonNavigation.outInForward(), DirectMTDNavigation.outInForward(), PATTauIDEmbedder.PATTauIDEmbedder(), CmsShowNavigator::FileQueue_t::iterator.previous(), cond::XMLAuthenticationService::XMLAuthenticationService.processFile(), TrackProducerWithSCAssociation.produce(), BoostedDoubleSVProducer.produce(), DAFTrackProducerAlgorithm.runWithCandidate(), HcalSimHitsClient.SimHitsEndjob(), stat_mean(), and stat_RMS().

◆ default

generateEDF.default

Definition at line 568 of file generateEDF.py.

◆ description

generateEDF.description

Definition at line 562 of file generateEDF.py.

◆ dest

generateEDF.dest

Definition at line 567 of file generateEDF.py.

◆ done

generateEDF.done

Definition at line 658 of file generateEDF.py.

◆ eventsDict

generateEDF.eventsDict

make EDF plots ##

Definition at line 688 of file generateEDF.py.

◆ help

generateEDF.help

Definition at line 569 of file generateEDF.py.

◆ inputGroup

generateEDF.inputGroup

Definition at line 565 of file generateEDF.py.

◆ maxIntLum

generateEDF.maxIntLum

Definition at line 633 of file generateEDF.py.

◆ maxRun

generateEDF.maxRun

Definition at line 631 of file generateEDF.py.

◆ minIntLum

generateEDF.minIntLum

Definition at line 632 of file generateEDF.py.

◆ minRun

generateEDF.minRun

Definition at line 630 of file generateEDF.py.

◆ modeGroup

generateEDF.modeGroup

Definition at line 566 of file generateEDF.py.

◆ nonSpaceRE

generateEDF.nonSpaceRE

Definition at line 19 of file generateEDF.py.

◆ options

generateEDF.options

Definition at line 616 of file generateEDF.py.

◆ parser

generateEDF.parser

Definition at line 562 of file generateEDF.py.

◆ pieces

generateEDF.pieces

Definition at line 642 of file generateEDF.py.

◆ plotGroup

generateEDF.plotGroup

Definition at line 563 of file generateEDF.py.

◆ prevRecLumi

generateEDF.prevRecLumi

Definition at line 657 of file generateEDF.py.

◆ rangeGroup

generateEDF.rangeGroup

Definition at line 564 of file generateEDF.py.

◆ recLumIndex

generateEDF.recLumIndex

Definition at line 655 of file generateEDF.py.

◆ recLumis

generateEDF.recLumis

look for which runs correspond to what total ## recorded integrated luminosity ##

Definition at line 640 of file generateEDF.py.

◆ recLumValue

generateEDF.recLumValue

Definition at line 645 of file generateEDF.py.

◆ sepRE

generateEDF.sepRE

Definition at line 18 of file generateEDF.py.

◆ totalWeight

generateEDF.totalWeight