Jacquet lv work

core/opengate_core/opengate_core.cpp

@@ -320,6 +320,10 @@ void init_GateKillActor(py::module &);
 
 void init_GateKillAccordingProcessesActor(py::module &);
 
+void init_GateKillNonInteractingParticleActor(py::module &);
+
+void init_GateKillAccordingParticleNameActor(py::module &);
+
 void init_GateAttenuationImageActor(py::module &);
 
 void init_itk_image(py::module &);
@@ -340,6 +344,8 @@ void init_GatePhaseSpaceActor(py::module &);
 
 void init_GateOptrComptSplittingActor(py::module &m);
 
+void init_GateLastVertexInteractionSplittingActor(py::module &m);
+
 void init_GateBOptrBremSplittingActor(py::module &m);
 
 void init_GateOptrFreeFlightActor(py::module &m);
@@ -378,6 +384,8 @@ void init_GateVolumeDepthID(py::module &m);
 // Gate source
 void init_GateVSource(py::module &);
 
+void init_GateLastVertexSource(py::module &);
+
 void init_GateSourceManager(py::module &);
 
 void init_GateGenericSource(py::module &);
@@ -569,6 +577,7 @@ PYBIND11_MODULE(opengate_core, m) {
   init_GateImageNestedParameterisation(m);
   init_GateRepeatParameterisation(m);
   init_GateVSource(m);
+  init_GateLastVertexSource(m);
   init_GateSourceManager(m);
   init_GateGenericSource(m);
   init_GateTreatmentPlanPBSource(m);
@@ -592,6 +601,7 @@ PYBIND11_MODULE(opengate_core, m) {
   init_GatePhaseSpaceActor(m);
   init_GateBOptrBremSplittingActor(m);
   init_GateOptrComptSplittingActor(m);
+  init_GateLastVertexInteractionSplittingActor(m);
   init_GateOptrFreeFlightActor(m);
   init_GateHitsCollectionActor(m);
   init_GateVDigitizerWithOutputActor(m);
@@ -606,6 +616,8 @@ PYBIND11_MODULE(opengate_core, m) {
   init_GateARFTrainingDatasetActor(m);
   init_GateKillActor(m);
   init_GateKillAccordingProcessesActor(m);
+  init_GateKillNonInteractingParticleActor(m);
+  init_GateKillAccordingParticleNameActor(m);
   init_GateAttenuationImageActor(m);
   init_GateDigiAttributeManager(m);
   init_GateVDigiAttribute(m);

core/opengate_core/opengate_lib/GateGenericSource.cpp

@@ -145,7 +145,6 @@ double GateGenericSource::PrepareNextTime(double current_simulation_time) {
       return fStartTime;
     if (ll.fEffectiveEventTime >= fEndTime)
       return -1;
-
     // get next time according to current fActivity
     double next_time = CalcNextTime(ll.fEffectiveEventTime);
     if (next_time >= fEndTime)

core/opengate_core/opengate_lib/GateKillAccordingParticleNameActor.cpp

@@ -0,0 +1,57 @@
+/* --------------------------------------------------
+   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 "GateKillAccordingParticleNameActor.h"
+#include "G4LogicalVolumeStore.hh"
+#include "G4PhysicalVolumeStore.hh"
+#include "G4TransportationManager.hh"
+#include "G4ios.hh"
+#include "GateHelpers.h"
+#include "GateHelpersDict.h"
+
+G4Mutex SetNbKillAcordingParticleMutex = G4MUTEX_INITIALIZER;
+
+GateKillAccordingParticleNameActor::GateKillAccordingParticleNameActor(
+    py::dict &user_info)
+    : GateVActor(user_info, false) {}
+
+void GateKillAccordingParticleNameActor::InitializeUserInfo(
+    py::dict &user_info) {
+  GateVActor::InitializeUserInfo(user_info);
+  fParticlesNameToKill = DictGetVecStr(user_info, "particles_name_to_kill");
+}
+
+void GateKillAccordingParticleNameActor::PreUserTrackingAction(
+    const G4Track *track) {
+  auto &l = fThreadLocalData.Get();
+  l.fIsAParticleToKill = false;
+
+  G4String particleName = track->GetParticleDefinition()->GetParticleName();
+  if (std::find(fParticlesNameToKill.begin(), fParticlesNameToKill.end(),
+                particleName) != fParticlesNameToKill.end()) {
+    l.fIsAParticleToKill = true;
+  }
+}
+
+void GateKillAccordingParticleNameActor::SteppingAction(G4Step *step) {
+
+  if (step->GetPostStepPoint()->GetStepStatus() == 1) {
+    G4String logicalVolumeNamePostStep = step->GetPostStepPoint()
+                                             ->GetPhysicalVolume()
+                                             ->GetLogicalVolume()
+                                             ->GetName();
+    if (std::find(fListOfVolumeAncestor.begin(), fListOfVolumeAncestor.end(),
+                  logicalVolumeNamePostStep) != fListOfVolumeAncestor.end()) {
+      auto &l = fThreadLocalData.Get();
+      if (l.fIsAParticleToKill) {
+        step->GetTrack()->SetTrackStatus(fStopAndKill);
+        G4AutoLock mutex(&SetNbKillAcordingParticleMutex);
+        fNbOfKilledParticles++;
+      }
+    }
+  }
+}

core/opengate_core/opengate_lib/GateKillAccordingParticleNameActor.h

@@ -0,0 +1,40 @@
+/* --------------------------------------------------
+   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 GateKillAccordingParticleNameActor_h
+#define GateKillAccordingParticleNameActor_h
+
+#include "G4Cache.hh"
+#include "GateVActor.h"
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+class GateKillAccordingParticleNameActor : public GateVActor {
+
+public:
+  // Constructor
+  GateKillAccordingParticleNameActor(py::dict &user_info);
+  struct threadLocalT {
+    G4bool fIsAParticleToKill = false;
+  };
+  G4Cache<threadLocalT> fThreadLocalData;
+  std::vector<std::string> fParticlesNameToKill;
+  std::vector<G4String> fListOfVolumeAncestor;
+
+  // Main function called every step in attached volume
+  void PreUserTrackingAction(const G4Track *) override;
+  void SteppingAction(G4Step *) override;
+  void InitializeUserInfo(py::dict &user_info) override;
+
+  inline long GetNumberOfKilledParticles() { return fNbOfKilledParticles; }
+
+private:
+  long fNbOfKilledParticles = 0;
+};
+
+#endif

core/opengate_core/opengate_lib/GateKillNonInteractingParticleActor.cpp

@@ -0,0 +1,81 @@
+/* --------------------------------------------------
+   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 "G4TransportationManager.hh"
+#include "G4ios.hh"
+#include "GateHelpers.h"
+#include "GateHelpersDict.h"
+
+GateKillNonInteractingParticleActor::GateKillNonInteractingParticleActor(
+    py::dict &user_info)
+    : GateVActor(user_info, false) {}
+
+void GateKillNonInteractingParticleActor::StartSimulationAction() {
+  fNbOfKilledParticles = 0;
+}
+
+void GateKillNonInteractingParticleActor::PreUserTrackingAction(
+    const G4Track *track) {
+  fIsFirstStep = true;
+  fKineticEnergyAtTheEntrance = 0;
+  ftrackIDAtTheEntrance = 0;
+  fPassedByTheMotherVolume = false;
+}
+
+void GateKillNonInteractingParticleActor::SteppingAction(G4Step *step) {
+  G4Navigator *navigator = G4TransportationManager::GetTransportationManager()
+                               ->GetNavigatorForTracking();
+
+  G4String logNameMotherVolume = G4LogicalVolumeStore::GetInstance()
+                                     ->GetVolume(fAttachedToVolumeName)
+                                     ->GetName();
+  G4String physicalVolumeNamePreStep = "None";
+  if (step->GetPreStepPoint()->GetPhysicalVolume() != 0)
+    physicalVolumeNamePreStep =
+        step->GetPreStepPoint()->GetPhysicalVolume()->GetName();
+  // if (((step->GetTrack()->GetLogicalVolumeAtVertex()->GetName() !=
+  // logNameMotherVolume) && (fIsFirstStep)) || ((fIsFirstStep) &&
+  // (step->GetTrack()->GetParentID() == 0))) {
+  if ((step->GetTrack()->GetLogicalVolumeAtVertex()->GetName() !=
+       logNameMotherVolume) &&
+      (fIsFirstStep)) {
+    // if ((fPassedByTheMotherVolume == false) &&
+    // (((step->GetPreStepPoint()->GetStepStatus() == 1) &&
+    // (physicalVolumeNamePreStep == fAttachedToVolumeName)) || ((fIsFirstStep)
+    // && (step->GetTrack()->GetParentID() == 0)))) {
+    if ((fPassedByTheMotherVolume == false) &&
+        (((step->GetPreStepPoint()->GetStepStatus() == 1) &&
+          (physicalVolumeNamePreStep == fAttachedToVolumeName)))) {
+      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,40 @@
+/* --------------------------------------------------
+   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 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