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
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 (optionally in a separate subProcess)

3.10.1.9.2. Functions

load_optical_properties_from_xml(...)	This function parses an xml file containing optical material properties.
create_g4_optical_properties_table(...)	Creates and fills a G4MaterialPropertiesTable with values from a dictionary created by a parsing function,
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

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

sources = []

g4_master_source_manager = None

g4_thread_source_managers = []

g4_particle_table = None

source_manager_options

close()

release_g4_references()

initialize(run_timing_intervals)

initialize_actors(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()

opengate.engines.load_optical_properties_from_xml(optical_properties_file, material_name)

This function parses an xml file containing optical material properties. Fetches property elements and property vector elements.

Returns a dictionary with the properties or None if the material is not found in the file.

opengate.engines.create_g4_optical_properties_table(material_properties_dictionary)

Creates and fills a G4MaterialPropertiesTable with values from a dictionary created by a parsing function, e.g. from an xml file. Returns G4MaterialPropertiesTable.

class opengate.engines.PhysicsEngine(simulation_engine)

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

gate_physics_constructors = []

close()

release_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_optical_material_properties()

initialize_user_limits_physics()

class opengate.engines.ActionEngine(simulation_engine)

Bases: opengate_core.G4VUserActionInitialization, EngineBase

Main object to manage all actions during a simulation.

simulation_engine

g4_PrimaryGenerator = []

g4_main_PrimaryGenerator = None

g4_RunAction = []

g4_EventAction = []

g4_TrackingAction = []

close()

release_g4_references()

BuildForMaster()

Build()

class opengate.engines.ActorEngine(simulation_engine)

Bases: EngineBase

This object manages all actors G4 objects at runtime

simulation_engine_wr

actors

close()

get_actor(name)

create_actors()

initialize(volume_engine=None)

register_all_actions(actor)

register_sensitive_detectors(world_name)

register_sensitive_detector_to_children(actor, lv)

start_simulation()

stop_simulation()

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

Bases: opengate_core.G4VUserParallelWorld, EngineBase

FIXME: Doc ParallelWorldEngine

parallel_world_name

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()

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

hook_log = []

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: EngineBase

Main class to execute a Simulation (optionally in a separate subProcess)

simulation

volume_engine

physics_engine

source_engine

action_engine

actor_engine

visu_engine

run_timing_intervals = None

is_initialized = False

new_process

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

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()

apply_g4_command(command)

check_volumes_overlap(verbose=True)

property g4_state

enable_user_event_information(actors)

opengate.engines.start_gdml_visu(filename)

opengate.engines.start_vrml_visu(filename)