Kill not interacting particles actor

core/opengate_core/opengate_core.cpp

@@ -294,6 +294,8 @@ void init_GateARFTrainingDatasetActor(py::module &m);
 
 void init_GateKillActor(py::module &);
 
+void init_GateKillNonInteractingParticleActor(py::module &);
+
 void init_itk_image(py::module &);
 
 void init_GateImageNestedParameterisation(py::module &);
@@ -561,6 +563,7 @@ PYBIND11_MODULE(opengate_core, m) {
   init_GateARFActor(m);
   init_GateARFTrainingDatasetActor(m);
   init_GateKillActor(m);
+  init_GateKillNonInteractingParticleActor(m);
   init_GateDigiAttributeManager(m);
   init_GateVDigiAttribute(m);
   init_GateExceptionHandler(m);

core/opengate_core/opengate_lib/GateKillNonInteractingParticleActor.cpp

@@ -0,0 +1,75 @@
+/* --------------------------------------------------
+   Copyright (C): OpenGATE Collaboration
+   This software is distributed under the terms
+   of the GNU Lesser General  Public Licence (LGPL)
+   See LICENSE.md for further details
+   ------------------------------------ -------------- */
+
+#include "GateKillNonInteractingParticleActor.h"
+#include "G4LogicalVolumeStore.hh"
+#include "G4PhysicalVolumeStore.hh"
+#include "G4ios.hh"
+#include "GateHelpers.h"
+#include "GateHelpersDict.h"
+
+GateKillNonInteractingParticleActor::GateKillNonInteractingParticleActor(
+    py::dict &user_info)
+    : GateVActor(user_info, false) {
+  fActions.insert("StartSimulationAction");
+  fActions.insert("SteppingAction");
+  fActions.insert("PreUserTrackingAction");
+}
+
+void GateKillNonInteractingParticleActor::ActorInitialize() {}
+
+void GateKillNonInteractingParticleActor::StartSimulationAction() {
+  fNbOfKilledParticles = 0;
+}
+
+void GateKillNonInteractingParticleActor::PreUserTrackingAction(
+    const G4Track *track) {
+  fIsFirstStep = true;
+  fKineticEnergyAtTheEntrance = 0;
+  ftrackIDAtTheEntrance = 0;
+  fPassedByTheMotherVolume = false;
+}
+
+void GateKillNonInteractingParticleActor::SteppingAction(G4Step *step) {
+
+  G4String logNameMotherVolume = G4LogicalVolumeStore::GetInstance()
+                                     ->GetVolume(fMotherVolumeName)
+                                     ->GetName();
+  G4String physicalVolumeNamePreStep =
+      step->GetPreStepPoint()->GetPhysicalVolume()->GetName();
+  if ((step->GetTrack()->GetLogicalVolumeAtVertex()->GetName() !=
+       logNameMotherVolume) &&
+      (fIsFirstStep)) {
+    if ((fPassedByTheMotherVolume == false) &&
+        (physicalVolumeNamePreStep == fMotherVolumeName) &&
+        (step->GetPreStepPoint()->GetStepStatus() == 1)) {
+      fPassedByTheMotherVolume = true;
+      fKineticEnergyAtTheEntrance = step->GetPreStepPoint()->GetKineticEnergy();
+      ftrackIDAtTheEntrance = step->GetTrack()->GetTrackID();
+    }
+  }
+
+  G4String logicalVolumeNamePostStep = step->GetPostStepPoint()
+                                           ->GetPhysicalVolume()
+                                           ->GetLogicalVolume()
+                                           ->GetName();
+  if ((fPassedByTheMotherVolume) &&
+      (step->GetPostStepPoint()->GetStepStatus() == 1)) {
+    if (std::find(fListOfVolumeAncestor.begin(), fListOfVolumeAncestor.end(),
+                  logicalVolumeNamePostStep) != fListOfVolumeAncestor.end()) {
+      if ((step->GetTrack()->GetTrackID() == ftrackIDAtTheEntrance) &&
+          (step->GetPostStepPoint()->GetKineticEnergy() ==
+           fKineticEnergyAtTheEntrance)) {
+        auto track = step->GetTrack();
+        track->SetTrackStatus(fStopAndKill);
+        fNbOfKilledParticles++;
+      }
+    }
+  }
+
+  fIsFirstStep = false;
+}

core/opengate_core/opengate_lib/GateKillNonInteractingParticleActor.h

@@ -0,0 +1,42 @@
+/* --------------------------------------------------
+   Copyright (C): OpenGATE Collaboration
+   This software is distributed under the terms
+   of the GNU Lesser General  Public Licence (LGPL)
+   See LICENSE.md for further details
+   -------------------------------------------------- */
+
+#ifndef GateKillNonInteractingParticleActor_h
+#define GateKillNonInteractingParticleActor_h
+
+#include "G4Cache.hh"
+#include "GateVActor.h"
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+class GateKillNonInteractingParticleActor : public GateVActor {
+
+public:
+  // Constructor
+  GateKillNonInteractingParticleActor(py::dict &user_info);
+
+  void ActorInitialize() override;
+
+  void StartSimulationAction() override;
+
+  // Main function called every step in attached volume
+  void SteppingAction(G4Step *) override;
+
+  void PreUserTrackingAction(const G4Track *) override;
+
+  std::vector<G4String> fParticlesTypeToKill;
+  G4bool fPassedByTheMotherVolume = false;
+  G4double fKineticEnergyAtTheEntrance = 0;
+  G4int ftrackIDAtTheEntrance = 0;
+  G4bool fIsFirstStep = true;
+  std::vector<std::string> fListOfVolumeAncestor;
+
+  long fNbOfKilledParticles{};
+};
+
+#endif

core/opengate_core/opengate_lib/pyGateKillNonInteractingParticleActor.cpp

@@ -0,0 +1,22 @@
+/* --------------------------------------------------
+   Copyright (C): OpenGATE Collaboration
+   This software is distributed under the terms
+   of the GNU Lesser General  Public Licence (LGPL)
+   See LICENSE.md for further details
+   -------------------------------------------------- */
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+#include "GateKillNonInteractingParticleActor.h"
+
+void init_GateKillNonInteractingParticleActor(py::module &m) {
+  py::class_<GateKillNonInteractingParticleActor,
+             std::unique_ptr<GateKillNonInteractingParticleActor, py::nodelete>,
+             GateVActor>(m, "GateKillNonInteractingParticleActor")
+      .def_readwrite(
+          "fListOfVolumeAncestor",
+          &GateKillNonInteractingParticleActor::fListOfVolumeAncestor)
+      .def(py::init<py::dict &>());
+}

opengate/actors/actorbuilders.py

@@ -19,6 +19,7 @@
     KillActor,
     BremSplittingActor,
     ComptSplittingActor,
+    KillNonInteractingParticleActor,
 )
 from .dynamicactors import DynamicGeometryActor
 from ..utility import make_builders
@@ -46,6 +47,7 @@
     KillActor,
     BremSplittingActor,
     ComptSplittingActor,
+    KillNonInteractingParticleActor,
     DynamicGeometryActor,
 }
 actor_builders = make_builders(actor_type_names)

opengate/actors/miscactors.py

@@ -5,6 +5,7 @@
 import numpy as np
 import time
 import platform
+from anytree import Node, RenderTree
 import opengate_core as g4
 from .base import ActorBase
 from ..exception import fatal
@@ -477,3 +478,33 @@ def set_default_user_info(user_info):
     def __init__(self, user_info):
         ActorBase.__init__(self, user_info)
         g4.GateBOptrBremSplittingActor.__init__(self, user_info.__dict__)
+
+
+class KillNonInteractingParticleActor(
+    g4.GateKillNonInteractingParticleActor, ActorBase
+):
+    type_name = "KillNonInteractingParticleActor"
+
+    def set_default_user_info(user_info):
+        ActorBase.set_default_user_info(user_info)
+        user_info.list_of_volume_name = []
+
+    def __init__(self, user_info):
+        ActorBase.__init__(self, user_info)
+        g4.GateKillNonInteractingParticleActor.__init__(self, user_info.__dict__)
+        self.list_of_volume_name = user_info.list_of_volume_name
+        self.user_info.mother = user_info.mother
+
+    def initialize(self, volume_engine=None):
+
+        super().initialize(volume_engine)
+        volume_tree = self.simulation.volume_manager.get_volume_tree()
+        dico_of_volume_tree = {}
+        for pre, _, node in RenderTree(volume_tree):
+            dico_of_volume_tree[str(node.name)] = node
+        volume_name = self.user_info.mother
+        while volume_name != "world":
+            node = dico_of_volume_tree[volume_name]
+            volume_name = node.mother
+            self.list_of_volume_name.append(volume_name)
+        self.fListOfVolumeAncestor = self.list_of_volume_name

opengate/managers.py

@@ -1034,6 +1034,9 @@ def dump_volume_types(self):
     def dump_material_database_names(self):
         return list(self.material_database.filenames)
 
+    def get_volume_tree(self):
+        return self.volume_tree_root
+
 
 def setter_hook_verbose_level(self, verbose_level):
     log.setLevel(verbose_level)