3.10.1.9. opengate.engines

3.10.1.9.1. Classes

EngineBase	Base class for all engines (SimulationEngine, VolumeEngine, etc.)
SourceEngine	Source Engine manages the G4 objects of sources at runtime
PhysicsEngine	Class that contains all the information and mechanism regarding physics
ActionEngine	Main object to manage all actions during a simulation.
ActorEngine	This object manages all actors G4 objects at runtime
FilterEngine	Base class for all engines (SimulationEngine, VolumeEngine, etc.)
ParallelWorldEngine	FIXME: Doc ParallelWorldEngine
VolumeEngine	Engine that will create all G4 elements for the hierarchy of volumes.
VisualisationEngine	Main class to manage visualisation
SimulationOutput	FIXME
SimulationEngine	Main class to execute a Simulation. Can only be created once per process because Geant4 dictates so.

3.10.1.9.2. Functions

register_sensitive_detector_to_children(actor, lv)
start_gdml_visu(filename)
start_vrml_visu(filename)

3.10.1.9.3. Module Contents

class opengate.engines.EngineBase(simulation_engine)

Base class for all engines (SimulationEngine, VolumeEngine, etc.)

simulation_engine

verbose_getstate

verbose_close

close()

__getstate__()

class opengate.engines.SourceEngine(simulation_engine)

Bases: EngineBase

Source Engine manages the G4 objects of sources at runtime

max_int = 2147483647

simulation_engine

run_timing_intervals = None

current_run_interval = None

progress_bar = False

expected_number_of_events = 'unknown'

sources = []

g4_master_source_manager = None

g4_thread_source_managers = []

source_manager_options

close()

release_g4_references()

initialize(run_timing_intervals, progress_bar=False)

initialize_actors()

3.10.1.9. Parameters

actorsdict

The dictionary ActorEngine.actors which contains key-value pairs “actor_name” : “Actor object”

create_master_source_manager()

create_g4_source_manager(append=True)

This is called by all threads This object is needed here, because it can only be created after physics initialization

start()

can_predict_expected_number_of_event()

class opengate.engines.PhysicsEngine(*args)

Bases: EngineBase

Class that contains all the information and mechanism regarding physics to actually run a simulation. It is associated with a simulation engine.

physics_manager

g4_physics_list = None

g4_decay = None

g4_radioactive_decay = None

g4_cuts_by_regions = []

g4_em_parameters = None

g4_parallel_world_physics = []

g4_optical_material_tables

g4_physical_volumes = []

g4_surface_properties = None

gate_physics_constructors = []

optical_surfaces_properties_dict

close()

release_g4_references()

release_optical_surface_g4_references()

close_physics_constructors()

This method removes PhysicsConstructors defined in python from the physics list.

It should be called after a simulation run, i.e. when a simulation engine closes, because the RunManager will otherwise attempt to delete the PhysicsConstructor and cause a segfault.

property user_info_physics_manager

initialize_before_runmanager()

Initialize methods to be called before G4RunManager.Initialize() is called.

initialize_after_runmanager()

initialize_parallel_world_physics()

initialize_physics_list()

Create a Physic List from the Factory

initialize_regions()

initialize_global_cuts()

initialize_g4_em_parameters()

initialize_physics_biasing()

initialize_optical_material_properties()

initialize_optical_surfaces()

Calls initialize() method of each OpticalSurface instance.

initialize_user_limits_physics()

class opengate.engines.ActionEngine(*args)

Bases: opengate_core.G4VUserActionInitialization, EngineBase

Main object to manage all actions during a simulation.

g4_PrimaryGenerator = []

g4_main_PrimaryGenerator = None

g4_RunAction = []

g4_EventAction = []

g4_TrackingAction = []

close()

release_g4_references()

register_all_actions(actor)

register_run_actions(actor)

register_event_actions(actor)

register_tracking_actions(actor)

BuildForMaster()

Build()

opengate.engines.register_sensitive_detector_to_children(actor, lv)

class opengate.engines.ActorEngine(*args, **kwargs)

Bases: EngineBase

This object manages all actors G4 objects at runtime

property actor_manager

close()

initialize()

register_to_actors()

register_sensitive_detectors(world_name)

start_simulation()

stop_simulation()

class opengate.engines.FilterEngine(*args, **kwargs)

Bases: EngineBase

Base class for all engines (SimulationEngine, VolumeEngine, etc.)

property filter_manager

initialize()

close()

class opengate.engines.ParallelWorldEngine(parallel_world_name, *args)

Bases: opengate_core.G4VUserParallelWorld, EngineBase

FIXME: Doc ParallelWorldEngine

parallel_world_name

close()

property parallel_world_volume

Construct()

G4 overloaded. Override the Construct method from G4VUserParallelWorld

ConstructSD()

class opengate.engines.VolumeEngine(simulation_engine)

Bases: opengate_core.G4VUserDetectorConstruction, EngineBase

Engine that will create all G4 elements for the hierarchy of volumes. Correspond to the G4VUserDetectorConstruction (inherit) Also manage the list of parallel worlds.

_is_constructed = False

volume_manager

parallel_world_engines

create_parallel_world_engines()

register_to_volumes()

close()

initialize()

initialize_dynamic_parametrisations()

Construct()

G4 overloaded. Override the Construct method from G4VUserDetectorConstruction

check_overlaps(verbose)

ConstructSDandField()

G4 overloaded

get_volume(name)

get_database_material_names(db=None)

dump_build_materials(level=0)

class opengate.engines.VisualisationEngine(simulation_engine)

Bases: EngineBase

Main class to manage visualisation

g4_vis_executive = None

current_visu_filename = None

_is_closed = None

simulation

close()

release_g4_references()

__enter__()

__exit__(type, value, traceback)

initialize_visualisation()

initialize_visualisation_gdml()

initialize_visualisation_vrml()

start_visualisation()

class opengate.engines.SimulationOutput

FIXME

simulation = None

actors

sources

sources_by_thread

pid

ppid

current_random_seed = None

user_hook_log = []

warnings = None

store_actors(simulation_engine)

store_hook_log(simulation_engine)

store_sources(simulation_engine)

get_actor(name)

get_source(name)

get_source_mt(name, thread)

class opengate.engines.SimulationEngine(simulation, new_process=False)

Bases: opengate.base.GateSingletonFatal

Main class to execute a Simulation. Can only be created once per process because Geant4 dictates so.

simulation

verbose_getstate

verbose_close

volume_engine

physics_engine

source_engine

action_engine

actor_engine

filter_engine

visu_engine

run_timing_intervals = None

is_initialized = False

new_process

g4_ui_session = None

g4_ui = None

g4_HepRandomEngine = None

current_random_seed = None

g4_RunManager = None

g4_StateManager

run_manager_finalizer = None

_is_closed = False

g4_exception_handler = None

user_hook_after_init

user_hook_after_run

user_hook_log = []

close_engines()

release_engines()

release_g4_references()

notify_managers()

close()

__enter__()

__exit__(_type, value, traceback)

__getstate__()

__setstate__(d)

run_engine()

When the simulation is about to init, if the Simulation object is in a separate process (with ‘spawn’), it has been pickled (copied) and the G4 phys list classes does not exist anymore, so we need to recreate them with ‘create_physics_list_classes’ Also, the StateManager must be recreated.

NK: Yes, but not this way. Each class should take care of recreating attributes which where set to None during pickling by implementing a __setstate__ method. Implementing the resetting somewhere else (maybe in multiple places…) in the code will make it very difficult to maintain.

-> removed the lines and implemented __setstate__ methods for the classes in question

start_and_stop()

Start the simulation. The runs are managed in the SourceManager.

initialize_random_engine()

initialize_g4_verbose()

initialize()

Build the main geant4 objects and initialize them.

create_run_manager()

Get the correct RunManager according to the requested threads and make some basic settings.

apply_all_g4_commands_after_init()

apply_all_g4_commands_before_init()

add_g4_command_after_init(command)

check_volumes_overlap(verbose=True)

property g4_state

initialize_user_event_information_flag()

opengate.engines.start_gdml_visu(filename)

opengate.engines.start_vrml_visu(filename)