GetLBInfoFromCOOL.py

Go to the documentation of this file.

#
#Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration                                                                                           
#
 
from PyCool import cool
from CoolConvUtilities.AtlCoolLib import indirectOpen
 
class LumiBlock:
    def __init__(self, cool_obj):
 
        self.run, self.lb = getRunLBFromObj(cool_obj)
 
        self.start_time = cool_obj.payload()['StartTime']
        self.end_time   = cool_obj.payload()['EndTime']
        self.key_since  = cool_obj.since()
        self.key_until  = cool_obj.until()
        
        self.inst_lumi_valid   = None
        self.inst_lumi_algid   = None
        self.inst_lumi_offline = None
        
        self.is_atlas_physics  = None
        self.is_stable_beams   = None
        self.l1_live_fraction  = None
 
        self.beam1_intensity   = -1.0
        self.beam2_intensity   = -1.0        
 
    def ReadLumiInfo(self, cool_obj):
        self.inst_lumi       = cool_obj.payload()['LBAvInstLumi']
        self.inst_lumi_valid = cool_obj.payload()['Valid']
        self.inst_lumi_algid = cool_obj.payload()['AlgorithmID']
        
    def ReadPhysicsLumiInfo(self, payload):
        if self.is_atlas_physics is not None:
            raise Exception('ReadPhysicsLumiInfo - duplicate lb=%d' ,self.lb)
 
        self.is_atlas_physics        = payload['AtlasPhysics']
        self.is_stable_beams         = payload['StableBeams']
        self.l1_live_fraction        = payload['LiveFraction']
        self.beam1_intensity         = payload['Beam1Intensity']
        self.beam2_intensity         = payload['Beam2Intensity']
        self.inst_lumi_offline       = payload['InstLumiAll']
        self.inst_lumi_offline_algid = payload['AlgorithmID']
        
    def GetLBSecs(self):
        if not (self.end_time > self.start_time):
            raise Exception('GetLBSecs - invalid start/end times')
        return (self.end_time - self.start_time)*1.0e-9
 
    def GetInstLumi(self):
        if self.inst_lumi_valid == 0:
            return self.inst_lumi
 
        return 0.0        
    
    def GetIntLumi(self):
        if self.inst_lumi_valid == 0:
            return self.inst_lumi*self.GetLBSecs()
 
        return 0.0
 
#==================================================================================================================
class Run:
    def __init__(self, run_number, lbs):
        self.run_number = run_number
        self.lbs        = lbs
        self.lb_first   = None
        self.lb_last    = None
        
        self.int_lumi       = 0
        self.peak_inst_lumi = 0.0
        
        for lb in lbs:
            self.peak_inst_lumi = max([self.peak_inst_lumi, lb.GetInstLumi()])
            
            self.int_lumi += lb.GetIntLumi()
 
            if self.lb_first is None:
                self.lb_first = lb
                self.lb_last  = lb
            else:
                if lb.lb < self.lb_first.lb: self.lb_first = lb
                if lb.lb > self.lb_last.lb:  self.lb_last  = lb
 
    def GetRunStartTime(self):
        return self.lb_first.start_time
 
    def GetRunEndTime(self):
        return self.lb_last.end_time
    
    def GetIntLumiInvPB(self):
        return self.int_lumi*1.0e-6
 
    def GetPeakInstLumi(self):
        return self.peak_inst_lumi
    
    def AsStr(self):
        ip = ('%.0f' ,(self.GetPeakInstLumi())).rjust(5)
        il = ('%.3f' ,(self.GetIntLumiInvPB())).rjust(8)
 
        s = 'Run %s peak lumi=%s int lumi=%s' ,(self.run_number, ip, il)
        
        return s
 
 
#==================================================================================================================
def getRunLBFromObj(obj):
    run = (obj.since() >> 32)
    lb  = (obj.since() & 0xffff)
    return (run, lb)
 
#==================================================================================================================
def getRunLB(beg_run, end_run,dbObj):
    print('INFO::getRunLB - will search for ATLAS runs in the following range:')
    print('INFO::   beg run: ' ,(beg_run))
    print('INFO::   end run: ' ,(end_run))
 
    f=dbObj.getFolder('/TRIGGER/LUMI/LBLB')
    fit = f.browseObjects(beg_run << 32, end_run << 32, cool.ChannelSelection.all())
 
    runs = {}
 
    while fit.goToNext():
        lb = LumiBlock(fit.currentRef())
 
        try:
            runs[lb.run]
        except KeyError:
            runs[lb.run]  = {}
 
        runs[lb.run][lb.lb] = lb
 
    print('INFO::getRunLB - found ', len(runs), ' ATLAS runs')
 
    return runs
 
#==================================================================================================================
def getRunOnlineLumi(runs,dbObj):
 
    print('INFO::getRunOnlineLumi - will read online luminosity for ', len(runs), ' ATLAS runs')
 
    f= dbObj.getFolder('/TRIGGER/LUMI/OnlPrefLumi')
    icount = 0
 
    for run_, lbs in runs.items():
        
        fit = f.browseObjects(run_ << 32, (run_ << 32) + 100000, cool.ChannelSelection(0))
 
        while fit.goToNext():
            obj = fit.currentRef()
 
            run = (obj.since() >> 32)
            lb  = (obj.since() & 0xffff)
 
            if run != run_:
                raise Exception('getRunOnlineLumi - logic error: run=', run, ', run_=', run_)
 
            if lb == 0:
                continue
 
            try:
                lblock = lbs[lb]        
            except KeyError:
                print('WANRING::getRunOnlineLumi - failed to find LumiBlock for run, lb: ', run, lb)
                continue
 
            lblock.ReadLumiInfo(obj)
        
        icount += 1
            
#==================================================================================================================
def GetLumiInfoDic(beg_run, end_run):
    dbInst=indirectOpen("COOLONL_TRIGGER/CONDBR2")
    
    collect_runs = getRunLB(beg_run, end_run,dbInst)
    physics_runs = []
 
    getRunOnlineLumi(collect_runs,dbInst)
    physics_runs = [Run(run, lbs.values()) for run,lbs in collect_runs.items()]
 
    dbInst.closeDatabase()
    
    if len(physics_runs) == 0:
        print('WARNING::Found 0 physics runs')
        return
 
    physics_runs.sort(key = lambda x: x.run_number)
 
    oflDb=indirectOpen('COOLOFL_TRIGGER/CONDBR2')
    
    RunsLumiDic = {}
    for run in physics_runs:
        LumiDic = {}
 
        key_since = run.GetRunStartTime() - 100000
        key_until = run.GetRunEndTime()   + 100000
        
        f = oflDb.getFolder('/TRIGGER/OFLLUMI/LumiAccounting')
        taglist=f.listTags()
        filledTags = {}
        for tag in taglist:
            objs = f.browseObjects(key_since, key_until, cool.ChannelSelection.all(), tag)
            if len(objs) != 0:
                filledTags[tag] = len(objs)
 
        if len(filledTags) == 0:
            print ("ERROR: no filled tag")
            return 
        elif len(filledTags) > 1:
            print ("WARNING: the number filled tags is more than 1")
       
        filledTags = sorted(filledTags.items(),key=lambda x:x[1],reverse=True)
        objs       = f.browseObjects(key_since, key_until, cool.ChannelSelection.all(), filledTags[0][0])
        icount     = 0
        for obj in objs:
            crun = obj.payload()['Run']        
            clb  = obj.payload()['LumiBlock']
 
            if crun != run.run_number:
                continue
 
            for lb in run.lbs:
                if lb.lb == clb:
                    lb.ReadPhysicsLumiInfo(obj.payload())
                    icount += 1                
                    break
 
            i_LB = obj.payload()['LumiBlock']
            LumiDic[i_LB] = {
                'AtlasPhysics' : obj.payload()['AtlasPhysics'],
                'InstLumi'     : obj.payload()['InstLumi']/10000.,
                'LiveFraction' : obj.payload()['LiveFraction'],
                'Duration'     : lb.GetLBSecs(),
                'start_time'   : lb.start_time,
                'end_time'     : lb.end_time
            }
 
        if len(run.lbs) != icount:
            print('WARNING::getRunPhysicsLumi - number of missed lbs=%d' ,(len(run.lbs) - icount))
            print('WARNING::   number of run lbs=%d'     ,(len(run.lbs)))
            print('WARNING::   number of matched lbs=%d' ,(icount))
        
        RunsLumiDic = LumiDic
 
    oflDb.closeDatabase()
    return RunsLumiDic
 
#==================================================================================================================
def printLumiInfo(RunsLumiDic):
    # for run, lumiDic in RunsLumiDic.items():
    for lb, lumiInfo in RunsLumiDic.items():
        # s  = 'Run %d  lb=%4d - AtlasPhysics=%d, InstLumi=%f, LiveFraction=%f, Duration=%f' %( 
            # run,
        s  = 'lb=%4d - AtlasPhysics=%d, InstLumi=%f, LiveFraction=%f, Duration=%f' %( 
            lb,
            lumiInfo['AtlasPhysics'],
            lumiInfo['InstLumi'],
            lumiInfo['LiveFraction'],
            lumiInfo['Duration']
        )
 
        print (s)
 
#==================================================================================================================
if __name__ == '__main__':
    print ("GetRunInfoFromCOOL:  Hello, World !")