python.runHLT Namespace Reference

Functions
def	lock_and_restrict (flags)
def	set_flags (flags)
def	runHLTCfg (flags)
def	athenaHLTCfg (flags)
def	athenaCfg (flags, parser=None)
def	main (flags)

Variables
	flags

Function Documentation

athenaCfg()

def python.runHLT.athenaCfg	(		flags,
			parser = None
	)

Top-level cfg function when running in athena

Definition at line 135 of file runHLT.py.

def athenaCfg(flags, parser=None):
   """Top-level cfg function when running in athena"""
   from AthenaConfiguration.Enums import Format
 
   # Set default flags for running HLT
   set_flags(flags)
 
   # To allow running from MC
   flags.Common.isOnline = lambda f: not f.Input.isMC
 
   # Add options to command line parser
   if not parser:
      parser = flags.getArgumentParser()
   parser.add_argument('--postExec', metavar='CMD',
                       help='Commands executed after Python configuration')
 
   # Fill flags from command line
   args = flags.fillFromArgs(parser=parser)
 
   if flags.Trigger.writeBS:
      flags.Output.doWriteBS = True
   else:  # RDO writing is default in athena
      flags.Output.doWriteRDO = True
      if not flags.Output.RDOFileName:
         flags.Output.RDOFileName = 'RDO_TRIG.pool.root'
 
   # Enable verbose control/data flow printouts if in a
   # restricted menu, typical for debugging
   if flags.Trigger.selectChains or len(flags.Trigger.enabledSignatures)==1:
      flags.Scheduler.ShowControlFlow = True
      flags.Scheduler.ShowDataDeps = True
 
   # Configure main services
   _allflags = flags.clone()   # copy including Concurrency flags
   _allflags.lock()
   from AthenaConfiguration.MainServicesConfig import MainServicesCfg
   cfg = MainServicesCfg(_allflags)
   del _allflags
 
   # Lock flags
   lock_and_restrict(flags)
 
   if flags.Input.Format is Format.BS:
       from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
       cfg.merge(ByteStreamReadCfg(flags))
   else:
       from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
       cfg.merge(PoolReadCfg(flags))
 
   # Configure HLT
   cfg.merge(runHLTCfg(flags))
 
   if args.postExec:
      exec(args.postExec)
 
   # Apply flags.Exec.XXXMessageComponents logic to configured job
   from AthenaConfiguration.Utils import setupLoggingLevels
   setupLoggingLevels(flags, cfg)
 
   return cfg
 
 

athenaHLTCfg()

def python.runHLT.athenaHLTCfg

(

flags

)

Top-level cfg function when running in athenaHLT

Definition at line 114 of file runHLT.py.

def athenaHLTCfg(flags):
   """Top-level cfg function when running in athenaHLT"""
 
   # Set default flags for running HLT
   set_flags(flags)
 
   # Decoding the flags from the command line is already done in athenaHLT.
   # But we have to do it again in case some of the flags from set_flags
   # get overwritten by the user.
   from TrigPSC import PscConfig
   for flag_arg in PscConfig.unparsedArguments:
      flags.fillFromString(flag_arg)
 
   # Lock flags
   lock_and_restrict(flags)
 
   # Configure HLT
   cfg = runHLTCfg(flags)
   return cfg
 
 

lock_and_restrict()

def python.runHLT.lock_and_restrict

(

flags

)

Deny access to a few flags and lock

Definition at line 17 of file runHLT.py.

def lock_and_restrict(flags):
   """Deny access to a few flags and lock"""
 
   def bomb(x):
      raise RuntimeError("Concurrency flags cannot be used in the HLT to ensure "
                         "that the configuration is portable across different CPUs")
 
   flags.Concurrency.NumProcs = bomb
   flags.Concurrency.NumThreads = bomb
   flags.Concurrency.NumConcurrentEvents = bomb
 
   flags.lock()
 
 

main()

def python.runHLT.main

(

flags

)

This method is called by athenaHLT (with pre-populated flags)

Definition at line 197 of file runHLT.py.

def main(flags):
   """This method is called by athenaHLT (with pre-populated flags)"""
   return athenaHLTCfg(flags)
 
 
# This entry point is only used when running in athena

runHLTCfg()

def python.runHLT.runHLTCfg

(

flags

)

Main function to configure the HLT in athena and athenaHLT

Definition at line 53 of file runHLT.py.

def runHLTCfg(flags):
   """Main function to configure the HLT in athena and athenaHLT"""
   from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
   from AthenaCommon.Logging import logging
 
   log = logging.getLogger('runHLT')
   cfg = ComponentAccumulator()
 
   # Load these objects from StoreGate
   loadFromSG = [('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
                 ('TrigConf::L1Menu','DetectorStore+L1TriggerMenu'),
                 ('TrigConf::HLTMenu','DetectorStore+HLTTriggerMenu')]
 
   from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
   cfg.merge(SGInputLoaderCfg(flags, loadFromSG))
 
   from TriggerJobOpts.TriggerHistSvcConfig import TriggerHistSvcConfig
   cfg.merge(TriggerHistSvcConfig(flags))
 
   # Menu
   from TriggerMenuMT.HLT.Config.GenerateMenuMT import generateMenuMT
   from TriggerJobOpts.TriggerConfig import triggerRunCfg
   menu = triggerRunCfg(flags, menu=generateMenuMT)
   cfg.merge(menu)
 
   from LumiBlockComps.LumiBlockMuWriterConfig import LumiBlockMuWriterCfg
   cfg.merge(LumiBlockMuWriterCfg(flags), sequenceName="HLTBeginSeq")
 
   if flags.Trigger.doTransientByteStream and flags.Trigger.doCalo:
       from TriggerJobOpts.TriggerTransBSConfig import triggerTransBSCfg_Calo
       cfg.merge(triggerTransBSCfg_Calo(flags), sequenceName="HLTBeginSeq")
 
   # L1 simulation
   if flags.Trigger.doLVL1:
       from TriggerJobOpts.Lvl1SimulationConfig import Lvl1SimulationCfg
       cfg.merge(Lvl1SimulationCfg(flags), sequenceName="HLTBeginSeq")
 
   # Track overlay needs this to ensure that the collections are copied correctly
   # (due to the hardcoding of the name in the converters)
   if flags.Overlay.doTrackOverlay:
       from TrkEventCnvTools.TrkEventCnvToolsConfig import TrkEventCnvSuperToolCfg
       cfg.merge(TrkEventCnvSuperToolCfg(flags))
 
   if flags.Common.isOnline:
     from TrigOnlineMonitor.TrigOnlineMonitorConfig import trigOpMonitorCfg
     cfg.merge( trigOpMonitorCfg(flags) )
 
   # Print config and statistics
   if log.getEffectiveLevel() <= logging.DEBUG:
       cfg.printConfig(withDetails=False, summariseProps=True, printDefaults=True)
 
   # Disable spurious warnings from HepMcParticleLink (ATR-21838)
   if flags.Input.isMC:
      cfg.addService(CompFactory.MessageSvc(setError=["HepMcParticleLink"]))
 
   from AthenaConfiguration.AccumulatorCache import AccumulatorDecorator
   AccumulatorDecorator.printStats()
 
   return cfg
 
 

set_flags()

def python.runHLT.set_flags

(

flags

)

Set default flags for running HLT

Definition at line 31 of file runHLT.py.

def set_flags(flags):
   """Set default flags for running HLT"""
   from AthenaConfiguration.Enums import BeamType
 
   flags.Trigger.doHLT = True    # needs to be set early as other flags depend on it
   flags.Trigger.EDMVersion = 3  # Run-3 EDM
   flags.Beam.Type = BeamType.Collisions
   flags.InDet.useDCS = False    # DCS is in general not available online
   flags.Muon.MuonTrigger = True # Setup muon reconstruction for trigger
 
   # Disable some forward detetors
   flags.Detector.GeometryALFA = False
   flags.Detector.GeometryFwdRegion = False
   flags.Detector.GeometryLucid = False
 
   # Increase scheduler checks and verbosity
   flags.Scheduler.CheckDependencies = True
   flags.Scheduler.EnableVerboseViews = True
   flags.Input.FailOnUnknownCollections = True
   flags.Scheduler.AutoLoadUnmetDependencies = False
 
 

Variable Documentation

flags

python.runHLT.flags

Definition at line 205 of file runHLT.py.