def __init__(self):
# Database parameters
self.menuReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LVL1/Menu')
self.countsReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LVL1COUNTERS')
self.lbtimeReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBTIME')
self.lblbReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBLB')
self.verbose = False
#self.verbose = True
# Dict of all TrigL1Data objects for the given time interval (keyed by RunLB IOV)
self.trigL1Dict = dict()
self.allL1Triggers = False
# List of all trigger items to read
self.trigList = ['L1_MBTS_2', 'L1_EM30']
# Dictionary of trigger channel number keyed by trigger name
self.trigChan = dict()
self.chanTrig = dict() # reverse order
# Store the lumi block times
self.lblbDict = dict()
def loadLumi(self, runnum):
if self.verbose: print 'Loading luminosity values'
# Instantiate new COOL data reader if not already done
if self.lumi1Reader == None:
self.lumi1Reader = CoolDataReader('COOLOFL_TRIGGER/COMP200',
'/TRIGGER/OFLLUMI/LBLESTOFL')
self.lumi1Reader.setIOVRangeFromRun(runnum)
self.lumi1Reader.setChannel([self.lumi1Channel])
self.lumi1Reader.setTag(self.lumi1Tag)
self.lumi1Reader.readData()
if self.verbose:
print 'Read %d Lumi records' % len(self.lumi1Reader.data)
# Instantiate new COOL data reader if not already done
if self.lumi2Reader == None:
self.lumi2Reader = CoolDataReader('COOLOFL_TRIGGER/COMP200',
'/TRIGGER/OFLLUMI/LBLESTOFL')
self.lumi2Reader.setIOVRangeFromRun(runnum)
self.lumi2Reader.setChannel([self.lumi2Channel])
self.lumi2Reader.setTag(self.lumi2Tag)
self.lumi2Reader.readData()
if self.verbose:
print 'Read %d Lumi records' % len(self.lumi2Reader.data)
def readRunData(self):
# Set up data readers here
# Time->RunLB mapping
self.lbtime = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBTIME')
# RunLB->Time mapping
self.lblb = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBLB')
# ATLAS ready flag
self.ready = CoolDataReader('COOLONL_TDAQ/COMP200',
'/TDAQ/RunCtrl/DataTakingMode')
# For each stable beams time interval, find the run range along with other useful information
for sb in self.stableList:
if self.verbose: print 'Reading run data for %s' % sb
# Time->RunLB mapping
self.lbtime.setIOVRange(sb.startTime, sb.endTime)
self.lbtime.readData()
run = self.lbtime.data[0].payload()['Run']
lb = self.lbtime.data[0].payload()['LumiBlock']
startRunLB = (run << 32) + lb
run = self.lbtime.data[-1].payload()['Run']
lb = self.lbtime.data[-1].payload()['LumiBlock']
endRunLB = (run << 32) + lb
sb.startRunLB = startRunLB
sb.endRunLB = endRunLB
# Now, load the ATLAS ready flag (this is RunLB keyed)
self.ready.setIOVRange(startRunLB, endRunLB)
self.ready.readData()
# Look for first ready lumiblock
sb.readyRunLB = None
for obj in self.ready.data:
if not obj.payload()['ReadyForPhysics']:
continue
sb.readyRunLB = obj.since()
break # Only need first one
# To find time from stable beams to ATLAS ready need to translate ready RunLB back into time
if sb.readyRunLB == None:
sb.dTime = -1.
continue
self.lblb.setIOVRange(sb.readyRunLB, sb.readyRunLB)
self.lblb.readData(
) # Will read one IOV which spans the RunLB when ATLAS ready is declared
sb.dTime = (self.lblb.data[0].payload()['StartTime'] - sb.startTime
) / 1E9 # Cool time is in ns, convert to seconds here
def execute(self):
# Handle command-line switches
self.parseOpts()
# Open outfile if desired
if self.outFile != None:
f = open(self.outFile, 'w')
# Get our COOL folder
lblb = CoolDataReader(self.onlLumiDB, self.onlLBLBFolder)
# Load data for each run specified
for run in self.runList:
lblb.setIOVRangeFromRun(run)
if not lblb.readData():
print 'RunLumiTime - No LBLB data found for run %d!' % run
continue
for obj in lblb.data:
# IOV is equal to (Run << 32) + LB number.
run = obj.since() >> 32
lb = obj.since() & 0xFFFFFFFF
# Time is UTC nanoseconds
startTime = obj.payload()['StartTime']
endTime = obj.payload()['EndTime']
# Write this out as seconds
outstr = "%d %d %f %f" % (run, lb, float(startTime)/1E9, float(endTime)/1E9)
if self.outFile != None:
f.write(outstr+'\n')
else:
print outstr
def loadTrigChannels(self, run):
if self.verbose: print('Loading trigger channel data')
self.trigChan = dict()
for trig in self.trigList:
self.trigChan[trig] = -1
if self.menuReader is None:
self.menuReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LVL1/Menu')
self.menuReader.setIOVRangeFromRun(run)
self.menuReader.readData()
for obj in self.menuReader.data:
trigName = obj.payload()['ItemName']
if trigName in self.trigList:
self.trigChan[trigName] = int(obj.channelId())
for trig in self.trigList:
if self.trigChan[trig] == -1:
print("Couldn't find", trig, "in run", run)
if self.verbose:
print('Found', trig, 'in channel', self.trigChan[trig])
def loadBCIDCali(self, iov):
if self.verbose: print 'Loading BCID luminosity calibrations'
# Instantiate new COOL data reader if not already done
if self.caliReader == None:
self.caliReader = CoolDataReader('COOLONL_TDAQ/COMP200', '/TDAQ/OLC/CALIBRATIONS')
self.caliReader.setIOVRange(iov[0], iov[1])
self.caliReader.readData()
if self.verbose:
print 'Read %d Calibration records' % len(self.caliReader.data)
def loadTrigData(self, run):
if self.verbose: print 'Loading Trigger data'
# Instantiate new COOL data reader if not already done
if self.trigReader == None:
self.trigReader = CoolDataReader('COOLONL_TRIGGER/COMP200', '/TRIGGER/LUMI/PerBcidDeadtime')
self.trigReader.setIOVRangeFromRun(run)
self.trigReader.readData()
if self.verbose:
print 'Read %d Trig records' % len(self.trigReader.data)
def loadBGData(self, run):
if self.verbose: print 'Loading Bunch group data'
# Instantiate new COOL reader if not already done
if self.bgReader == None:
self.bgReader = CoolDataReader('COOLONL_TRIGGER/COMP200', '/TRIGGER/LVL1/BunchGroupContent')
self.bgReader.setIOVRangeFromRun(run)
self.bgReader.readData()
if self.verbose:
print 'Read %d bunch group records' % len(self.bgReader.data)
def loadBCIDMask(self, iov):
if self.verbose: print 'Loading BCID masks'
# Instantiate new COOL data reader if not already done
if self.maskReader == None:
self.maskReader = CoolDataReader('COOLONL_TDAQ/COMP200', '/TDAQ/OLC/LHC/FILLPARAMS')
self.maskReader.setIOVRange(iov[0], iov[1])
self.maskReader.readData()
if self.verbose:
print 'Read %d BCID Mask records' % len(self.maskReader.data)
def loadLHCData(self, iov):
if self.verbose: print 'Loading LHC information'
# Instantiate new COOL data reader if not already done
if self.lhcReader == None:
self.lhcReader = CoolDataReader('COOLOFL_DCS/COMP200', '/LHC/DCS/FILLSTATE')
self.lhcReader.setIOVRange(iov[0], iov[1])
self.lhcReader.readData()
if self.verbose:
print 'Read %d LHC records' % len(self.lhcReader.data)
def loadReadyData(self, run):
if self.verbose: print 'Loading ATLAS ready information'
# Instantiate new COOL data reader if not already done
if self.rdyReader == None:
self.rdyReader = CoolDataReader('COOLONL_TDAQ/COMP200', '/TDAQ/RunCtrl/DataTakingMode')
self.rdyReader.setIOVRangeFromRun(run)
self.rdyReader.readData()
if self.verbose:
print 'Read %d ATLAS ready records' % len(self.rdyReader.data)
def loadTrigCounts(self, run):
if self.verbose:
print('loading Trigger Counts data')
self.liveFracTrig = dict()
if self.countsReader is None:
self.countsReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LVL1COUNTERS')
self.countsReader.setIOVRangeFromRun(run)
# Build channel list
chanList = self.trigChan.values()
chanList.sort()
# Skip any trigger we didn't find
tmpList = []
for chan in chanList:
if chan < 0: continue
tmpList.append(chan)
chanList = tmpList
self.countsReader.setChannel(chanList)
self.countsReader.readData()
for obj in self.countsReader.data:
#if self.verbose:
# print obj.since()>>32, '/', obj.since()&0xFFFFFFFF, obj.channelId(), obj.payload()['BeforePrescale'], obj.payload()['AfterPrescale'], obj.payload()['L1Accept']
# use the string as the dictionary key
ss = obj.since()
if ss not in self.liveFracTrig:
self.liveFracTrig[ss] = dict()
for (trig, chan) in self.trigChan.iteritems():
if chan != obj.channelId(): continue
ratio = 0.
if obj.payload()['AfterPrescale'] > 0:
ratio = float(obj.payload()['L1Accept']) / obj.payload(
)['AfterPrescale']
self.liveFracTrig[ss][trig] = ratio
if self.verbose:
print(obj.since() >> 32, '/',
obj.since() & 0xFFFFFFFF, trig, ratio)
def loadOtherCurrents(self, iov):
if self.verbose: print 'Loading LBDATA Bunch Current information'
if self.lbdataReader == None:
self.lbdataReader = CoolDataReader('COOLONL_TDAQ/CONDBR2',
'/TDAQ/OLC/LHC/LBDATA')
self.lbdataReader.setIOVRange(iov[0], iov[1])
self.lbdataReader.setChannel([0, 1, 2, 3]) # 0 = BPTX, 1 = Fast BCT
self.lbdataReader.readData()
if self.verbose:
print 'Read %d LBDATA Current records' % len(
self.lbdataReader.data)
def loadBCIDLumi(self, iov):
if self.verbose: print 'Loading BCID luminosity values'
# Instantiate new COOL data reader if not already done
if self.lumiReader == None:
# self.lumiReader = CoolDataReader('COOLONL_TDAQ/MONP200', '/TDAQ/OLC/BUNCHLUMIS')
self.lumiReader = CoolDataReader('COOLONL_TDAQ/COMP200', '/TDAQ/OLC/BUNCHLUMIS')
self.lumiReader.setIOVRange(iov[0], iov[1])
self.lumiReader.setChannel([self.lumiChan])
self.lumiReader.readData()
if self.verbose:
print 'Read %d Lumi records' % len(self.lumiReader.data)
def loadLBLB(self, run):
if self.verbose: print 'Loading LBLB data'
# Instantiate new COOL data reader if not already done
if self.lblbReader == None:
self.lblbReader = CoolDataReader('COOLONL_TRIGGER/COMP200', '/TRIGGER/LUMI/LBLB')
self.lblbReader.setIOVRangeFromRun(run)
self.lblbReader.readData()
if self.verbose:
print 'Read %d LBLB records' % len(self.lblbReader.data)
if len(self.lblbReader.data) > 0:
print 'First LB %d/%d' % (self.lblbReader.data[0].since() >> 32, self.lblbReader.data[0].since() & 0xFFFFFFFF)
print 'Last LB %d/%d' % (self.lblbReader.data[-1].since() >> 32, self.lblbReader.data[-1].since() & 0xFFFFFFFF)
def loadBCIDLumi(self, iov):
if self.verbose: print 'Loading BCID luminosity values'
# Instantiate new COOL data reader if not already done
if self.lumiReader == None:
# Switch at start of September
self.lumiReader = CoolDataReader('COOLONL_TDAQ/CONDBR2',
'/TDAQ/OLC/BUNCHLUMIS')
#self.lumiReader.verbose = True
self.lumiReader.setIOVRange(iov[0], iov[1])
self.lumiReader.setChannel(self.lumiChanList)
self.lumiReader.readData()
#self.lumiReader.verbose = False
if self.verbose:
print 'Read %d Lumi records' % len(self.lumiReader.data)
def loadBCIDCurrents(self, iov):
if self.verbose: print 'Loading Bunch Current information'
if self.currReader == None:
# self.currReader = CoolDataReader('COOLONL_TDAQ/MONP200', '/TDAQ/OLC/LHC/BUNCHDATA')
self.currReader = CoolDataReader('COOLONL_TDAQ/CONDBR2',
'/TDAQ/OLC/LHC/BUNCHDATA')
self.currReader.setIOVRange(iov[0], iov[1])
if self.writeExtraCurrents:
self.currReader.setChannel([0, 1]) # 0 = BPTX, 1 = Fast BCT
else:
self.currReader.setChannelId(1) # 0 = BPTX, 1 = Fast BCT
self.currReader.readData()
if self.verbose:
print 'Read %d Current records' % len(self.currReader.data)
def getReadyForPhysicsInRange(period):
"""
returns all runs in the given period which have the ReadyForPhysics flag set in at least 1 LB
"""
print ("Loading COOL libs...")
from CoolLumiUtilities.CoolDataReader import CoolDataReader
print ("Done loading libs, starting now ...")
myReader = CoolDataReader('COOLONL_TDAQ/CONDBR2', '/TDAQ/RunCtrl/DataTakingMode')
runsWithReady = {}
firstRun = min([x for x in period.keys()])
lastRun = max([x for x in period.keys()])+1
since = (firstRun << 32)
until = (lastRun << 32)
myReader.setIOVRange( since, until )
myReader.readData()
for obj in myReader.data:
isReady = (obj.payload()['ReadyForPhysics'] == 1)
if not isReady:
continue
sincerun, sincelb = getRunLBFromU64(obj.since())
untilrun, untillb = getRunLBFromU64(obj.until())
if sincerun != untilrun:
print ("WARNING: ready block crosses run boundaries:", sincerun, untilrun)
if sincerun not in period: continue
if sincerun in runsWithReady:
runsWithReady[sincerun] += [ (sincelb, untillb) ]
else:
runsWithReady[sincerun] = [ (sincelb, untillb) ]
print (runsWithReady)
return runsWithReady
def findScanData(self):
print 'vdMScanMaker.findScanData() called'
# Based on the (text) starting and ending times, find the available scan entries in COOL
# First, convert time strings to COOL IOV times
self.startTimeIOV = timeVal(self.startTime)
if self.startTimeIOV == None:
print 'OflLumiMaker.findScanData - Error converting start time', self.startTime, '!'
sys.exit()
self.endTimeIOV = timeVal(self.endTime)
if self.endTimeIOV == None:
print 'OflLumiMaker.findScanData - Error converting end time', self.endTime, '!'
sys.exit()
# Load the scan data
self.scanData = CoolDataReader(self.tdaqDB, self.scanFolder)
self.scanData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.scanData.readData():
print 'OflLumiMaker.findScanData - No scan data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose or True:
for obj in self.scanData.data:
run = obj.payload()['RunLB'] >> 32
lb = obj.payload()['RunLB'] & 0xFFFFFFFF
print timeString(obj.since(
)), run, lb, (obj.until() - obj.since()) / 1E9, obj.payload(
)['StepProgress'], obj.payload(
)['ScanningIP'], obj.payload()['AcquisitionFlag'], obj.payload(
)['NominalSeparation'], obj.payload()['ScanInPlane']
# Load the beam positions
self.beamData = CoolDataReader(self.tdaqDB, self.beamFolder)
self.beamData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.beamData.readData():
print 'OflLumiMaker.findScanData - No beam separation data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.beamData.data:
run = obj.payload()['RunLB'] >> 32
lb = obj.payload()['RunLB'] & 0xFFFFFFFF
print run, lb, obj.payload()['B1_PositionAtIP_H'], obj.payload(
)['B1_PositionAtIP_V'], obj.payload(
)['B2_PositionAtIP_H'], obj.payload()['B2_PositionAtIP_V']
# Load the fill parameters
self.fillData = CoolDataReader(self.tdaqDB, self.fillFolder)
self.fillData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.fillData.readData():
print 'OflLumiMaker.findScanData - No fill parameters data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.fillData.data:
print obj.payload()['Beam1Bunches'], obj.payload(
)['Beam2Bunches'], obj.payload()['LuminousBunches']
# Load the lbdata parameters
self.lbdataData = CoolDataReader(self.tdaqDB, self.lbdataFolder)
self.lbdataData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.lbdataData.readData():
print 'OflLumiMaker.findScanData - No LBDATA data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.lbdataData.data:
print 'LBDATA', obj.channelId(), obj.payload(
)['Beam1Intensity'], obj.payload()['Beam2Intensity']
# Load the BUNCHDATA parameters
self.bunchData = CoolDataReader(self.tdaqDB, self.bunchFolder)
self.bunchData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.bunchData.readData():
print 'OflLumiMaker.findScanData - No BUNCHDATA data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.bunchData.data:
print 'BUNCHDATA', obj.channelId(), obj.payload(
)['B1BunchAverage'], obj.payload()['B2BunchAverage']
# Load the BUNCHLUMI parameters
self.bunchLumi = CoolDataReader(self.tdaqDB, self.bunchLumiFolder)
self.bunchLumi.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.bunchLumi.readData():
print 'OflLumiMaker.findScanData - No BUNCHLUMIS data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.bunchLumi.data:
print 'BUNCHLUMI', obj.channelId(), obj.payload(
)['AverageRawInstLum']
# Load the luminosity data
self.lumiData = CoolDataReader(self.tdaqDB, self.lumiFolder)
self.lumiData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.lumiData.readData():
print 'OflLumiMaker.findScanData - No LUMINOSITY data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
def execute(self):
self.parseOpts()
# Read offline luminosity
lumiReader = CoolDataReader('COOLOFL_TRIGGER/COMP200',
'/TRIGGER/OFLLUMI/LBLESTOFL')
lumiReader.setChannelId(self.lumiChannel)
lumiReader.setTag(self.lumiTag)
# Read LAr noise bursts
larReader = CoolDataReader('COOLOFL_LAR/COMP200',
'/LAR/BadChannelsOfl/EventVeto')
larReader.setTag('LARBadChannelsOflEventVeto-UPD4-04')
# Time to use with LAr noise
# lbtimeReader = CoolDataReaderCache('COOLONL_TRIGGER/COMP200', '/TRIGGER/LUMI/LBTIME')
lblbReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBLB')
# Read ATLAS ready flag
readyReader = LumiDBCache('COOLONL_TDAQ/COMP200',
'/TDAQ/RunCtrl/DataTakingMode')
for run in self.runList:
print
print 'Generating run', run
rootfile = self.outdir + '/run' + str(run) + '.root'
# Define ntuple - will open existing file if present
nt = TrigNtupleHandler()
nt.fileName = rootfile
nt.open(update=False)
nt.initLBData()
nt.initL1TrigData()
# Load run information
print 'Load trigger information'
th = TriggerHandler()
th.allL1Triggers = True
th.trigList = []
th.loadDataByRun(run)
# Load lumi information
print 'Load lumi information'
lumiReader.setIOVRangeFromRun(run)
lumiReader.readData()
# Read ATLAS ready information
print 'Load ATLAS ready information'
readyReader.reader.setIOVRangeFromRun(run)
readyReader.reader.readData()
# Load time stamps
print 'Load LBLB information'
lblbReader.setIOVRangeFromRun(run)
lblbReader.readData()
startTime = lblbReader.data[0].payload()["StartTime"]
endTime = lblbReader.data[-1].payload()["EndTime"]
# Read bad LAr periods
print 'Load LAr information'
larReader.setIOVRange(startTime, endTime)
larReader.readData()
# Now make a list of bad lumi blocks
print 'Finding bad LBs'
badLB = set()
for larData in larReader.data:
if larData.payload()["EventVeto"] == 0:
continue
tlo = larData.since()
thi = larData.until()
# Find all lumi blocks spanned by this range
for lb in lblbReader.data:
if lb.payload()["EndTime"] <= tlo: continue
ss = lb.since()
if lb.payload()["StartTime"] < tlo:
badLB.add(ss)
print runLBString(ss)
if lb.payload()["StartTime"] < thi:
badLB.add(ss)
print runLBString(ss)
if lb.payload()["StartTime"] > thi: break
# Process
for obj in lumiReader.data:
ss = obj.since()
lumi = obj.payload()["LBAvInstLumi"]
mu = obj.payload()["LBAvEvtsPerBX"]
if ss not in th.trigL1Dict:
continue
trigcount = th.trigL1Dict[ss].TBP[self.trigChan]
dtime = th.trigL1Dict[ss].dtime
if (dtime > 0.):
trigrate = trigcount / dtime
else:
trigrate = 0.
atlasReady = False
readypay = readyReader.getPayload(obj.since())
if readypay != None:
atlasReady = readypay['ReadyForPhysics']
print runLBString(
ss), atlasReady, lumi, mu, trigcount, trigrate,
if trigrate > 0.:
print lumi / trigrate
else:
print
# ATLAS Ready only
if self.ready and (not atlasReady): continue
nt.clear()
nt.lbData.coolStartTime = th.trigL1Dict[ss].startTime
nt.lbData.coolEndTime = th.trigL1Dict[ss].endTime
nt.lbData.startTime = nt.lbData.coolStartTime / 1.E9
nt.lbData.endTime = nt.lbData.coolEndTime / 1.E9
nt.lbData.lbTime = dtime
nt.lbData.run = obj.since() >> 32
nt.lbData.lb = obj.since() & 0xFFFFFFFF
nt.lbData.onlInstLum = lumi
nt.lbData.onlEvtsPerBX = mu
nt.lbData.ready = atlasReady
nt.lbData.larVeto = (ss in badLB)
# And save trigger counts
nt.fillL1Trig(th.trigL1Dict[ss], th.trigChan)
nt.save()
#for chan in range(256):
# print chan, nt.l1TBP[chan]
nt.close()
def findScanData(self):
print 'vdMScanMaker.findScanData() called'
# Based on the (text) starting and ending times, find the available scan entries in COOL
# First, convert time strings to COOL IOV times
self.startTimeIOV = timeVal(self.startTime)
if self.startTimeIOV == None:
print 'OflLumiMaker.findScanData - Error converting start time', self.startTime, '!'
sys.exit()
self.endTimeIOV = timeVal(self.endTime)
if self.endTimeIOV == None:
print 'OflLumiMaker.findScanData - Error converting end time', self.endTime, '!'
sys.exit()
# Load the scan data
self.scanData = CoolDataReader(self.tdaqDB, self.scanFolder)
self.scanData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.scanData.readData():
print 'OflLumiMaker.findScanData - No scan data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
# for obj in self.scanData.data:
# run = obj.payload()['RunLB'] >> 32
# lb = obj.payload()['RunLB'] & 0xFFFFFFFF
# print '%s (%6d/%3d) t=%5.2fs Acq:%5.2f d=%6.3fmm IP:%2d Plane:%2d' % (timeString(obj.since()), run, lb, (obj.until()-obj.since())/1E9, obj.payload()['AcquisitionFlag'], obj.payload()['NominalSeparation'], obj.payload()['ScanningIP'], obj.payload()['ScanInPlane'])
# Load the beam positions
# self.beamData = CoolDataReader(self.tdaqDB, self.beamFolder)
# self.beamData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
# if not self.beamData.readData():
# print 'OflLumiMaker.findScanData - No beam separation data found in range', self.startTime, 'to', self.endTime,'!'
# sys.exit()
# if self.verbose:
# for obj in self.beamData.data:
# run = obj.payload()['RunLB'] >> 32
# lb = obj.payload()['RunLB'] & 0xFFFFFFFF
# print run, lb, obj.payload()['B1_PositionAtIP_H'], obj.payload()['B1_PositionAtIP_V'], obj.payload()['B2_PositionAtIP_H'], obj.payload()['B2_PositionAtIP_V']
# Load the fill parameters
self.fillData = CoolDataReader(self.tdaqDB, self.fillFolder)
self.fillData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.fillData.readData():
print 'OflLumiMaker.findScanData - No fill parameters data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.fillData.data:
print obj.payload()['Beam1Bunches'], obj.payload(
)['Beam2Bunches'], obj.payload()['LuminousBunches']
# Load the lbdata parameters
self.lbdataData = CoolDataReader(self.tdaqDB, self.lbdataFolder)
self.lbdataData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.lbdataData.readData():
print 'OflLumiMaker.findScanData - No LBDATA data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.lbdataData.data:
print 'LBDATA', obj.channelId(), obj.payload(
)['Beam1Intensity'], obj.payload()['Beam2Intensity']
# Load the BUNCHDATA parameters
if self.monp:
self.bunchData = CoolDataReader(self.tdaqMonpDB, self.bunchFolder)
else:
self.bunchData = CoolDataReader(self.tdaqDB, self.bunchFolder)
self.bunchData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
self.bunchData.setChannelId(1) # 0 = BPTX, 1 = Fast BCT
if not self.bunchData.readData():
print 'OflLumiMaker.findScanData - No BUNCHDATA data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.bunchData.data:
print 'BUNCHDATA', obj.channelId(), obj.payload(
)['B1BunchAverage'], obj.payload()['B2BunchAverage']
# Load the BUNCHLUMI parameters
if self.monp:
self.bunchLumi = CoolDataReader(self.tdaqMonpDB,
self.bunchLumiFolder)
else:
self.bunchLumi = CoolDataReader(self.tdaqDB, self.bunchLumiFolder)
self.bunchLumi.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.bunchLumi.readData():
print 'OflLumiMaker.findScanData - No BUNCHLUMIS data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
if self.verbose:
for obj in self.bunchLumi.data:
print 'BUNCHLUMI', obj.channelId(), obj.payload(
)['AverageRawInstLum']
# Load the luminosity data
self.lumiData = CoolDataReader(self.tdaqDB, self.lumiFolder)
self.lumiData.setIOVRange(self.startTimeIOV, self.endTimeIOV)
if not self.lumiData.readData():
print 'OflLumiMaker.findScanData - No LUMINOSITY data found in range', self.startTime, 'to', self.endTime, '!'
sys.exit()
# Load the Lucid currents
self.pmtReader = CoolDataReader('COOLONL_TDAQ/COMP200',
'/TDAQ/OLC/LUCIDCURRENTS')
self.pmtReader.setIOVRange(self.startTimeIOV, self.endTimeIOV)
self.pmtReader.setChannel([0, 1]) # Load total PMT and fiber currents
if not self.pmtReader.readData():
print 'No PMT current data found in range', self.startTime, 'to', self.endTime, '!'
if self.verbose:
for obj in self.pmtReader.data:
print 'LUCIDCURRENTS', obj.channelId(), obj.payload(
)['CurrentSideA'], obj.payload()['CurrentSideC']
def getKeys( listOfRuns, doPrint = False ):
from CoolLumiUtilities.CoolDataReader import CoolDataReader
keysByRun = {}
mySmkReader = CoolDataReader('COOLONL_TRIGGER/CONDBR2', '/TRIGGER/HLT/HltConfigKeys')
myL1pskReader = CoolDataReader('COOLONL_TRIGGER/CONDBR2', '/TRIGGER/LVL1/Lvl1ConfigKey')
myHltpskReader = CoolDataReader('COOLONL_TRIGGER/CONDBR2', '/TRIGGER/HLT/PrescaleKey')
#myBgskReader = CoolDataReader('COOLONL_TRIGGER/CONDBR2', '/TRIGGER/LVL1/BunchGroupKey')
for run in sorted(listOfRuns):
listOfReadyBlocks = listOfRuns[run]
print ("Getting keys for run %i, lbs %r" % (run, listOfReadyBlocks))
since = (run << 32)
until = ((run+1) << 32)
# super master key
mySmkReader.setIOVRange( since, until - 1 )
mySmkReader.readData()
for obj in mySmkReader.data:
smk = obj.payload()['MasterConfigurationKey']
sincerun, sincelb = getRunLBFromU64(obj.since())
untilrun, untillb = getRunLBFromU64(obj.until())
keysByRun.setdefault(run,{})['smk'] = smk
for sincelb, untillb in listOfReadyBlocks:
since = (run << 32) + sincelb
until = (run << 32) + untillb
# l1 prescale keys
myL1pskReader.setIOVRange( since, until )
myL1pskReader.readData()
for obj in myL1pskReader.data:
l1psk = obj.payload()['Lvl1PrescaleConfigurationKey']
sincerun2, sincelb2 = getRunLBFromU64(obj.since())
untilrun2, untillb2 = getRunLBFromU64(obj.until())
if sincelb2 == untillb: break
keysByRun.setdefault(run,{}).setdefault('l1psk',[]).append((l1psk,sincerun2, sincelb2,untilrun2, untillb2-1)) #use same convention as GRL, last lb is included
# hlt prescale keys
myHltpskReader.setIOVRange( since, until )
myHltpskReader.readData()
for obj in myHltpskReader.data:
hltpsk = obj.payload()['HltPrescaleKey']
sincerun2, sincelb2 = getRunLBFromU64(obj.since())
untilrun2, untillb2 = getRunLBFromU64(obj.until())
if sincelb2 == untillb: break
keysByRun.setdefault(run,{}).setdefault('hltpsk',[]).append((hltpsk,sincerun2, sincelb2,untilrun2, untillb2-1)) #use same convention as GRL, last lb is included
## Bunch group key
#myBgskReader.setIOVRange( since, until )
#myBgskReader.readData()
#for obj in myBgskReader.data:
# bgsk = obj.payload()['Lvl1BunchGroupConfigurationKey']
# sincerun2, sincelb2 = getRunLBFromU64(obj.since())
# untilrun2, untillb2 = getRunLBFromU64(obj.until())
# keysByRun.setdefault(run,{}).setdefault('bgsk',[]).append(bgsk)
if doPrint:
print (keysByRun)
return keysByRun
to.setValue(2.)
print to.getValue(), '-> should be 2.0'
to.append(1.)
to.append(2.)
v = to.getList()
print v[0], '-> should be 1.0'
print v[1], '-> should be 2.0'
##### FillParamsUtil
print 'Testing FillParamsUtil'
from ROOT import FillParamsUtil
# Find start/end time of run
lblbReader = CoolDataReader('COOLONL_TRIGGER/COMP200', '/TRIGGER/LUMI/LBLB')
lblbReader.setIOVRangeFromRun(215589)
lblbReader.readData()
iovSince = lblbReader.data[0].payload()['StartTime']
iovUntil = lblbReader.data[-1].payload()['EndTime']
#print iovSince, '-> starting time'
print(iovUntil - iovSince) / (10**9 * 3600), '-> end time'
print "years after 1970", (iovUntil) / (10**9 * 3600 * 24 * 365)
count = 0
fillParamsReader = CoolDataReader("COOLONL_TDAQ/COMP200",
"/TDAQ/OLC/LHC/FILLPARAMS")
fillParamsReader.setIOVRange(iovSince, iovUntil)
for runnum in range(int(subrunlist[1]) + 1):
runList.append(runnum)
else:
print 'Invalid run list segment found:', runstr
sys.exit()
runList.sort()
else:
runList = data2010
print len(runList)
countlb = 0
countpbd = 0
for run in runList:
print run
lblbReader = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBLB')
lblbReader.setIOVRangeFromRun(run)
lblbReader.readData()
iovSince = lblbReader.data[0].payload()['StartTime']
iovUntil = lblbReader.data[-1].payload()['EndTime']
countlb = 0
for obj in lblbReader.data:
countlb += 1
bunchPrbcidDeadtime = CoolDataReader("COOLONL_TRIGGER/COMP200",
"/TRIGGER/LUMI/PerBcidDeadtime")
bunchPrbcidDeadtime.setIOVRangeFromRun(run)
bunchPrbcidDeadtime.readData()
def main():
f1 = "%s::%s" % (db1, options.folderBS)
f2 = "%s::%s" % (db2, options.folderLumi)
print("=" * 100)
print("Comparing: ")
print(" * ", f1, options.tagBS)
print(" * ", f2, options.tagLumi)
print("=" * 100)
requiredForNtuple = ['posX', 'posY', 'posZ', 'sigmaX', 'sigmaY', 'sigmaZ']
checkNtupleProd = all(item in varColl for item in requiredForNtuple)
if not checkNtupleProd:
print('Ntuple will not be filled missing vars')
#Open up required databases
from PyCool import cool
from CoolConvUtilities import AtlCoolLib
cooldbBS = AtlCoolLib.indirectOpen(db1, True, True, False)
cooldbLumi = AtlCoolLib.indirectOpen(db2, True, True, False)
folderBS = cooldbBS.getFolder(options.folderBS)
folderLumi = cooldbLumi.getFolder(options.folderLumi)
from InDetBeamSpotExample.COOLUtils import COOLQuery
coolQuery = COOLQuery()
if options.runMin is not None:
iov1 = options.runMin << 32
if options.runMax is not None:
iov2 = (options.runMax + 1) << 32
else:
iov2 = (options.runMin + 1) << 32
print('Plotting runs %i to %i ' % (iov1, iov2))
else:
print('No run selected -- ERROR')
return
if (iov2 > cool.ValidityKeyMax):
iov2 = cool.ValidityKeyMax
print("Reading data from database")
itrBS = folderBS.browseObjects(iov1, iov2, cool.ChannelSelection.all(),
options.tagBS)
print("...finished getting BS data")
lbDict = dict()
startRLB = 0x7FFFFFFFFFFFFFFF
endRLB = 0
outfile = ROOT.TFile("BeamspotLumi_%i.root" % (options.runMin), "recreate")
ntuple = ROOT.TNtupleD(
'BeamspotLumi', 'BeamSpotLumi',
"x:y:z:sigma_x:sigma_y:sigma_z:run:mu:lumi:year:month:day:hour:minute:epoch"
)
runs = set()
while itrBS.goToNext():
obj = itrBS.currentRef()
since = obj.since()
runBegin = since >> 32
lumiBegin = since & 0xFFFFFFFF
until = obj.until()
runUntil = until >> 32
lumiUntil = until & 0xFFFFFFFF
status = int(obj.payloadValue('status'))
if status != 59:
continue
runs.add(runBegin)
if since < startRLB:
startRLB = since
if until > endRLB:
endRLB = until
values = {}
for var in varColl:
values[var] = float(obj.payloadValue(var))
values[var + 'Err'] = float(obj.payloadValue(var + 'Err'))
values['until'] = until
lbDict[since] = values
print('Runs: ', runs)
lumi = array('d')
xd = array('d')
exd = array('d')
ydDict = {}
eydDict = {}
ydDict2 = {}
sqtrt2pi = math.sqrt(2 * math.pi)
lblb = CoolDataReader('COOLONL_TRIGGER/CONDBR2', '/TRIGGER/LUMI/LBLB')
from DQUtils.sugar import RANGEIOV_VAL, RunLumi
from DQUtils import IOVSet
grlIOVs = IOVSet.from_grl(
"data15_13TeV.periodAllYear_DetStatus-v89-pro21-02_Unknown_PHYS_StandardGRL_All_Good_25ns.xml"
)
grlIOVs += IOVSet.from_grl(
"data16_13TeV.periodAllYear_DetStatus-v89-pro21-01_DQDefects-00-02-04_PHYS_StandardGRL_All_Good_25ns.xml"
)
grlIOVs += IOVSet.from_grl(
"data17_13TeV.periodAllYear_DetStatus-v99-pro22-01_Unknown_PHYS_StandardGRL_All_Good_25ns_Triggerno17e33prim.xml"
)
grlIOVs += IOVSet.from_grl(
"data18_13TeV.periodAllYear_DetStatus-v102-pro22-04_Unknown_PHYS_StandardGRL_All_Good_25ns_Triggerno17e33prim.xml"
)
for run in runs:
iov1 = run << 32
iov2 = (run + 1) << 32
itrLumi = folderLumi.browseObjects(iov1, iov2,
cool.ChannelSelection.all(),
options.tagLumi)
print("...finished getting Lumi data for run %i" % run)
lblb.setIOVRangeFromRun(run)
lblb.readData()
if len(lblb.data) < 1:
print('No LBLB data found!')
continue
# Make time map
lblbMap = dict()
for obj in lblb.data:
lblbMap[obj.since()] = (obj.payload()['StartTime'],
obj.payload()['EndTime'])
while itrLumi.goToNext():
obj = itrLumi.currentRef()
since = obj.since()
runBegin = since >> 32
lumiBegin = since & 0xFFFFFFFF
until = obj.until()
runUntil = until >> 32
lumiUntil = until & 0xFFFFFFFF
inGRL = False
for sinceGRL, untilGRL, grl_states in process_iovs(grlIOVs):
if grl_states[0].since == None:
continue
if (sinceGRL.run <= runBegin and untilGRL.run >= runUntil
and sinceGRL.lumi <= lumiBegin
and untilGRL.lumi >= lumiUntil):
inGRL = True
break
if not inGRL:
continue
mu = float(obj.payloadValue('LBAvEvtsPerBX'))
instlumi = float(obj.payloadValue('LBAvInstLumi'))
#if( mu < 10 or mu > 65 ):
#print 'Mu: %2.1f Run : %d LB: %d - %d Lumi: %f' % (mu,runBegin,lumiBegin,lumiUntil,instlumi)
if since in lbDict:
if lbDict[since]['sigmaX'] > 0.1:
continue
startTime = lblbMap.get(obj.since(), (0., 0.))[0]
endTime = lblbMap.get(lbDict[since]['until'],
(0., 0.))[0] #[1] end of lumiblock
mylumi = (endTime - startTime) / 1e9 * instlumi / 1e9
thisTime = time.gmtime(startTime / 1.e9)
year = thisTime[0]
month = thisTime[1]
day = thisTime[2]
hour = thisTime[3]
mins = thisTime[4]
sec = thisTime[5]
lumi.append(mylumi)
# in fb^-1
xd.append(mu)
exd.append(0)
if options.plotSomething:
for var in varColl:
if not var in ydDict:
ydDict[var] = array('d')
ydDict2[var] = array('d')
eydDict[var] = array('d')
ydDict2[var].append(mu /
(lbDict[since][var] * sqtrt2pi))
ydDict[var].append(lbDict[since][var])
eydDict[var].append(lbDict[since][var + 'Err'])
if checkNtupleProd and lbDict[since]['sigmaZErr'] < 5:
ntuple.Fill(lbDict[since]['posX'], lbDict[since]['posY'],
lbDict[since]['posZ'], lbDict[since]['sigmaX'],
lbDict[since]['sigmaY'],
lbDict[since]['sigmaZ'], runBegin, mu, mylumi,
year, month, day, hour, mins, startTime / 1.e9)
runStart = startRLB >> 32
runEnd = endRLB >> 32
fillStart = fillEnd = 0
timeStart = timeEnd = 0
beamEnergy = 13
try:
timeStart = coolQuery.lbTime(int(startRLB >> 32),
int(startRLB & 0xFFFFFFFF))[0]
except:
pass
try:
timeEnd = coolQuery.lbTime(int(endRLB >> 32),
int(endRLB & 0xFFFFFFFF) - 1)[1]
except:
pass
try:
fillStart = coolQuery.getLHCInfo(timeStart).get('FillNumber', 0)
except:
pass
try:
fillEnd = coolQuery.getLHCInfo(timeEnd).get('FillNumber', 0)
except:
pass
try:
beamEnergy = coolQuery.getLHCInfo(timeStart).get('BeamEnergyGeV', 0)
beamEnergy *= 2e-3
except:
pass
ntuple.Write()
if not options.plotSomething:
return
from InDetBeamSpotExample import ROOTUtils
ROOTUtils.setStyle()
canvas = ROOT.TCanvas('BeamSpotComparison', 'BeamSpotComparison', 1600,
1200)
canvas.cd()
ROOT.gPad.SetTopMargin(0.05)
ROOT.gPad.SetLeftMargin(0.15)
ROOT.gPad.SetRightMargin(0.05)
if not options.plotGraph:
ROOT.gPad.SetRightMargin(0.15)
#Plot each variable
for var in varColl:
if var not in ydDict:
print('Missing yd: ', var)
if var not in eydDict:
print('Missing eyd: ', var)
continue
gr = ROOT.TGraphErrors(len(xd), xd, ydDict[var], exd, eydDict[var])
xmin = min(xd)
xmax = max(xd)
ymin = min(ydDict[var])
ymax = max(ydDict[var])
h = (ymax - ymin)
ymin -= 0.25 * h
ymaxSmall = ymax + 0.25 * h
ymax += 0.75 * h
ymin2 = min(ydDict2[var])
ymax2 = max(ydDict2[var])
h = (ymax2 - ymin2)
ymin2 -= 0.25 * h
ymax2 += 0.75 * h
h = (xmax - xmin)
xmin -= 0.05 * h
xmax += 0.05 * h
#This histogram is made just to make it easier to manipulate the margins
histo = ROOT.TH2D('hd' + var, 'hd' + var, 100, xmin, xmax, 100, ymin,
ymax)
histo.GetYaxis().SetTitle(varDef(var, 'atit', var))
histo.GetXaxis().SetTitle('Average interactions per bunch crossing')
histo.GetZaxis().SetTitle('Entries')
histo2 = ROOT.TH2D('hd2' + var, 'hd2' + var, 100, xmin, xmax, 100,
ymin2, ymax2)
histo2.GetYaxis().SetTitle(
"<Interaction density> @ z=0 [interactions/mm]")
histo2.GetXaxis().SetTitle('Average interactions per bunch crossing')
histo2.GetZaxis().SetTitle('Entries')
histo2W = ROOT.TH2D('hd3' + var, 'hd3' + var, 100, xmin, xmax, 100,
ymin2, ymax2)
histo2W.GetYaxis().SetTitle(
"<Interaction density> @ z=0 [interactions/mm]")
histo2W.GetXaxis().SetTitle('Average interactions per bunch crossing')
histo2W.GetZaxis().SetTitle('Integrated Luminosity (fb^{-1}/bin)')
histoW = ROOT.TH2D('hdW' + var, 'hdW' + var, 100, xmin, xmax, 100,
ymin, ymax)
histoW.GetYaxis().SetTitle(varDef(var, 'atit', var))
histoW.GetXaxis().SetTitle('Average interactions per bunch crossing')
histoW.GetZaxis().SetTitle('Integrated Luminosity (fb^{-1}/bin)')
histoW1D = ROOT.TH1D('hd1D' + var, 'hd1D' + var, 100, ymin, ymaxSmall)
histoW1D.GetXaxis().SetTitle(varDef(var, 'atit', var))
histoW1D.GetYaxis().SetTitle('Integrated Luminosity (fb^{-1}/bin)')
histo.Draw()
if options.plotGraph:
gr.Draw("p")
else:
for mu, x, l in zip(xd, ydDict[var], lumi):
histo.Fill(mu, x)
histoW.Fill(mu, x, l)
histoW1D.Fill(x, l)
for mu, x, l in zip(xd, ydDict2[var], lumi):
histo2.Fill(mu, x)
histo2W.Fill(mu, x, l)
histo.Draw("colz")
histo.Write()
histoW.Write()
histo2.Write()
histo2W.Write()
histoW1D.Write()
# Add some information to the graph
ROOTUtils.atlasLabel(0.53,
0.87,
False,
offset=0.12,
isForApproval=False,
customstring="Internal",
energy='%2.0f' % beamEnergy,
size=0.055)
ROOTUtils.drawText(0.18, 0.87, 0.055, varDef(var, 'title', var))
comments = []
if runStart == runEnd:
comments.append('Run %i' % runStart)
else:
comments.append('Runs %i - %i' % (runStart, runEnd))
if fillStart == fillEnd:
comments.append('Fill %i' % fillStart)
else:
comments.append('Fills %i - %i' % (fillStart, fillEnd))
t1 = time.strftime('%d %b %Y', time.localtime(timeStart))
t2 = time.strftime('%d %b %Y', time.localtime(timeEnd))
if t1 == t2:
comments.append(t1)
else:
comments.append('%s - %s' % (t1, t2))
ROOTUtils.drawText(0.18, 0.81, 0.05, ';'.join(comments), font=42)
canvas.Print("Run_%d_%sVsMu.png" % (options.runMin, var))
canvas.Print("Run_%d_%sVsMu.pdf" % (options.runMin, var))
if not options.plotGraph:
canvas.SetLogz(True)
canvas.Print("Run_%d_%sVsMuLog.png" % (options.runMin, var))
canvas.Print("Run_%d_%sVsMuLog.pdf" % (options.runMin, var))
canvas.SetLogz(False)
histo2.Draw("colz")
ROOTUtils.atlasLabel(0.53,
0.87,
False,
offset=0.12,
isForApproval=False,
customstring="Internal",
energy='%2.0f' % beamEnergy,
size=0.055)
ROOTUtils.drawText(0.18, 0.87, 0.055, "Interaction density")
ROOTUtils.drawText(0.18, 0.81, 0.05, ';'.join(comments), font=42)
canvas.Print("Run_%d_Mu%sVsMu.png" % (options.runMin, var))
canvas.Print("Run_%d_Mu%sVsMu.pdf" % (options.runMin, var))
canvas.SetLogz(True)
canvas.Print("Run_%d_Mu%sVsMuLog.png" % (options.runMin, var))
canvas.Print("Run_%d_Mu%sVsMuLog.pdf" % (options.runMin, var))
canvas.SetLogz(False)
histoW.Draw("colz")
histoW.SetMinimum(0.005)
ROOTUtils.atlasLabel(0.53,
0.87,
False,
offset=0.12,
isForApproval=False,
customstring="Internal",
energy='%2.0f' % beamEnergy,
size=0.055)
ROOTUtils.drawText(0.18, 0.87, 0.055, varDef(var, 'title', var))
ROOTUtils.drawText(0.18, 0.81, 0.05, ';'.join(comments), font=42)
canvas.Print("Run_%d_%sVsMuW.png" % (options.runMin, var))
canvas.Print("Run_%d_%sVsMuW.pdf" % (options.runMin, var))
canvas.SetLogz(True)
canvas.Print("Run_%d_%sVsMuWLog.png" % (options.runMin, var))
canvas.Print("Run_%d_%sVsMuWLog.pdf" % (options.runMin, var))
canvas.SetLogz(False)
histo2W.Draw("colz")
histo2W.SetMinimum(0.01)
ROOTUtils.atlasLabel(0.53,
0.87,
False,
offset=0.12,
isForApproval=False,
customstring="Internal",
energy='%2.0f' % beamEnergy,
size=0.055)
ROOTUtils.drawText(0.18, 0.87, 0.055, "Interaction density")
ROOTUtils.drawText(0.18, 0.81, 0.05, ';'.join(comments), font=42)
canvas.Print("Run_%d_Mu%sVsMuW.png" % (options.runMin, var))
canvas.Print("Run_%d_Mu%sVsMuW.pdf" % (options.runMin, var))
canvas.SetLogz(True)
canvas.Print("Run_%d_Mu%sVsMuWLog.png" % (options.runMin, var))
canvas.Print("Run_%d_Mu%sVsMuWLog.pdf" % (options.runMin, var))
canvas.SetLogz(False)
histoW1D.Draw("colz")
ROOTUtils.atlasLabel(0.53,
0.87,
False,
offset=0.12,
isForApproval=False,
customstring="Internal",
energy='%2.0f' % beamEnergy,
size=0.055)
ROOTUtils.drawText(0.18, 0.87, 0.055, varDef(var, 'title', var))
ROOTUtils.drawText(0.18,
0.81,
0.05,
"#mu=%2.4f RMS=%2.4f" %
(histoW1D.GetMean(), histoW1D.GetRMS()),
font=42)
canvas.Print("Run_%d_%s1D.png" % (options.runMin, var))
canvas.Print("Run_%d_%s1D.pdf" % (options.runMin, var))
canvas.SetLogy(True)
canvas.Print("Run_%d_%s1DLog.png" % (options.runMin, var))
canvas.Print("Run_%d_%s1DLog.pdf" % (options.runMin, var))
canvas.SetLogy(False)
def readData(self, runnum):
# Luminosity folder
if self.verbose: print 'Reading lumi for run %d' % runnum
if self.lumi == None:
if self.online:
self.lumi = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBLESTONL')
else:
self.lumi = CoolDataReader('COOLOFL_TRIGGER/COMP200',
'/TRIGGER/OFLLUMI/LBLESTOFL')
self.lumi.setTag(self.lumiTag)
self.lumi.setChannelId(self.lumiChan)
self.lumi.setIOVRangeFromRun(runnum)
self.lumi.readData()
if self.verbose:
print 'Read %d Luminosity records' % len(self.lumi.data)
# Load stable beam flag (
if self.verbose: print 'Reading ATLAS ready flag'
if self.ardy == None:
self.ardy = LumiDBCache('COOLONL_TDAQ/COMP200',
'/TDAQ/RunCtrl/DataTakingMode')
self.ardy.reader.setIOVRangeFromRun(runnum)
self.ardy.reader.readData()
if self.verbose:
print 'Read %d ATLAS ready records' % len(self.ardy.reader.data)
# Load LBLB data (needed to convert to time)
if self.verbose: print 'Reading LBLB data'
if self.lblb == None:
self.lblb = CoolDataReader('COOLONL_TRIGGER/COMP200',
'/TRIGGER/LUMI/LBLB')
self.lblb.setIOVRangeFromRun(runnum)
self.lblb.readData()
if self.verbose:
print 'Read %d LBLB records' % len(self.lblb.data)
if len(self.lblb.data) > 0:
print 'First LB %d/%d' % (self.lblb.data[0].since() >> 32,
self.lblb.data[0].since()
& 0xFFFFFFFF)
print 'Last LB %d/%d' % (self.lblb.data[-1].since() >> 32,
self.lblb.data[-1].since()
& 0xFFFFFFFF)
# Now figure out starting/ending time
if len(self.lblb.data) < 1:
print 'No LBLB data found!'
return # Nothing to work with
tlo = self.lblb.data[0].payload()['StartTime']
thi = self.lblb.data[-1].payload()['EndTime']
# Fillparams (slow)
if self.verbose: print 'Reading Fillparams'
if self.fill == None:
self.fill = LumiDBCache('COOLONL_TDAQ/COMP200',
'/TDAQ/OLC/LHC/FILLPARAMS')
self.fill.reader.setIOVRange(tlo, thi)
self.fill.reader.readData()
if self.verbose:
print 'Read %d FILLPARAMS records' % len(self.fill.reader.data)
# LHC information (for stable beams)
if self.verbose: print 'Reading LHC information'
if self.lhc == None:
self.lhc = LumiDBCache('COOLOFL_DCS/COMP200', '/LHC/DCS/FILLSTATE')
self.lhc.reader.setIOVRange(tlo, thi)
self.lhc.reader.readData()
if self.verbose:
print 'Read %d LHC records' % len(self.lhc.reader.data)
def __init__(self, dbstr=None, folderstr=None):
self.reader = CoolDataReader(dbstr, folderstr)
self.clearValidity()
def readFillData(self):
# Use defined IOV range and read all data from FILLSTATE folder
# Then parse this to produce a dict with stable beam ranges
# LHC information
if self.verbose: print 'Reading', self.fillFolder
self.fill = CoolDataReader('COOLOFL_DCS/COMP200', '/LHC/DCS/FILLSTATE')
self.fill.setIOVRange(self.startIOV, self.endIOV)
self.fill.readData()
self.stableList = []
stableData = None
# Parse information by going through each record in folder
for obj in self.fill.data:
fillNumber = obj.payload()['FillNumber']
stable = obj.payload()['StableBeams']
# Protection against bogus values
if fillNumber == None:
print 'Fill number is NULL for ', range, '!'
fillNumber = 0
if stable == None:
print 'StableBeams is NULL for ', range, '!'
stable = False
# Check if we are not in stable beams
if not stable:
# Do we have a valid StableData object?
if stableData != None:
# Yes, save it to the list
self.stableList.append(stableData)
stableData = None
continue
# We have found a stable beams period
# Is this new?
if stableData == None:
stableData = StableData()
stableData.startTime = obj.since()
stableData.endTime = obj.until()
stableData.fillNumber = obj.payload()['FillNumber']
continue
# Not new, is this an extension of the previous one?
if obj.since() == stableData.endTime:
# Yes, adjust end time and continue
stableData.endTime = obj.until()
continue
# No, this is a new stable period (note this shouldn't happen, but handle it anyways)
if self.verbose:
print "Found successive records that aren't contiguous in time!"
print stableData
# Save previous
self.stableList.append(stableData)
# Create new
stableData = StableData()
stableData.startTime = obj.since()
stableData.endTime = obj.until()
stableData.fillNumber = obj.payload()['FillNumber']
if self.verbose:
print stableData
# OK, all done
if self.verbose:
for obj in self.stableList:
print obj