athenaEF.ConfigRunner Class Reference

Collaboration diagram for athenaEF.ConfigRunner:

Public Member Functions
	__init__ (self, job_options_type, job_options_path, run_params=None, properties=None, db_server=None, smk=None, num_threads=1, num_slots=1, ef_files=None)
	from_json (cls, json_file, run_params=None, properties=None, num_threads=1, num_slots=1, ef_files=None)
	from_database (cls, db_server, smk, l1psk=None, hltpsk=None, run_params=None, num_threads=1, num_slots=1, ef_files=None)
	run (self, maxEvents=None)

Public Attributes
str	job_options_type = job_options_type
	job_options_path = job_options_path
	run_params = run_params or {}
	properties = properties
	db_server = db_server
	smk = smk
	num_threads = num_threads
	num_slots = num_slots
	ef_files = ef_files or []

Protected Attributes
	_app = None

Detailed Description

Runner class that executes Gaudi configuration from JSON file or database.
Uses TrigConf::JobOptionsSvc with TYPE="FILE" or TYPE="DB" to load configuration.
Same approach used by PSC (Psc.cxx) - it sets JobOptionsType and
JobOptionsPath on the ApplicationMgr, and TrigConf::JobOptionsSvc handles both
FILE and DB modes transparently.

Definition at line 508 of file athenaEF.py.

Constructor & Destructor Documentation

__init__()

athenaEF.ConfigRunner.__init__	(		self,
			job_options_type,
			job_options_path,
			run_params = None,
			properties = None,
			db_server = None,
			smk = None,
			num_threads = 1,
			num_slots = 1,
			ef_files = None )

Args:
   job_options_type: "FILE" or "DB"
   job_options_path: JSON file path (for FILE) or DB connection string (for DB)
   run_params: Run parameters dict for prepareForStart
   properties: Pre-loaded properties dict (optional, for FILE mode)
   db_server: DB server alias (for store() in DB mode)
   smk: Super Master Key (for store() in DB mode)
   num_threads: Number of threads for AvalancheSchedulerSvc.ThreadPoolSize
   num_slots: Number of event slots for EventDataSvc.NSlots
   ef_files: List of input files for EFInterfaceSvc

Definition at line 516 of file athenaEF.py.

                num_threads=1, num_slots=1, ef_files=None):
      """
      Args:
         job_options_type: "FILE" or "DB"
         job_options_path: JSON file path (for FILE) or DB connection string (for DB)
         run_params: Run parameters dict for prepareForStart
         properties: Pre-loaded properties dict (optional, for FILE mode)
         db_server: DB server alias (for store() in DB mode)
         smk: Super Master Key (for store() in DB mode)
         num_threads: Number of threads for AvalancheSchedulerSvc.ThreadPoolSize
         num_slots: Number of event slots for EventDataSvc.NSlots
         ef_files: List of input files for EFInterfaceSvc
      """
      self.job_options_type = job_options_type
      self.job_options_path = job_options_path
      self.run_params = run_params or {}
      self.properties = properties
      self.db_server = db_server  # For store() in DB mode
      self.smk = smk              # For store() in DB mode
      self.num_threads = num_threads
      self.num_slots = num_slots
      self.ef_files = ef_files or []  # Input files for EFInterfaceSvc
      self._app = None
   

Member Function Documentation

from_database()

athenaEF.ConfigRunner.from_database	(		cls,
			db_server,
			smk,
			l1psk = None,
			hltpsk = None,
			run_params = None,
			num_threads = 1,
			num_slots = 1,
			ef_files = None )

Create runner for database (TYPE=DB)

Definition at line 550 of file athenaEF.py.

                     num_threads=1, num_slots=1, ef_files=None):
      """Create runner for database (TYPE=DB)"""
      # Build the DB connection string: server=X;smkey=Y;lvl1key=Z;hltkey=W
      db_path = f"server={db_server};smkey={smk}"
      if l1psk is not None:
         db_path += f";lvl1key={l1psk}"
      if hltpsk is not None:
         db_path += f";hltkey={hltpsk}"
      return cls("DB", db_path, run_params, db_server=db_server, smk=smk,
                 num_threads=num_threads, num_slots=num_slots, ef_files=ef_files)
      

from_json()

athenaEF.ConfigRunner.from_json	(		cls,
			json_file,
			run_params = None,
			properties = None,
			num_threads = 1,
			num_slots = 1,
			ef_files = None )

Create runner for JSON file (TYPE=FILE)

Definition at line 543 of file athenaEF.py.

                 num_threads=1, num_slots=1, ef_files=None):
      """Create runner for JSON file (TYPE=FILE)"""
      return cls("FILE", os.path.abspath(json_file), run_params, properties,
                 num_threads=num_threads, num_slots=num_slots, ef_files=ef_files)
   

run()

athenaEF.ConfigRunner.run	(		self,
			maxEvents = None )

This follows the same pattern as PSC (Psc.cxx):
1. Create ApplicationMgr via BootstrapHelper
2. Set JobOptionsSvcType, JobOptionsType, JobOptionsPath
3. configure() -> initialize() -> prepareForStart() -> start() ->
   hltUpdateAfterFork() -> run() -> stop() -> finalize() -> terminate()

Definition at line 562 of file athenaEF.py.

   def run(self, maxEvents=None):
      """
      This follows the same pattern as PSC (Psc.cxx):
      1. Create ApplicationMgr via BootstrapHelper
      2. Set JobOptionsSvcType, JobOptionsType, JobOptionsPath
      3. configure() -> initialize() -> prepareForStart() -> start() ->
         hltUpdateAfterFork() -> run() -> stop() -> finalize() -> terminate()
      """
      from Gaudi.Main import BootstrapHelper
      
      # For FILE mode, load properties from JSON if not already provided
      if self.job_options_type == "FILE" and self.properties is None:
         with open(self.job_options_path, 'r') as f:
            jocat = json.load(f)
         self.properties = jocat.get('properties', {})
      
      bsh = BootstrapHelper()
      app = bsh.createApplicationMgr()
      self._app = app
      
      # For FILE mode, set ApplicationMgr properties from JSON before configure
      if self.job_options_type == "FILE" and self.properties:
         app_props = self.properties.get('ApplicationMgr', {})
         for k, v in app_props.items():
            if k not in ('JobOptionsSvcType', 'JobOptionsType', 'JobOptionsPath'):
               log.debug("Setting ApplicationMgr.%s = %s", k, v)
               app.setProperty(k, str(v) if not isinstance(v, str) else v)
      
      # Set JobOptionsSvc properties like PSC does in Psc.cxx
      log.info("Configuring TrigConf::JobOptionsSvc with TYPE=%s, PATH=%s",
               self.job_options_type, self.job_options_path)
      app.setProperty("JobOptionsSvcType", "TrigConf::JobOptionsSvc")
      app.setProperty("JobOptionsType", self.job_options_type)
      app.setProperty("JobOptionsPath", self.job_options_path)
      
      # Configure the application - TrigConf::JobOptionsSvc will load from FILE or DB
      app.configure()
      
      # Override EvtMax AFTER configure() only if explicitly specified by user
      # Otherwise use whatever value is in the DB
      if maxEvents is not None:
         log.info("Setting EvtMax=%d (overriding DB value)", maxEvents)
         app.setProperty('EvtMax', str(maxEvents))
      
      # All property overrides below use iProperty and must be done after configure()
      # but before initialize() - this is the same pattern as PSC (Psc.cxx)
      from GaudiPython.Bindings import iProperty
      
      # Override EFInterfaceSvc.NumEvents if user specified it (overrides DB value)
      if maxEvents is not None:
         log.info("Setting EFInterfaceSvc.NumEvents=%d (overriding DB value)", maxEvents)
         iProperty("EFInterfaceSvc").NumEvents = maxEvents
      
      # Set threading configuration
      log.info("Setting threading: ThreadPoolSize=%d, NSlots=%d", self.num_threads, self.num_slots)
      iProperty("AvalancheSchedulerSvc").ThreadPoolSize = self.num_threads
      iProperty("EventDataSvc").NSlots = self.num_slots
      
      # Set input files for EFInterfaceSvc (overrides what's in DB/JSON config)
      if self.ef_files:
         log.info("Setting EFInterfaceSvc.Files = %s", self.ef_files)
         iProperty("EFInterfaceSvc").Files = self.ef_files
      
      # If HLT PSK is set on command line, read it from DB instead of COOL (ATR-25974)
      # This is the same logic as TrigPSCPythonDbSetup.py
      from TrigPSC import PscConfig
      if PscConfig.forcePSK:
         log.info("PscConfig.forcePSK is set - configuring HLTPrescaleCondAlg to read from DB instead of COOL")
         iProperty("HLTPrescaleCondAlg").Source = "DB"
      
      # Set forceRunNumber on HltEventLoopMgr if conditions_run is specified
      # This overrides the run number used for IOV lookup in conditions loading
      conditions_run = self.run_params.get('conditions_run')
      if conditions_run is not None:
         log.info("Setting HltEventLoopMgr.forceRunNumber=%d for conditions lookup", conditions_run)
         iProperty("HltEventLoopMgr").forceRunNumber = conditions_run
      
      # Initialize
      sc = app.initialize()
      if not sc.isSuccess():
         log.error("Failed to initialize AppMgr")
         return sc
      
      # Initialize TrigServicesHelper for lifecycle calls (prepareForStart, prepareForRun, hltUpdateAfterFork)
      try:
         from TrigServices.TrigServicesHelper import TrigServicesHelper
         helper = TrigServicesHelper()
      except ImportError as e:
         log.error("TrigServicesHelper not available: %s", e)
         log.error("Cannot proceed without TrigServicesHelper - required for HLTEventLoopMgr lifecycle")
         raise RuntimeError("TrigServicesHelper not available") from e
      
      # Call prepareForStart to set up ByteStreamMetadata (like PSC does)
      try:
         run_number = self.run_params['run_number']
         det_mask = self.run_params['detector_mask']
         sor_time = self.run_params['sor_time']
         solenoid_current = self.run_params['solenoid_current']
         toroids_current = self.run_params['toroids_current']
         
         log.info("Calling prepareForStart with run=%d, det_mask=0x%s, sor_time=%s",
                  run_number, det_mask, sor_time)
         
         success = helper.prepareForStart(
            run_number=run_number,
            det_mask=det_mask,
            sor_time=sor_time,
            solenoid_current=solenoid_current,
            toroids_current=toroids_current
         )
         if not success:
            log.error("prepareForStart failed")
            raise RuntimeError("prepareForStart failed")
         log.info("prepareForStart completed successfully")
      except Exception as e:
         log.error("Error calling prepareForStart: %s", e)
         traceback.print_exc()
         raise
      
      # Start
      sc = app.start()
      if not sc.isSuccess():
         log.error("Failed to start AppMgr")
         return sc
      
      # prepareForRun initializes COOL folder helper - must be called after start() 
      # which fires the start incident
      try:
         log.info("Calling prepareForRun to initialize COOL folder helper")
         success = helper.prepareForRun()
         if not success:
            log.error("prepareForRun failed")
            raise RuntimeError("prepareForRun failed")
         log.info("prepareForRun completed successfully")
      except Exception as e:
         log.error("Error calling prepareForRun: %s", e)
         traceback.print_exc()
         raise
      
      # hltUpdateAfterFork initializes the scheduler (like PSC does after fork)
      # worker_id=1 for single-worker, non-forked mode
      try:
         log.info("Calling hltUpdateAfterFork to initialize scheduler (worker_id=1)")
         success = helper.hltUpdateAfterFork(worker_id=1)
         if not success:
            log.error("hltUpdateAfterFork failed")
            raise RuntimeError("hltUpdateAfterFork failed")
         log.info("hltUpdateAfterFork completed successfully")
      except Exception as e:
         log.error("Error calling hltUpdateAfterFork: %s", e)
         traceback.print_exc()
         raise
      
      # Run the event loop
      # Note: Python signal handlers won't work during C++ execution.
      nevt = maxEvents if maxEvents is not None else -1
      sc = app.run(nevt)
      
      if not sc.isSuccess():
         log.error("Failure running application")
         return sc
         
      # Stop
      sc = app.stop()
      if not sc.isSuccess():
         log.error("Failed to stop AppMgr")
         return sc
         
      # Finalize
      sc = app.finalize()
      if not sc.isSuccess():
         log.error("Failed to finalize AppMgr")
         return sc
         
      # Terminate
      sc = app.terminate()
      return sc
 
 

Member Data Documentation

_app

athenaEF.ConfigRunner._app = None

protected

Definition at line 540 of file athenaEF.py.

db_server

athenaEF.ConfigRunner.db_server = db_server

Definition at line 535 of file athenaEF.py.

ef_files

athenaEF.ConfigRunner.ef_files = ef_files or []

Definition at line 539 of file athenaEF.py.

job_options_path

athenaEF.ConfigRunner.job_options_path = job_options_path

Definition at line 532 of file athenaEF.py.

job_options_type

athenaEF.ConfigRunner.job_options_type = job_options_type

Definition at line 531 of file athenaEF.py.

num_slots

athenaEF.ConfigRunner.num_slots = num_slots

Definition at line 538 of file athenaEF.py.

num_threads

athenaEF.ConfigRunner.num_threads = num_threads

Definition at line 537 of file athenaEF.py.

properties

athenaEF.ConfigRunner.properties = properties

Definition at line 534 of file athenaEF.py.

run_params

athenaEF.ConfigRunner.run_params = run_params or {}

Definition at line 533 of file athenaEF.py.

smk

athenaEF.ConfigRunner.smk = smk

Definition at line 536 of file athenaEF.py.

---

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

• athenaEF.py