python.TriggerAPI.TriggerAPISession.TriggerAPISession Class Reference

Collaboration diagram for python.TriggerAPI.TriggerAPISession.TriggerAPISession:

Public Member Functions
	__init__ (self, input=None, *, grl=None, flags=None, json=None, menu=None, file=None, period=None)
	save (self, path)
	chains (self, *, triggerType=TriggerType.ALL)
	triggerInfo (self)
	runs (self)
	setRunRange (self, start=0, end=999999)
	getLowestUnprescaled (self, *, triggerType=TriggerType.ALL, livefraction=1.0, runStart=0, runEnd=999999)
	getLowestUnprescaledByRun (self, *, triggerType=TriggerType.ALL, livefraction=1.0, runStart=0, runEnd=999999)
	getLowestUnprescaledAnyRun (self, *, triggerType=TriggerType.ALL, livefraction=1.0, runStart=0, runEnd=999999)
	getLiveFractions (self, *, triggerType=TriggerType.ALL, runStart=0, runEnd=999999)
	getLowerUnprescaled (self, *, chainName, triggerType=TriggerType.ALL, livefraction=1.0, runStart=0, runEnd=999999)

Public Attributes
dict	dbQueries = {}
	customGRL = None
	flags = None
	release = None
bool	cacheread = True

Detailed Description

--------------------------------------------------------------------------------------------------------------------
TriggerAPI helper class. Use the following import in your code:

  from TriggerMenuMT.TriggerAPI import TriggerAPISession,TriggerType,TriggerPeriod

Examples of use:
================

Set of triggers of a given type that are unprescaled for an entire GRL:

  s = TriggerAPISession("path/to/grl.xml") # can be a PathResolver path as well
  triggers = s.getLowestUnprescaled(triggerType=TriggerType.el_single)

Dictionary of sets of triggers of a given type that are unprescaled, for each run in the GRL:

  s = TriggerAPISession("path/to/grl.xml")
  triggersByRun = s.getLowestUnprescaledByRun(triggerType=TriggerType.el_single)

Set of triggers that are unprescaled for all runs between two run numbers (inclusive), in a GRL:

  s = TriggerAPISession("path/to/grl.xml")
  triggers = s.getLowestUnprescaledByRun(triggerType=TriggerType.el_single,runStart=123456,runEnd=234567)

Other helpful methods are:

  - Set of runs present in the session's GRL: s.runs()
  - List of trigger types: [x.name for x in TriggerType]
  - Dictionary of livefractions between given runs, key = trigger chain name:
    liveFractions = s.getLiveFractions(triggerType=TriggerType.el_single,runStart=123456,runEnd=234567)
  - Dictionary of chains (key is chain.name): s.chains()
  - Set of triggers that are deemed to be of same type and lower threshold than a given trigger and unprescaled:
    triggers = s.getLowerPrescaled(chainName="myChain")

Each method accepts an "additionalTriggerType" parameter that is used for multi-leg triggers of different type
(e.g. e-mu triggers).

Instead of passing a GRL you can pass a menu name ("menu_name") in the constructor, and the unprescaled
triggers will be the Primary|TagAndProbe triggers from the menu.


Saving a session
================
Sessions can be saved to json file and reloaded at a later time (to save requerying the database):

    s.save("myDump.json")
    s2 = TriggerAPISession(json="myDump.json") # reloads the session

--------------------------------------------------------------------------------------------------------------------

Definition at line 14 of file TriggerAPISession.py.

Constructor & Destructor Documentation

__init__()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.__init__	(		self,
			input = None,
		*	,
			grl = None,
			flags = None,
			json = None,
			menu = None,
			file = None,
			period = None )

Specify one and only one of the following parameters to construct your API session:

:param input: If specified, will try to auto-infer which of the things below it is:

:param grl: Path to a GRL file, locatable by PathResolver
:param flags: flag container, used if reading triggers from the trigger menu (in the file or the release) - EXPERT OPTION
:param json: Path to a JSON file, locatable by PathResolver, containing a cache of TriggerAPI session
:param menu: Specify a menu to use, such as "Physics_pp_run3_v1". This is otherwise taken from flags
:param file: Specify a root file (AOD etc) from which the menu will be taken
:param period: Legacy option, can specify a TriggerPeriod and will load through the hardcoded GRLs (TriggerPeriodData)

Definition at line 67 of file TriggerAPISession.py.

    def __init__(self, input=None, *, grl=None, flags=None, json=None, menu=None, file=None, period=None):
        """
        Specify one and only one of the following parameters to construct your API session:
 
        :param input: If specified, will try to auto-infer which of the things below it is:
 
        :param grl: Path to a GRL file, locatable by PathResolver
        :param flags: flag container, used if reading triggers from the trigger menu (in the file or the release) - EXPERT OPTION
        :param json: Path to a JSON file, locatable by PathResolver, containing a cache of TriggerAPI session
        :param menu: Specify a menu to use, such as "Physics_pp_run3_v1". This is otherwise taken from flags
        :param file: Specify a root file (AOD etc) from which the menu will be taken
        :param period: Legacy option, can specify a TriggerPeriod and will load through the hardcoded GRLs (TriggerPeriodData)
        """
 
        import os
 
        if input is not None:
            if type(input)==str:
                if input.endswith(".xml"):
                    log.info("Loading session for GRL:" + input)
                    grl = input
                elif input.endswith(".json"):
                    log.info("Loading saved session from:" + input)
                    json = input
                elif os.path.exists(input):
                    log.info("Loading session with menu from file:" + input)
                    file = input
                else:
                    log.info("Loading session for menu:" + input)
                    menu = input
            else:
                raise RuntimeError("Unsupported input type:" + type(input).__name__)
 
 
        # the following represents the complete "state" of the TriggerAPI
        self.dbQueries = {}
        self.customGRL = None
        self.flags     = None
        self.release   = None
        self.cacheread = True # always prevent auto-loading of cache in singleton
 
        if json is not None:
            self.dbQueries = SerializeAPI.load(json)
        elif grl is not None:
            from PathResolver import PathResolver
            grl = PathResolver.FindCalibFile(grl) if grl[0] != "/" else grl
            self.customGRL = grl
        elif flags is not None:
            self.flags = flags
        elif menu is not None:
            from AthenaConfiguration.AllConfigFlags import initConfigFlags
            self.flags = initConfigFlags()
            self.flags.Trigger.triggerMenuSetup = menu
            self.flags.lock()
        elif file is not None:
            from AthenaConfiguration.AllConfigFlags import initConfigFlags
            self.flags = initConfigFlags()
            self.flags.Input.Files = [file]
            self.flags.lock()
        elif period is not None:
            TriggerAPI.reset()
            TriggerAPI._loadTriggerPeriod(period,reparse=False)
            if not TriggerAPI.dbQueries:
                raise RuntimeError("Failed to load TriggerAPI information for period")
            import copy
            self.dbQueries = copy.deepcopy(TriggerAPI.dbQueries)
        else:
            raise RuntimeError("Must specify one of: grl, flags, json, menu, period")
 
        if self.flags is not None or self.customGRL is not None:
            TriggerAPI.reset()
            period = TriggerPeriod.future2e34 # used when loading with a flags container
            if self.flags is not None:
                TriggerAPI.setConfigFlags(self.flags)
            else:
                TriggerAPI.setCustomGRL(self.customGRL)
                period = TriggerPeriod.customGRL
            TriggerAPI._loadTriggerPeriod(period,reparse=False)
            if not TriggerAPI.dbQueries:
                raise RuntimeError("Failed to load TriggerAPI information")
            import copy
            self.dbQueries = copy.deepcopy(TriggerAPI.dbQueries)
 
        # TODO:
        # for any query loaded with an actual period enum (so through json or period arg)
        # we should use TriggerPeriodData to assign per run values of activeLB and totalLB
        # could then merge into a single ti object ... but then need to look at is2015 in isLowerThan
        # since there is special behaviour for 2015 that will be lost
 
        pass
 

Member Function Documentation

chains()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.chains	(		self,
		*	,
			triggerType = TriggerType.ALL )

:param triggerType: you can list available types with "[x.name for x in TriggerType]"
:return: dictionary of triggerChain objects of given types, key = chain Name

Definition at line 166 of file TriggerAPISession.py.

    def chains(self,*,triggerType=TriggerType.ALL):
        """
        :param triggerType: you can list available types with "[x.name for x in TriggerType]"
        :return: dictionary of triggerChain objects of given types, key = chain Name
        """
        if len(self.dbQueries)>1:
            raise RuntimeError("Unsupported in multi-period TriggerAPI sessions (should only happen if using a period enum or an old json cache)")
 
        if not isinstance(triggerType,list): triggerType = [triggerType,TriggerType.UNDEFINED]
        if len(triggerType)==1: triggerType += [TriggerType.UNDEFINED]
        elif len(triggerType) > 2:
            raise RuntimeError("More than two trigger types not currently supported")
 
        out = {}
        for tc in self.triggerInfo().triggerChains:
            if not tc.passType(triggerType[0],triggerType[1]): continue
            out[tc.name] = tc
        return out
 

getLiveFractions()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.getLiveFractions	(		self,
		*	,
			triggerType = TriggerType.ALL,
			runStart = 0,
			runEnd = 999999 )

:param triggerType: can be a single type or a list of types
:param runStart:
:param runEnd:
:return: a dictionary of live fractions for triggers matching given trigger types

Definition at line 262 of file TriggerAPISession.py.

    def getLiveFractions(self,*,triggerType=TriggerType.ALL,runStart=0,runEnd=999999):
        """
        :param triggerType: can be a single type or a list of types
        :param runStart:
        :param runEnd:
        :return: a dictionary of live fractions for triggers matching given trigger types
        """
        out = {}
        self.setRunRange(runStart,runEnd)
        for x in self.chains(triggerType=triggerType).values():
            out[x.name] = x.livefraction
        self.setRunRange()
        return out
 

getLowerUnprescaled()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.getLowerUnprescaled	(		self,
		*	,
			chainName,
			triggerType = TriggerType.ALL,
			livefraction = 1.0,
			runStart = 0,
			runEnd = 999999 )

:param chainName:
:param triggerType:
:param livefraction:
:param runStart:
:param runEnd:
:return: set of chains of unprescaled triggers that were lower than the given chain

Definition at line 276 of file TriggerAPISession.py.

    def getLowerUnprescaled(self,*,chainName,triggerType=TriggerType.ALL,livefraction=1.0,runStart=0,runEnd=999999):
        """
        :param chainName:
        :param triggerType:
        :param livefraction:
        :param runStart:
        :param runEnd:
        :return: set of chains of unprescaled triggers that were lower than the given chain
        """
 
        chains = self.chains()
        if chainName not in chains:
            raise RuntimeError(chainName + " not found")
        chain = chains[chainName]
        self.setRunRange(runStart,runEnd)
        out = set()
        for x in self.chains(triggerType=triggerType).values():
            if x.name==chain.name: continue
            if not x.isUnprescaled(livefraction): continue
            if x.isLowerThan(chain,period=self.triggerInfo().period)==1: out.add(x)
        self.setRunRange()
        return out
 
 

getLowestUnprescaled()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.getLowestUnprescaled	(		self,
		*	,
			triggerType = TriggerType.ALL,
			livefraction = 1.0,
			runStart = 0,
			runEnd = 999999 )

:param triggerType: list available types with "[x.name for x in TriggerType] .. provide a list of length 2 for multi-leg types"
:param livefraction: threshold to be considered unprescaled
:param runStart:
:param runEnd:
:return: set of lowest unprescaled (according to livefraction) triggers of given type

Definition at line 203 of file TriggerAPISession.py.

    def getLowestUnprescaled(self,*, triggerType=TriggerType.ALL,livefraction=1.0,runStart=0,runEnd=999999):
        """
        :param triggerType: list available types with "[x.name for x in TriggerType] .. provide a list of length 2 for multi-leg types"
        :param livefraction: threshold to be considered unprescaled
        :param runStart:
        :param runEnd:
        :return: set of lowest unprescaled (according to livefraction) triggers of given type
        """
 
        
        if not isinstance(triggerType,list): triggerType = [triggerType,TriggerType.UNDEFINED]
        if len(triggerType)==1: triggerType += [TriggerType.UNDEFINED]
        elif len(triggerType) > 2:
            raise RuntimeError("More than two trigger types not currently supported")
 
        self.setRunRange(runStart,runEnd)
        out = set()
        for ti in self.dbQueries.values():
            out.update(ti._getLowestUnprescaled(triggerType[0], triggerType[1], "", livefraction))
        self.setRunRange() # reset to include all ranges
 
        if not out and livefraction==1.0 and list(self.dbQueries.keys())[0][1] and runStart!=runEnd:
            log.warning("No triggers found that are fully unprescaled in your GRL ... checking for livefractions per run:")
            # check result by-run to see if there are problems with individual runs (possibly lumiblocks included in each)
            for run in sorted(list(self.runs())):
                liveFractions = self.getLiveFractions(triggerType=triggerType,runStart=run,runEnd=run)
                lf = max(liveFractions.values())
                if lf < 1 and lf > 0.9:
                    log.warning(f"run {run} has maximum livefraction {lf} - prescaled LBs may have been included in your GRL accidentally. Please report this to Data Preparation")
                elif lf==1.0:
                    log.info(f"run {run} is unprescaled")
 
        return out
 

getLowestUnprescaledAnyRun()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.getLowestUnprescaledAnyRun	(		self,
		*	,
			triggerType = TriggerType.ALL,
			livefraction = 1.0,
			runStart = 0,
			runEnd = 999999 )

Definition at line 257 of file TriggerAPISession.py.

    def getLowestUnprescaledAnyRun(self,*,triggerType=TriggerType.ALL,livefraction=1.0,runStart=0,runEnd=999999):
        out = set()
        for tc in self.getLowestUnprescaledByRun(triggerType=triggerType,livefraction=livefraction,runStart=runStart,runEnd=runEnd).values():
            out.update(tc)
        return out

getLowestUnprescaledByRun()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.getLowestUnprescaledByRun	(		self,
		*	,
			triggerType = TriggerType.ALL,
			livefraction = 1.0,
			runStart = 0,
			runEnd = 999999 )

:param triggerType:
:param livefraction:
:param runStart:
:param runEnd:
:return: lowest unprescaled trigger by run. If this session does not have per-run info, all triggers will be listed under a dummy key of ""

Definition at line 237 of file TriggerAPISession.py.

    def getLowestUnprescaledByRun(self,*,triggerType=TriggerType.ALL,livefraction=1.0,runStart=0,runEnd=999999):
        """
 
        :param triggerType:
        :param livefraction:
        :param runStart:
        :param runEnd:
        :return: lowest unprescaled trigger by run. If this session does not have per-run info, all triggers will be listed under a dummy key of ""
        """
        if not self.runs(): # case where loaded from trigger menu, for example
            return {"":self.getLowestUnprescaled(triggerType=triggerType,livefraction=livefraction,runStart=runStart,runEnd=runEnd)}
        out = {}
        import tqdm
        pbar = tqdm.tqdm(self.runs(),unit=" runs",bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}')
        for run in pbar:
            pbar.set_description(f"Determining lowest unprescaled for run {run}")
            if int(run)<runStart or int(run)>runEnd: continue
            out[run] = self.getLowestUnprescaled(triggerType=triggerType,livefraction=livefraction,runStart=run,runEnd=run)
        return out
 

runs()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.runs

(

self

)

:return: set of runs covered by this session

Definition at line 188 of file TriggerAPISession.py.

    def runs(self):
        """
        :return: set of runs covered by this session
        """
        out = set()
        for ti in self.dbQueries.values():
            for tc in ti.triggerChains:
                for run in tc.activeLBByRun.keys():
                    out.add(run)
        return out
 

save()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.save	(		self,
			path )

:param path: Save a cache of the current session to the given json file
:return: result of json dump

Definition at line 158 of file TriggerAPISession.py.

    def save(self, path):
        """
        :param path: Save a cache of the current session to the given json file
        :return: result of json dump
        """
        return SerializeAPI.dump(self.dbQueries,path)
 
 

setRunRange()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.setRunRange	(		self,
			start = 0,
			end = 999999 )

Definition at line 199 of file TriggerAPISession.py.

    def setRunRange(self,start=0,end=999999):
        for ti in self.dbQueries.values():
            ti.setRunRange(start,end)
 

triggerInfo()

python.TriggerAPI.TriggerAPISession.TriggerAPISession.triggerInfo

(

self

)

Definition at line 185 of file TriggerAPISession.py.

    def triggerInfo(self):
        return self.dbQueries[list(self.dbQueries.keys())[0]]
 

Member Data Documentation

cacheread

bool python.TriggerAPI.TriggerAPISession.TriggerAPISession.cacheread = True

Definition at line 106 of file TriggerAPISession.py.

customGRL

python.TriggerAPI.TriggerAPISession.TriggerAPISession.customGRL = None

Definition at line 103 of file TriggerAPISession.py.

dbQueries

python.TriggerAPI.TriggerAPISession.TriggerAPISession.dbQueries = {}

Definition at line 102 of file TriggerAPISession.py.

flags

python.TriggerAPI.TriggerAPISession.TriggerAPISession.flags = None

Definition at line 104 of file TriggerAPISession.py.

release

python.TriggerAPI.TriggerAPISession.TriggerAPISession.release = None

Definition at line 105 of file TriggerAPISession.py.

---

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

• TriggerAPISession.py