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, overrides=None)
	from_json (cls, json_file, run_params=None, properties=None, overrides=None)
	from_database (cls, db_server, smk, l1psk=None, hltpsk=None, run_params=None, overrides=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
	overrides = overrides or RuntimeOverrides()

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.
It sets JobOptionsType and JobOptionsPath on the ApplicationMgr, and TrigConf::JobOptionsSvc
handles both FILE and DB modes transparently.

Definition at line 578 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,
			overrides = 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)
   overrides: RuntimeOverrides applied between configure() and initialize()

Definition at line 585 of file athenaEF.py.

                properties=None, db_server=None, smk=None, overrides=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)
         overrides: RuntimeOverrides applied between configure() and initialize()
      """
      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.overrides = overrides or RuntimeOverrides()
      self._app = None
   

Member Function Documentation

from_database()

athenaEF.ConfigRunner.from_database	(		cls,
			db_server,
			smk,
			l1psk = None,
			hltpsk = None,
			run_params = None,
			overrides = None )

Create runner for database (TYPE=DB)

Definition at line 612 of file athenaEF.py.

   def from_database(cls, db_server, smk, l1psk=None, hltpsk=None, run_params=None, overrides=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, overrides=overrides)
      

from_json()

athenaEF.ConfigRunner.from_json	(		cls,
			json_file,
			run_params = None,
			properties = None,
			overrides = None )

Create runner for JSON file (TYPE=FILE)

Definition at line 607 of file athenaEF.py.

   def from_json(cls, json_file, run_params=None, properties=None, overrides=None):
      """Create runner for JSON file (TYPE=FILE)"""
      return cls("FILE", os.path.abspath(json_file), run_params, properties, overrides=overrides)
   

run()

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

1. Create ApplicationMgr via BootstrapHelper
2. Set JobOptionsSvcType, JobOptionsType, JobOptionsPath
3. configure() -> initialize() -> prepareForStart() -> start() ->
   hltUpdateAfterFork() -> run() -> stop() -> finalize() -> terminate()

Definition at line 622 of file athenaEF.py.

   def run(self, maxEvents=None):
      """
      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
      #Set trigger defaults here, see ATR-32996
      app.setProperty("MessageSvcType", "TrigMessageSvc")
      
      # 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
      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))
      
      # Overrides must be applied after configure() but before initialize().
      self.overrides.apply()
 
      # THistSvc.Output cannot be scheduled in main(): setTHistSvcOutput() has to run
      # against the service that configure() actually created.
      if self.overrides.service_types.get('THistSvc') == 'THistSvc':
         from GaudiPython.Bindings import iProperty
         from TriggerJobOpts.TriggerHistSvcConfig import setTHistSvcOutput
         output = []
         setTHistSvcOutput(output)
         iProperty("THistSvc").Output = output
 
      # Postcommands run last.
      if self.overrides.commands:
         log.info("Executing postcommand(s)")
         for cmd in self.overrides.commands:
            log.info("  %s", cmd)
            exec(cmd, globals(), {'app': app})
 
      # 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
      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']
         beam_type = self.run_params['beam_type']
         beam_energy = self.run_params['beam_energy']
         lb_number = self.run_params['lb_number']
         
         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,
            lb_number=lb_number,
            beam_type=beam_type,
            beam_energy=beam_energy,
            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
      # 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 604 of file athenaEF.py.

db_server

athenaEF.ConfigRunner.db_server = db_server

Definition at line 601 of file athenaEF.py.

job_options_path

athenaEF.ConfigRunner.job_options_path = job_options_path

Definition at line 598 of file athenaEF.py.

job_options_type

athenaEF.ConfigRunner.job_options_type = job_options_type

Definition at line 597 of file athenaEF.py.

overrides

athenaEF.ConfigRunner.overrides = overrides or RuntimeOverrides()

Definition at line 603 of file athenaEF.py.

properties

athenaEF.ConfigRunner.properties = properties

Definition at line 600 of file athenaEF.py.

run_params

athenaEF.ConfigRunner.run_params = run_params or {}

Definition at line 599 of file athenaEF.py.

smk

athenaEF.ConfigRunner.smk = smk

Definition at line 602 of file athenaEF.py.

---

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

• athenaEF.py