python.AtlRunQueryRun.Run Class Reference

Collaboration diagram for python.AtlRunQueryRun.Run:

Public Member Functions
def	AddToShowOrder (cls, key)
def	addGlobalToolTip (cls, var, content)
def	__init__ (self, runNr=0)
def	runNrS (self)
def	data_current_lb (self)
def	NrLBs (self)
def	nr_lb (self)
def	addToolTip (self, var, content)
def	getStableBeamsVector (self)
def	SortedShowOrder (cls)
def	headerkeys (cls)
def	header (cls)
def	addResult (self, resDictKey, value, iov=None, reject=False, valueForStorage=None)
def	runlinks (self)
def	timestr (self, format='html', closed=True)
def	durationstr (self)
def	prettyChain (cls, tr, ps)
def	splitTriggerChains (self, chainlist)
def	__str__ (self)
def	__lt__ (self, other)
def	__eq__ (self, other)
def	astxt (self)

Public Attributes
	runNr
	lhcRun
	sor
	eor
	lastlb
	selDataIncomplete
	showDataIncomplete
	xvecStb
	hasStableBeamsInfo
	result
	stats
	lbtimes
	tooltips
	data
	lumiunit
	lumiunittxt
	instlumiunittxt
	givepeakmuinfo

Static Public Attributes
list	ShowOrder = []
	DisplayOrder = map(re.compile,['#Events','Ready','lhc:|olc:', 'TriggerMenu|SMK|Release|L1 PSK|HLT PSK|BGS|TriggerRates', 'bs:', 'STR:', 'DQ|SHIFTOFL:|LBSUMM:', 'lar:', 'Detector','.*'])
list	PromptCalibRuns = []
dictionary	NemoTasks = {}
bool	showrunnr = False
bool	showtime = False
bool	showduration = False
bool	writehtml = False
string	bgcolor = "1"
list	totevents = [0, 0]
int	runnropen = -1
bool	showCAFLinks = False
string	Datapath = ''
dictionary	Fieldinfo = {}
list	GlobalTooltips = []
string	BeamspotSource = ''
	runPeriods = RunPeriods()
string	TmpBoxContent = ''

Static Private Attributes
	_SortedShowOrder = None

Detailed Description

Definition at line 317 of file AtlRunQueryRun.py.

Constructor & Destructor Documentation

__init__()

def python.AtlRunQueryRun.Run.__init__	(		self,
			runNr = 0
	)

Definition at line 348 of file AtlRunQueryRun.py.

    def __init__(self, runNr=0):
        self.runNr = runNr
        self.lhcRun = 0
        self.sor = 0
        self.eor = 0
        self.lastlb = 0
        self.selDataIncomplete = False
        self.showDataIncomplete = False
        self.xvecStb = []
        self.hasStableBeamsInfo = False
        # the results of the query index by query key
        self.result = {}
        # the run statistics index by query key (filled in selector.runAfterQuery)
        self.stats = {}
        # the start times of all lumiblocks [start_LB1, start_LB2, start_LB3, ..., start_LBN]
        self.lbtimes = []
        self.tooltips = []
        self.data = RunData(run=self)
        # luminosity unil
        self.lumiunit    = 1.0 # default unit
        self.lumiunittxt = 'nb'
        self.instlumiunittxt = '30'
        self.givepeakmuinfo = True
        if self.runNr > 378000:
            # last Run-2 run with SMK 2787 and release AthenaP1,21.1.56 is 376153
            # first Run-3 with SMK 59 and release 22.0.13 is 379453
            self.lhcRun = 3
        elif self.runNr > 249000: 
            # last Run-1 run with SMK 1670 and release AtlasP1HLT,19.3.0.4 is 248373  
            # first Run-2 run with SMK 2002 and release AtlasP1HLT,20.1.0.1 is 249785  
            self.lhcRun = 2
        else:
            self.lhcRun = 1
 
        if self.runNr > 168206 and self.runNr <= 170482:
            self.lumiunit = 1.0e6 # unit is mbarn for heavy ions
            self.lumiunittxt = 'mb'
            self.instlumiunittxt = '24'
            self.givepeakmuinfo = False
 
 

Member Function Documentation

__eq__()

def python.AtlRunQueryRun.Run.__eq__	(		self,
			other
	)

Definition at line 916 of file AtlRunQueryRun.py.

    def __eq__(self,other):
        if isinstance(other,Run):
            return self.runNr == other.runNr
        return self.runNr == other
 
 

__lt__()

def python.AtlRunQueryRun.Run.__lt__	(		self,
			other
	)

Definition at line 911 of file AtlRunQueryRun.py.

    def __lt__(self,other):
        if isinstance(other,Run):
            return self.runNr < other.runNr
        return self.runNr < other
 

__str__()

def python.AtlRunQueryRun.Run.__str__

(

self

)

Definition at line 901 of file AtlRunQueryRun.py.

    def __str__(self):
        if Run.writehtml:
            s = ashtml(self)
            return s
        else:
            s = self.astxt()
            for lbr in self.data:
                s+= "\n" + lbr.astxt()
            return s
 

addGlobalToolTip()

def python.AtlRunQueryRun.Run.addGlobalToolTip	(		cls,
			var,
			content
	)

Definition at line 345 of file AtlRunQueryRun.py.

    def addGlobalToolTip(cls, var, content):
        cls.GlobalTooltips += ['dw_Tooltip.content_vars["%s"] = {content: \'%s\'};' % (var, content.replace("'","'"))]
    

addResult()

def python.AtlRunQueryRun.Run.addResult	(		self,
			resDictKey,
			value,
			iov = None,
			reject = False,
			valueForStorage = None
	)

Definition at line 742 of file AtlRunQueryRun.py.

    def addResult(self, resDictKey, value, iov=None, reject=False, valueForStorage=None):
        if resDictKey=='DQ' and value=='n.a.':
            return
        if resDictKey not in self.result:
            self.result[resDictKey] = value
        if iov:
            if iov.startTime.lb>self.lastlb:
                return # sometimes there are IOVs completely outside the run e.g. run 165821 DQ SHIFTOFL
            iov.endTime = min(iov.endTime, IOVTime(self.runNr,self.lastlb+1) ) 
        self.data.addResult(iov, resDictKey, value, reject, valueForStorage=valueForStorage)
 

addToolTip()

def python.AtlRunQueryRun.Run.addToolTip	(		self,
			var,
			content
	)

Definition at line 405 of file AtlRunQueryRun.py.

    def addToolTip(self, var, content):
        self.tooltips += ['dw_Tooltip.content_vars["%s\"] = {content: \'%s\'};' % (var, content.replace("'","'"))]
 

AddToShowOrder()

def python.AtlRunQueryRun.Run.AddToShowOrder	(		cls,
			key
	)

Definition at line 339 of file AtlRunQueryRun.py.

    def AddToShowOrder(cls,key):
        #print ("ADDING TO SHOWORDER  %r" % key)
        if key not in cls.ShowOrder:
            cls.ShowOrder += [ key ]
 

astxt()

def python.AtlRunQueryRun.Run.astxt

(

self

)

Definition at line 922 of file AtlRunQueryRun.py.

    def astxt(self):
        s = ""
        if Run.showrunnr:
            s += "run %*s  %*s  " % (_fW['Run']-4,self.runNrS, _fW['NLB'], self.NrLBs)
        s += " "
 
        if Run.showtime:
            s += "%*s  " % (_fW['Time'],self.timestr('txt'))
 
        if Run.showduration:
            dt = time.gmtime((self.eor-self.sor)/1.E9)[2:6]
            if dt[0]>1:
                s += "%id %ih %im %is " % ((dt[0]-1,) + dt[1:])
            else:
                s += "%2ih %2im %2is " % dt[1:]
 
        for k in Run.SortedShowOrder():
            w = 10
            if k in _fW:
                w = _fW[k]
            v = self.result[k.ResultKey]
            ostr=v
            if k == "#Events":
                ostr = addKommaToNumber(v)
            elif k.Type == DataKey.STREAM:
                w=max(len(k.Header)-k.Header.find('_'),_fW['Stream'])
                if isinstance(ostr,tuple):
                    ostr = ostr[0]
            elif k=="TriggerMenu":
                pv = [Run.prettyChain(tr,pslist) for (tr,pslist) in v.items() if tr.forshow]
                ostr = ", ".join(pv)
            elif k=="TriggerRates":
                ostr = "NOT YET"
            elif k=="olc:bcidmask":
                ostr = "NOT YET"
 
            s += "%*s  " % (w,ostr)
 
        return s
 
 
 

data_current_lb()

def python.AtlRunQueryRun.Run.data_current_lb

(

self

)

Definition at line 394 of file AtlRunQueryRun.py.

    def data_current_lb(self):
        return self.data.data_current_lb
 

durationstr()

def python.AtlRunQueryRun.Run.durationstr

(

self

)

Definition at line 850 of file AtlRunQueryRun.py.

    def durationstr(self):
        dt = time.gmtime((self.eor-self.sor)/1.E9)[2:6]
        if dt[0]>1:
            return "%id %ih %im %is" % ((dt[0]-1,) + dt[1:])
        else:
            return "%ih %im %is" % dt[1:]
 

getStableBeamsVector()

def python.AtlRunQueryRun.Run.getStableBeamsVector

(

self

)

Definition at line 408 of file AtlRunQueryRun.py.

    def getStableBeamsVector(self):
        if len(self.xvecStb)==0 and 'lhc:stablebeams' in Run.ShowOrder and 'lhc:stablebeams' in self.data:
            entries = self.data['lhc:stablebeams']
            for entry in entries:
                if entry.startlb == 0:
                    continue
                if 'true' in entry.value.lower():
                    self.xvecStb += range(entry.startlb,entry.endlb)
            self.hasStableBeamsInfo = len(self.xvecStb)>0
        return self.hasStableBeamsInfo, self.xvecStb
 

header()

def python.AtlRunQueryRun.Run.header

(

cls

)

Definition at line 456 of file AtlRunQueryRun.py.

    def header(cls):
        if Run.writehtml:
            # flags...
            ofllumiFlag = False
            s = '<tr>\n'
            if Run.showrunnr:
                s += '  <th>Run</th><th>Links</th><th>#LB</th>\n'
            if Run.showtime:
                s += '  <th>Start and endtime (%s)</th>\n' % QC.localStr()
            if Run.showduration:
                s += '  <th>Duration</th>\n'
            for ik, data_key in enumerate(Run.SortedShowOrder()):
                k = data_key.ResultKey
                if k[0:4] == 'STR:':
                    s += '  <th><font size="-2">%s_<BR>%s</font></th>' % tuple(k[4:].split('_',1))
                elif k[0:8] == "Detector":
                    s += '  <th>%s</th>' % k
                elif "SolCurrent" in k:
                    s += '  <th>Solenoid<br>current&nbsp;(A)</th>'
                elif "TorCurrent" in k:
                    s += '  <th>Toroid<br>current&nbsp;(A)</th>'
                elif 'DQ' == k:
                    s += '  '
                    matching_names = dict(Run.Fieldinfo['DQ']['DefMatch'])
                    first = True
                    for channelname in Run.Fieldinfo['DQ']['DefChannels']:
                        tip = "defect_match_%s" % channelname
                        info = "%s # %s" % (channelname if channelname!="" else "*",data_key._second_internal_key if data_key._second_internal_key!="" else "HEAD")
                        s += '<th style="align:center; white-space:nowrap; padding-right: 10px; padding-left: 10px; ">'
                        s += 'Data Quality<br><span class="showTip %s tooltip" style="font-weight:normal; font-size:80%%">(%s)</span>' % (tip, info)
                        if first:
                            s += '<div style="font-size: xx-small; cursor: pointer;" onclick="toggle_dq(this)">[show tolerable]</div>'
                            first = False
                        s += '</th>'
                        
                        allDefects = sorted(matching_names[channelname])
                        n = 4*[len(allDefects)//4]
                        for x in range(len(allDefects) % 4):
                            n[x]+=1
 
                        # put the list of all defects into 4 columns
                        cx = 0
                        columns = []
                        for x in n:
                            columns.append( allDefects[slice(cx,cx+x)] )
                            cx+=x
 
                        for x in columns[1:]: # padding at the end of each column except the first to make zip include the last line
                            x += ['']
 
                        columnsTransposed = zip(*columns) # transpose
 
                        tts = ''
                        for z in columnsTransposed:
                            tts += '<tr>%s</tr>' % ''.join(["<td>%s</td>"% x for x in z])
                        content = '<table style="width:500px; font-size:80%%;">%s</table>' % tts
                        Run.addGlobalToolTip(tip,content)
                    
                elif isDQ(k):
                    foldertag,flag = k.split(':')
 
                    if flag in Run.Fieldinfo:
                        tipname = 'dqvfdesc_%s' % flag
                        commentbox = '%s' % (Run.Fieldinfo[flag])
                        Run.addGlobalToolTip(tipname, commentbox)
                        s += '<th class="showTip %s tooltip" style="cursor:pointer">' % tipname
                    else:
                        s += '  <th>'
 
                    s += '<font size="-1">%s</font><BR><font style="font-weight:normal;font-size:70%%">' % flag
                    if '#' in foldertag:
                        s += '(%s #<br>%s)' % tuple(foldertag.split('#',1))
                    else:
                        s += '(%s)' % (foldertag)
                    s += '</font></th>'
                    
                elif k == "L1 PSK":
                    continue
                elif k == "HLT PSK":
                    s += '  <th>Prescale keys</th>' 
                elif k == "Release":
                    s += '  <th>HLT Release</th>'
                elif k == "Datasets":
                    s += '  <th>Tier-0 Datasets</th>'
                elif k == '#Events (incl. calib.)':
                    s += '  <th>#Events<br><font size="-2">(incl.&nbsp;calib.)</font></th>'
                elif k == '#Events (streamed)'    :
                    s += '  <th>#Events<br><font size="-2">(streamed)</font></th>'
                elif 'lar:' in k:
                    if   'runtype'        in k:
                        s += '  <th><font size="-2">Run type</font></th>' 
                    elif 'nsamples'       in k:
                        s += '  <th><font size="-2">#Samples</font></th>' 
                    elif 'firstsample'    in k:
                        s += '  <th><font size="-2">1st sample</font></th>' 
                    elif 'format'         in k:
                        s += '  <th><font size="-2">Format</font></th>' 
                    else:
                        print ('ERROR: unknown LAr option "%s"' % k)
                        sys.exit(1)
                elif 'lhc:' in k:
                    if   'fillnumber'     in k:
                        s += '  <th>  LHC Fill</th>'
                    elif 'stablebeams'    in k:
                        s += '  <th>Stable beams</th>'
                        if 'lhc:beammode' in Run.ShowOrder:
                            s += '  <th>Beam mode</th>' 
                        if 'lhc:beamenergy' in Run.ShowOrder:
                            s += '  <th>Beam&nbsp;energy and&nbsp;intensities</th>'
                            
                    elif 'beamenergy'     in k:
                        continue # included in 'fillbeams' summary
                    elif 'nbunch1'        in k:
                        s += '  <th>#Bunches B1 <br><font size="-2"><b>(NOT YET RELIABLE)</b></font></th>' 
                    elif 'nbunch2'        in k:
                        s += '  <th>#Bunches B2 <br><font size="-2"><b>(NOT YET RELIABLE)</b></font></th>' 
                    elif 'nbunchcoll'     in k:
                        s += '  <th>#Bunches<br>colliding <br><font size="-2"><b>(NOT YET RELIABLE)</b></font></th>' 
                    elif 'beamtype1'      in k:
                        s += '  <th>Beam type&nbsp;B1</th>' 
                    elif 'beamtype2'      in k:
                        s += '  <th>Beam type&nbsp;B2</th>' 
                    elif 'machinemode'    in k:
                        s += '  <th>LHC mode</th>' 
                    elif 'beammode'       in k:
                        continue
                    else:
                        print ('ERROR: unknown LHC option "%s"' % k)
                        sys.exit(1)
                elif 'ofllumi:' in k:
                    if not ofllumiFlag:
                        s += '  <th>Offline Luminosity<br><font style="font-weight:normal">(%s)</font></font></th>' % k.split(':')[-1]
                        ofllumiFlag = True
                elif 'bs:' in k:
                    kt = k.replace('bs:','')
                    if 'bs:Pos' in k or 'bs:Sig' in k:
                        s += '  <th><font size="-2">%s<br><font style="font-weight:normal">(mm)</font></font></th>' % kt
                    elif 'bs:Tilt' in k:
                        s += '  <th><font size="-2">%s<br><font style="font-weight:normal">(rad)</font></font></th>' % kt
                    else:
                        s += '  <th><font size="-2">%s</font></th>' % kt
                elif 'BPM' in k:
                    s += '  <th>Beam&nbsp;Position Monitors&nbsp;(BPM)</th>' 
                elif 'olc:' in k:
                    if 'olc:lumi' in k:
                        tp1, tp2, chan = k.split(':')
                        try:
                            chan = float(chan)
                        except ValueError:
                            chan = -1
                        if chan in OLCAlgorithms:
                            chanstr = OLCAlgorithms[chan]
                        else:
                            chanstr = 'UNKNOWN'
                        s += '  <th>Online&nbsp;del.&nbsp;Luminosity&nbsp;<font size="-2"><br><font style="font-weight:normal">[%s]</font></font></th>' % chanstr
                    elif 'beam1bunches' in k:
                        continue # not used anymore
                    elif 'beam2bunches' in k:
                        continue # not used anymore
                    elif 'collbunches'  in k:
                        continue # not used anymore
                    elif 'bcidmask' in k:
                        s += '  <th>Bunch&nbsp;structure</th>'
                    elif 'beam1intensity' in k:
                        continue # included in 'fillbeams' summary
                    elif 'beam2intensity' in k:
                        continue # included in 'fillbeams' summary
                    else:
                        s += '  <th>%s</th>' % k
 
                elif 'BGS Key' in k:
                    s += '  <th>Bunch group key</th>'
                        
                else:
                    s += '  <th>%s</th>' % k
                s += '\n'
            s += '</tr>'
 
            # generate a second header line
            secondheader = ''
            patterns = [ ('lar:',          'LAr configuration'),
                         ('lhc:|olc:',     'LHC and online luminosity information' if any(['olc:' in x for x in Run.headerkeys()]) else 'LHC information' ),
                         ('bs:',           'Beam spot parameters (%s)' % Run.BeamspotSource),
                         ('STR:',          'Data stream statistics'),
                         ('TriggerMenu|SMK|Release|L1 PSK|HLT PSK|BGS|TriggerRates', 'Trigger information'),
                         ('SHIFTOFL:',     'Data quality (SHIFTOFL)'),
                         ('LBSUMM:',       'Data quality (LBSUMM)')
                         ]
 
            order = []
            for (p,hdesc) in patterns:
                matchedpositions = [idx for (idx,head) in enumerate(Run.headerkeys()) if re.match(p,head)]
                #print ("pattern",p,matchedpositions)
                if matchedpositions:
                    order += [(min(matchedpositions),max(matchedpositions),hdesc)]
            order.sort()
 
            mergeempty = True
            if len(order)>0:
                current=0
                for th in order:
                    if mergeempty:
                        if th[0]>current:
                            secondheader += '<th colspan="%s"></th>'  % (th[0]-current)
                    else:
                        for x in range(th[0]-current):
                            secondheader += '<th></th>'
                    secondheader += '<th colspan="%s">%s</th>' % (th[1]-th[0]+1,th[2])
                    current=th[1]+1
                if len(Run.headerkeys())>current:
                    if mergeempty:
                        secondheader += '<th colspan="%s"></th>' % (len(Run.headerkeys())-current)
                    else:
                        for x in range(len(Run.headerkeys())-current):
                            secondheader += '<th></th>'
                secondheader = "<tr>%s</tr>" % secondheader
            
 
            s = '<thead>' + secondheader + s + '</thead>\n'
 
            # Global (run independent) tooltips
 
            # OLC
            if any([k for k in Run.ShowOrder if "olc:lumi" in k.ResultKey]):
                boxcontent = '<font color="#AA0000">Click&nbsp;to&nbsp;enlarge&nbsp;figure and&nbsp;to&nbsp;obtain&nbsp;online&nbsp;integrated&nbsp;luminosity&nbsp;versus&nbsp;LB</font>'
                Run.addGlobalToolTip("OLCLumi", boxcontent)
 
            # OFLLumi
            if any([k for k in Run.ShowOrder if "ofllumi" in k.ResultKey]):
                boxcontent = '<font color="#AA0000">Click to obtain offline integrated luminosity versus LB</font>'
                Run.addGlobalToolTip("OFLLumi", boxcontent)
 
            # OFLBS - beamspot
            if any([k for k in Run.ShowOrder if "bs:" in k.ResultKey]):
                boxcontent = '<font color="#AA0000">Click to obtain %s beamspot versus LB</font>' % (Run.BeamspotSource.split()[0])
                Run.addGlobalToolTip("OFLBS", boxcontent)
 
            # BPM info
            if any([k for k in Run.ShowOrder if "BPM" == k.ResultKey]):
                boxcontent = '<font color="#AA0000">Click to enlarge figure</font>'
                Run.addGlobalToolTip("BPM", boxcontent)
 
            # LHC Summary
            if any([k for k in Run.ShowOrder if "lhc:fillnumber" in k.ResultKey]):
                boxcontent = '<font color="#AA0000">Click to enlarge figure</font>'
                Run.addGlobalToolTip("LHCSummary", boxcontent)
 
        else:
            s = ''
            for lll in [1,2]:
                if Run.showrunnr:
                    if lll==0:
                        s += '%-*s  %*s  ' % (_fW['Run'],'Run',_fW['NLB'],'#LB')
                    if lll==1:
                        s += '%-*s  %*s  ' % (_fW['Run'],' ',_fW['NLB'],' ')
                s+=" " # accept/reject flag
                if Run.showtime:
                    hstr = 'Start and endtime (%s)' % QC.localStr()
                    if lll==0:
                        s += '%*s  ' %(_fW['Time'],hstr)
                    if lll==1:
                        s += '%*s  ' %(_fW['Time'],' ')
                if Run.showduration:
                    if lll==0:
                        s += '%*s  ' % (10,'Duration')
                    if lll==1:
                        s += '%*s  ' % (10,' ')
                for k in Run.SortedShowOrder():
                    if k.Type == DataKey.STREAM:
                        w = max(len(k.Header)-k.Header.find('_'),_fW['Stream'])
                        if lll==0:
                            s += '%*s  ' % (w,k.Header[4:k.Header.find('_')])
                        if lll==1:
                            s += '%*s  ' % (w,k.Header[k.Header.find('_')+1:])
                    else:
                        w = 10
                        if k in _fW:
                            w = _fW[k.ResultKey]
                        if lll==0:
                            s += '%*s  ' % (w,k.Header)
                        if lll==1:
                            s += '%*s  ' % (w,' ')
                if lll==0:
                    s+='\n'
        return s
 

headerkeys()

def python.AtlRunQueryRun.Run.headerkeys

(

cls

)

Definition at line 439 of file AtlRunQueryRun.py.

    def headerkeys(cls):
        hk = []
        if Run.showrunnr:
            hk += ['Run','Links','#LB']
        if Run.showtime:
            hk += ['Start and endtime (%s)' % QC.localStr()]
        if Run.showduration:
            hk += ['Duration']
        for x in cls.SortedShowOrder():
            x = x.ResultKey
            if 'L1 PSK' in x or ('olc:' in x and ('beam1bunches' in x or 'beam2bunches' in x or 'collbunches' in x or 'beam1intensity' in x or 'beam2intensity' in x)):
                continue
            hk += [x]
        return hk
 
 

nr_lb()

def python.AtlRunQueryRun.Run.nr_lb

(

self

)

Definition at line 402 of file AtlRunQueryRun.py.

    def nr_lb(self):
        return self.lastlb
 

NrLBs()

def python.AtlRunQueryRun.Run.NrLBs

(

self

)

Definition at line 398 of file AtlRunQueryRun.py.

    def NrLBs(self):
        return "%i" % self.lastlb
 

prettyChain()

def python.AtlRunQueryRun.Run.prettyChain	(		cls,
			tr,
			ps
	)

Definition at line 858 of file AtlRunQueryRun.py.

    def prettyChain(cls,tr,ps):
        i = len(ps)-1
        while i>0:
            if ps[i]==ps[i-1]:
                ps[i]=' '
            elif ps[i]<0:
                ps[i]='x'
            else:
                ps[i]=str(ps[i])
            i-=1
        if ps[0] is None:
            ps[0]='n.a.'
        elif ps[0]<0:
            ps[0]='x'
        else:
            ps[0]=str(ps[0])
        
        pss = '-'.join(ps)
        s = "%s (%s)" % (tr.name,pss)
        return s
 

runlinks()

def python.AtlRunQueryRun.Run.runlinks

(

self

)

Definition at line 753 of file AtlRunQueryRun.py.

    def runlinks(self):
        s = ''
        # DS
        if time.gmtime(self.sor/1.E9).tm_year >= 2010:
            s  += '    <a href="http://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/DataSummary/%i/run.py?run=%i" target="_blank" title="Data summary information for run %i"><font size="-3">DS</font></a>,&nbsp;\n' % (time.gmtime(self.sor/1.E9).tm_year, self.runNr, self.runNr)
        # RS
        s += '    <a href="http://atlas-service-db-runlist.web.cern.ch/atlas-service-db-runlist/php/runDetails.php?run=%i" target="_blank" title="Run summary information for run %i"><font size="-3">RS</font></a>,&nbsp;\n' % (self.runNr, self.runNr)
        # BS
        s += '    <a href="https://atlas-beamspot.cern.ch/webapp/jobs/?r=%i" target="_blank" title="Beam spot fit information for run %i"><font size="-3">BS</font></a>,&nbsp;\n' % (self.runNr, self.runNr)        
        # AMI
        s += '    <a href="https://ami.in2p3.fr/AMI/servlet/net.hep.atlas.Database.Bookkeeping.AMI.Servlet.Command?Converter=/AMIXmlToAMIProdHtml.xsl&Command=FormBrowseDatasetPerRun+-runNumber=%i" target="_blank" title="AMI reference for run %i"><font size="-3">AMI</font></a>,&nbsp;\n' % (self.runNr, self.runNr)
        # DQ
        s += '    <a href="https://atlasdqm.web.cern.ch/atlasdqm/DQBrowser/makeMatrix.php?selection=All&run=%i&runup=&dbinstance=COMP200_SHIFTOFL&tag=HEAD" target="_blank" title="Browse detailed data quality entries for run %i (uses SHIFTOFL folder in COMP200 conditions database)"><font size="-3">DQ</font></a>,<br>\n' % (self.runNr, self.runNr)
        # ELOG
        s += '    <a href="https://atlasop.cern.ch/elog/ATLAS/ATLAS/?mode=full&reverse=0&reverse=1&npp=20&ma=1&ya=2008&last=3064&subtext=%i&sall=0" target="_blank" title="Search for ELOG entries on run %i"><font size="-3">ELOG</font></a>,&nbsp;\n' % (self.runNr, self.runNr)
        # DCS reference, format: http://atlas-dcs.cern.ch/navigation.php?datestring=2009-07-26-10-12
        tbeg = time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime(self.sor/1.E9))
        t    = time.gmtime(self.eor/1.E9)
        tend = "%4i-%02i-%02i-%02i-%02i" % (t[0], t[1], t[2], t[3], t[4])
        s += '    <a href="http://atlas-dcs.cern.ch/navigation.php?date2=%s" target="_blank" title="DCS status at begin of run %i"><font size="-3">DCS:SoR</font></a>/' % (tbeg, self.runNr)
        s += '<a href="http://atlas-dcs.cern.ch/navigation.php?date2=%s" target="_blank" title="DCS status at end of run %i"><font size="-3">EoR</font></a>,&nbsp;\n  ' % (tend, self.runNr)
        #s += '    <a href="https://atlas-dcs.cern.ch/navigation.php?date2=2008-09-29-19-01-42">DCS:SoR</font></a>/' % (tbeg, self.runNr)
        #s += '<a href="https://atlas-dcs.cern.ch/navigation.php?date2=2008-09-30-08-17"><font size="-3">EoR</font></a>,&nbsp;\n  ' % (tend, self.runNr)
 
        # OKS
        if self.data['oks']:
            if self.lhcRun<3:
                s += '    <a href="http://cern.ch/atlas-project-tdaq-cc/cgi/getdata.sh?tdaq-05-05-00&oracle://atlas_oks/r&atlas_oks_archive&%i&%i&ATLAS" target="_blank" title="Download online configuration for run %i"><font size="-3">OKS</font></a>\n' % ( self.data['oks'][0].value + (self.runNr,) )
            else:
                (hash, release) = self.data["oks"][0].value
                s+= f'    <a href="https://gitlab.cern.ch/atlas-tdaq-oks/p1/{release}/-/tree/{hash[5:]}" target="_blank" title="Browse online configuration for run {self.runNr}"><font size="-3">OKS</font></a>\n'
        # lumi summary
        # typical address: https://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/RunSummary/run142308_summary.html
        # OLD: fname = 'https://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/RunSummary/run%i_summary.html' % (self.runNr)
        fname = 'http://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/DataSummary/runsum.py?run=%i\n' % (self.runNr)
        fwget = urllib.request.urlopen(fname)
 
        wincontent = ''
        for line in fwget:
            if '</head>' in str(line) and '<base href' not in wincontent:
                wincontent += '<base href="http://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/DataSummary/2010/"></base>'
            wincontent += str(line)
        wincontent = wincontent.replace('href="css/atlas-datasummary.css"', 'href="http://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/DataSummary/css/atlas-datasummary.css"')
 
        # remove temporarily second plot with integration
        wincontent = wincontent.replace( '<td>\n<a href="rundata/run%i/run%i_ilumr.png"><img src="rundata/run%i/run%i_ilumr.png" alt="InstLumi" style="width: 200px; "></a></td>' % (self.runNr,self.runNr,self.runNr,self.runNr),'')
        wincontent = wincontent.replace('"','&quot;')
        wincontent = wincontent.replace('./RunSummary/figs','https://atlas.web.cern.ch/Atlas/GROUPS/DATAPREPARATION/RunSummary/figs')
        wincontent = wincontent.replace('<a href','<a target=&quot;_blank&quot; href')
        wincontent = wincontent.replace('width: 200px','width: 350px')
        wincontent = wincontent.replace('width: 250px','width: 350px')
 
 
        openwincmd = 'javascript:openLumiWindow('
        openwincmd += "'Print','<!DOCTYPE html PUBLIC &quot;-//W3C//DTD HTML 4.01 Transitional//EN&quot;><html xmlns:&quot;my&quot;><head><title>Luminosity information for run %i</title></head><body style=&quot;background-color:#ffffff&quot;>" % self.runNr
        openwincmd += wincontent        
        openwincmd += '</body></html>'
        openwincmd += "')"
 
        return s
 
 

runNrS()

def python.AtlRunQueryRun.Run.runNrS

(

self

)

Definition at line 390 of file AtlRunQueryRun.py.

    def runNrS(self):
        return "%i" % self.runNr
 

SortedShowOrder()

def python.AtlRunQueryRun.Run.SortedShowOrder

(

cls

)

Definition at line 420 of file AtlRunQueryRun.py.

    def SortedShowOrder(cls):
        if Run._SortedShowOrder is not None:
            if len(Run._SortedShowOrder) != len(Run.ShowOrder):
                raise RuntimeError ("Sorting not up-to-date %i %i" % (len(Run._SortedShowOrder), len(Run.ShowOrder) ))
            return Run._SortedShowOrder
        hk = []
        for order in Run.DisplayOrder:
            for x in Run.ShowOrder:
                if not order.match(x.ResultKey):
                    continue
                if x in hk:
                    continue
                hk += [x]
        Run._SortedShowOrder = hk
        if len(Run._SortedShowOrder) != len(Run.ShowOrder):
            raise RuntimeError ("Sorting not up-to-date after creation %i %i" % (len(Run._SortedShowOrder), len(Run.ShowOrder) ))
        return Run._SortedShowOrder
    

splitTriggerChains()

def python.AtlRunQueryRun.Run.splitTriggerChains	(		self,
			chainlist
	)

Definition at line 879 of file AtlRunQueryRun.py.

    def splitTriggerChains(self, chainlist):
        res = { 'L1': [], 'L2': [], 'EF': [] }
        for tr,pslist in chainlist.items():
            if not tr.forshow:
                continue
            k = tr.name[0:2]
            res[k] += [Run.prettyChain(tr,pslist)]
        res['L1'].sort()
        res['L2'].sort()
        res['EF'].sort()
        l1chains = '<br> '.join(res['L1'])
        l2chains = '<br> '.join(res['L2'])
        efchains = '<br> '.join(res['EF'])
        ret = ()
        if l1chains:
            ret += (l1chains.replace('.0',''), )
        if l2chains:
            ret += (l2chains.replace('.0',''), )
        if efchains:
            ret += (efchains.replace('.0',''), )
        return ret
 

timestr()

def python.AtlRunQueryRun.Run.timestr	(		self,
			format = 'html',
			closed = True
	)

sor and eor is always in UTC, so sor=0 means the run started 1.1.1970 at 00:00:00

Definition at line 815 of file AtlRunQueryRun.py.

    def timestr(self,format='html',closed=True):
        """ sor and eor is always in UTC, so sor=0 means the run started 1.1.1970 at 00:00:00"""
        if QC.localtime:
            begin = time.localtime(self.sor/1.E9)
            end   = time.localtime(self.eor/1.E9)
        else:
            begin = time.gmtime(self.sor/1.E9)
            end   = time.gmtime(self.eor/1.E9)
 
        # begin string
        beginstr = time.strftime("%a %b %d %Y %X",begin)
 
        # end format
        endformat = "%X"
        if end[0]>begin[0]:
            endformat = "%a %b %d, %Y %X"
        elif end[1]>begin[1] or end[2]>begin[2]:
            endformat = "%a %b %d, %X"
 
        # end string
        if closed:
            endstr = time.strftime(endformat,end)
        else:
            endstr = '<font color=#BB0000>ongoing</font>' if format=='html' else 'ongoing'
 
        # output
        if format=='html':
            return '%s&nbsp;&minus;&nbsp;%s' % (beginstr,endstr)
        elif format=='seconds': #mainly for dictionary
            return '%12.3f, %12.3f' % (self.sor/1.E9, self.eor/1.E9)
        elif format=='secondsNum': #mainly for dictionary
            return self.sor/1.E9, self.eor/1.E9
        else:
            return '%s - %s' % (beginstr,endstr)
 

Member Data Documentation

_SortedShowOrder

python.AtlRunQueryRun.Run._SortedShowOrder = None

staticprivate

Definition at line 319 of file AtlRunQueryRun.py.

BeamspotSource

string python.AtlRunQueryRun.Run.BeamspotSource = ''

static

Definition at line 334 of file AtlRunQueryRun.py.

bgcolor

string python.AtlRunQueryRun.Run.bgcolor = "1"

static

Definition at line 327 of file AtlRunQueryRun.py.

data

python.AtlRunQueryRun.Run.data

Definition at line 365 of file AtlRunQueryRun.py.

Datapath

string python.AtlRunQueryRun.Run.Datapath = ''

static

Definition at line 331 of file AtlRunQueryRun.py.

DisplayOrder

python.AtlRunQueryRun.Run.DisplayOrder = map(re.compile,['#Events','Ready','lhc:|olc:', 'TriggerMenu|SMK|Release|L1 PSK|HLT PSK|BGS|TriggerRates', 'bs:', 'STR:', 'DQ|SHIFTOFL:|LBSUMM:', 'lar:', 'Detector','.*'])

static

Definition at line 320 of file AtlRunQueryRun.py.

eor

python.AtlRunQueryRun.Run.eor

Definition at line 352 of file AtlRunQueryRun.py.

Fieldinfo

dictionary python.AtlRunQueryRun.Run.Fieldinfo = {}

static

Definition at line 332 of file AtlRunQueryRun.py.

givepeakmuinfo

python.AtlRunQueryRun.Run.givepeakmuinfo

Definition at line 370 of file AtlRunQueryRun.py.

GlobalTooltips

list python.AtlRunQueryRun.Run.GlobalTooltips = []

static

Definition at line 333 of file AtlRunQueryRun.py.

hasStableBeamsInfo

python.AtlRunQueryRun.Run.hasStableBeamsInfo

Definition at line 357 of file AtlRunQueryRun.py.

instlumiunittxt

python.AtlRunQueryRun.Run.instlumiunittxt

Definition at line 369 of file AtlRunQueryRun.py.

lastlb

python.AtlRunQueryRun.Run.lastlb

Definition at line 353 of file AtlRunQueryRun.py.

lbtimes

python.AtlRunQueryRun.Run.lbtimes

Definition at line 363 of file AtlRunQueryRun.py.

lhcRun

python.AtlRunQueryRun.Run.lhcRun

Definition at line 350 of file AtlRunQueryRun.py.

lumiunit

python.AtlRunQueryRun.Run.lumiunit

Definition at line 367 of file AtlRunQueryRun.py.

lumiunittxt

python.AtlRunQueryRun.Run.lumiunittxt

Definition at line 368 of file AtlRunQueryRun.py.

NemoTasks

dictionary python.AtlRunQueryRun.Run.NemoTasks = {}

static

Definition at line 322 of file AtlRunQueryRun.py.

PromptCalibRuns

list python.AtlRunQueryRun.Run.PromptCalibRuns = []

static

Definition at line 321 of file AtlRunQueryRun.py.

result

python.AtlRunQueryRun.Run.result

Definition at line 359 of file AtlRunQueryRun.py.

runNr

python.AtlRunQueryRun.Run.runNr

Definition at line 349 of file AtlRunQueryRun.py.

runnropen

int python.AtlRunQueryRun.Run.runnropen = -1

static

Definition at line 329 of file AtlRunQueryRun.py.

runPeriods

python.AtlRunQueryRun.Run.runPeriods = RunPeriods()

static

Definition at line 335 of file AtlRunQueryRun.py.

selDataIncomplete

python.AtlRunQueryRun.Run.selDataIncomplete

Definition at line 354 of file AtlRunQueryRun.py.

showCAFLinks

bool python.AtlRunQueryRun.Run.showCAFLinks = False

static

Definition at line 330 of file AtlRunQueryRun.py.

showDataIncomplete

python.AtlRunQueryRun.Run.showDataIncomplete

Definition at line 355 of file AtlRunQueryRun.py.

showduration

bool python.AtlRunQueryRun.Run.showduration = False

static

Definition at line 325 of file AtlRunQueryRun.py.

ShowOrder

list python.AtlRunQueryRun.Run.ShowOrder = []

static

Definition at line 318 of file AtlRunQueryRun.py.

showrunnr

bool python.AtlRunQueryRun.Run.showrunnr = False

static

Definition at line 323 of file AtlRunQueryRun.py.

showtime

bool python.AtlRunQueryRun.Run.showtime = False

static

Definition at line 324 of file AtlRunQueryRun.py.

sor

python.AtlRunQueryRun.Run.sor

Definition at line 351 of file AtlRunQueryRun.py.

stats

python.AtlRunQueryRun.Run.stats

Definition at line 361 of file AtlRunQueryRun.py.

TmpBoxContent

string python.AtlRunQueryRun.Run.TmpBoxContent = ''

static

Definition at line 336 of file AtlRunQueryRun.py.

tooltips

python.AtlRunQueryRun.Run.tooltips

Definition at line 364 of file AtlRunQueryRun.py.

totevents

list python.AtlRunQueryRun.Run.totevents = [0, 0]

static

Definition at line 328 of file AtlRunQueryRun.py.

writehtml

bool python.AtlRunQueryRun.Run.writehtml = False

static

Definition at line 326 of file AtlRunQueryRun.py.

xvecStb

python.AtlRunQueryRun.Run.xvecStb

Definition at line 356 of file AtlRunQueryRun.py.

---

The documentation for this class was generated from the following file:

• AtlRunQueryRun.py