feat: allow users of ddsim to set e.g. stepping action

DDG4/include/DDG4/Geant4TestActions.h

@@ -148,6 +148,26 @@ namespace dd4hep {
         void operator()(const G4Step*, G4SteppingManager*)  override;
       };
 
+      /// Example stacking action doing nothing, but print
+      /**
+       *  \author  M.Frank
+       *  \version 1.0
+       *  \ingroup DD4HEP_SIMULATION
+       */
+      class Geant4TestStackAction: public Geant4StackingAction, public Geant4TestBase {
+      public:
+        /// Standard constructor with initializing arguments
+        Geant4TestStackAction(Geant4Context* c, const std::string& n);
+        /// Default destructor
+        virtual ~Geant4TestStackAction();
+        /// New-stage callback
+        virtual void newStage(G4StackManager*)  override;
+        /// Preparation callback
+        virtual void prepare(G4StackManager*)  override;
+        /// Return TrackClassification with enum G4ClassificationOfNewTrack or NoTrackClassification
+        virtual TrackClassification classifyNewTrack(G4StackManager*, const G4Track*)  override;
+      };
+
       /// Example sensitve detector action doing nothing, but print
       /**
        *  \author  M.Frank

DDG4/plugins/Geant4Factories.cpp

@@ -139,7 +139,7 @@ DECLARE_GEANT4ACTION(Geant4TestRunAction)
 DECLARE_GEANT4ACTION(Geant4TestEventAction)
 DECLARE_GEANT4ACTION(Geant4TestStepAction)
 DECLARE_GEANT4ACTION(Geant4TestTrackAction)
-//DECLARE_GEANT4ACTION(Geant4TestStackingAction)
+DECLARE_GEANT4ACTION(Geant4TestStackAction)
 DECLARE_GEANT4ACTION(Geant4TestGeneratorAction)
 DECLARE_GEANT4SENSITIVE(Geant4TestSensitive)
 DECLARE_GEANT4SENSITIVE(Geant4TestSensitiveTracker)

DDG4/python/DDSim/DD4hepSimulation.py

@@ -347,6 +347,20 @@ def run(self):
     # configure geometry creation
     self.geometry.constructGeometry(kernel, geant4, self.output.geometry)
 
+    # ----------------------------------------------------------------------------------
+    # Configure run, event, track, step, and stack actions, if present
+    for action_list, DDG4_Action, kernel_Action in \
+        [(self.action.run, DDG4.RunAction, kernel.runAction),
+         (self.action.event, DDG4.EventAction, kernel.eventAction),
+         (self.action.track, DDG4.TrackingAction, kernel.trackingAction),
+         (self.action.step, DDG4.SteppingAction, kernel.steppingAction),
+         (self.action.stack, DDG4.StackingAction, kernel.stackingAction)]:
+      for action_dict in action_list:
+        action = DDG4_Action(kernel, action_dict["name"])
+        for parameter, value in action_dict['parameter'].items():
+          setattr(action, parameter, value)
+        kernel_Action().add(action)
+
     # ----------------------------------------------------------------------------------
     # Configure Run actions
     run1 = DDG4.RunAction(kernel, 'Geant4TestRunAction/RunInit')

DDG4/python/DDSim/Helper/Action.py

@@ -5,9 +5,9 @@
 
 
 class Action(ConfigHelper):
-  """Helper holding sensitive detector actions.
+  """Helper holding sensitive detector and other actions.
 
-  The default tracker and calorimeter actions can be set with
+  The default tracker and calorimeter sensitive actions can be set with
 
   >>> SIM = DD4hepSimulation()
   >>> SIM.action.tracker=('Geant4TrackerWeightedAction', {'HitPositionCombination': 2, 'CollectSingleDeposits': False})
@@ -30,6 +30,15 @@ class Action(ConfigHelper):
   >>> SIM = DD4hepSimulation()
   >>> SIM.action.mapActions['ecal'] =( "CaloPreShowerSDAction", {"FirstLayerNumber": 1} )
 
+  Additional actions can be set as well with
+
+  >>> SIM = DD4hepSimulation()
+  >>> SIM.action.run = [ ("Geant4TestRunAction", {"Property_int": 10} ) ]
+  >>> SIM.action.event = [ ("Geant4TestEventAction", {"Property_int": 10} ) ]
+  >>> SIM.action.track = [ ("Geant4TestTrackAction", {"Property_int": 10} ) ]
+  >>> SIM.action.step = [ ("Geant4TestStepAction", {"Property_int": 10} ) ]
+  >>> SIM.action.stack = [ ("Geant4TestStackAction", {"Property_int": 10} ) ]
+
   """
 
   def __init__(self):
@@ -39,6 +48,11 @@ def __init__(self):
     self._mapActions = dict()
     self._trackerSDTypes = ['tracker']
     self._calorimeterSDTypes = ['calorimeter']
+    self._run = []
+    self._event = []
+    self._track = []
+    self._step = []
+    self._stack = []
     self._closeProperties()
 
   @property
@@ -108,3 +122,71 @@ def calorimeterSDTypes(self):
   @calorimeterSDTypes.setter
   def calorimeterSDTypes(self, val):
     self._calorimeterSDTypes = ConfigHelper.makeList(val)
+
+  @staticmethod
+  def makeListOfDictFromJSON(val):
+    if isinstance(val, str):
+      # assumes: valid JSON string or comma-separated list of names
+      import json
+      try:
+        val = json.loads(val)
+      except ValueError:
+        val = tuple(val.split(","))
+    if isinstance(val, tuple):
+      # assumes: ( "Geant4TestEventAction", {"Property_int": 10} )
+      # creates: { "name": "Geant4TestEventAction", "parameter": {"Property_int": 10} }
+      # note: not able to specified as json which only allows a list
+      val = dict(name=val[0], parameter=val[1])
+    if isinstance(val, dict):
+      # assumes: { "name": "Geant4TestEventAction", "parameter": {"Property_int": 10} }
+      # creates: [ { "name": "Geant4TestEventAction", "parameter": {"Property_int": 10} } ]
+      val = [val]
+    if isinstance(val, list):
+      # assumes: [ { "name": "Geant4TestEventAction", "parameter": {"Property_int": 10} } ]
+      return val
+    raise RuntimeError("Commandline setting of action is not successful for: %s " % val)
+
+  @property
+  def run(self):
+    """ set the default run action """
+    return self._run
+
+  @run.setter
+  def run(self, val):
+    self._run.extend(Action.makeListOfDictFromJSON(val))
+
+  @property
+  def event(self):
+    """ set the default event action """
+    return self._event
+
+  @event.setter
+  def event(self, val):
+    self._event.extend(Action.makeListOfDictFromJSON(val))
+
+  @property
+  def track(self):
+    """ set the default track action """
+    return self._track
+
+  @track.setter
+  def track(self, val):
+    self._track.extend(Action.makeListOfDictFromJSON(val))
+
+  @property
+  def step(self):
+    """ set the default step action """
+    return self._step
+
+  @step.setter
+  def step(self, val):
+    self._step.extend(Action.makeListOfDictFromJSON(val))
+
+  @property
+  def stack(self):
+    """ set the default stack action """
+    return self._stack
+
+  @stack.setter
+  def stack(self, val):
+    self._stack.extend(Action.makeListOfDictFromJSON(val))

DDG4/src/Geant4TestActions.cpp

@@ -49,6 +49,7 @@ Geant4TestBase::Geant4TestBase(Geant4Action* a, const std::string& typ)
 }
 /// Default destructor
 Geant4TestBase::~Geant4TestBase() {
+  printout(VERBOSE, m_type, "properties at destruction: %d, %f, %s", m_value1, m_value2, m_value3.c_str());
   InstanceCount::decrement(this);
 }
 
@@ -185,6 +186,33 @@ void Geant4TestStepAction::operator()(const G4Step*, G4SteppingManager*) {
   PRINT("%s> calling operator()", m_type.c_str());
 }
 
+/// Standard constructor with initializing arguments
+Geant4TestStackAction::Geant4TestStackAction(Geant4Context* c, const std::string& n)
+  : Geant4StackingAction(c, n), Geant4TestBase(this, "Geant4TestStackAction") {
+  InstanceCount::increment(this);
+}
+
+/// Default destructor
+Geant4TestStackAction::~Geant4TestStackAction() {
+  InstanceCount::decrement(this);
+}
+/// New-stage callback
+void Geant4TestStackAction::newStage(G4StackManager*) {
+  PRINT("%s> calling newStage()", m_type.c_str());
+}
+/// Preparation callback
+void Geant4TestStackAction::prepare(G4StackManager*) {
+  PRINT("%s> calling prepare()", m_type.c_str());
+}
+/// Return TrackClassification with enum G4ClassificationOfNewTrack or NoTrackClassification
+TrackClassification Geant4TestStackAction::classifyNewTrack(G4StackManager*, const G4Track* trk) {
+  PRINT("%s> calling classifyNewTrack(track=%d, parent=%d, position=(%f,%f,%f) Context: run=%p evt=%p)",
+        m_type.c_str(), trk->GetTrackID(),
+        trk->GetParentID(), trk->GetPosition().x(), trk->GetPosition().y(), trk->GetPosition().z(),
+        &context()->run(), &context()->event());
+  return TrackClassification();
+}
+
 /// Standard constructor with initializing arguments
 Geant4TestSensitive::Geant4TestSensitive(Geant4Context* c, const std::string& n, DetElement det, Detector& description)
   : Geant4Sensitive(c, n, det, description), Geant4TestBase(this, "Geant4TestSensitive") {