Chemistry

core/opengate_core/g4_bindings/pyG4DNAChemistryManager.cpp

@@ -0,0 +1,71 @@
+#include "G4DNAChemistryManager.hh"
+#include "G4Scheduler.hh"
+#include "G4VUserChemistryList.hh"
+#include "pybind11/pybind11.h"
+
+namespace py = pybind11;
+
+void init_G4DNAChemistryManager(py::module &m) {
+  py::class_<G4DNAChemistryManager,
+             std::unique_ptr<G4DNAChemistryManager, py::nodelete>>(
+      m, "G4DNAChemistryManager")
+      .def_static("Instance", &G4DNAChemistryManager::Instance,
+                  py::return_value_policy::reference)
+
+      .def(
+          "SetChemistryList",
+          [](G4DNAChemistryManager *self, py::object pychemlist) {
+            if (!pychemlist) {
+              throw std::runtime_error(
+                  "SetChemistryList() requires a ChemistryList object");
+            }
+            auto ptr = pychemlist.cast<G4VUserChemistryList *>();
+            if (!ptr) {
+              throw std::runtime_error("Invalid ChemistryList: null pointer");
+            }
+            self->SetChemistryList(*ptr);
+          },
+          py::arg("chemistry_list"),
+          "Register a user-defined ChemistryList with the DNA chemistry "
+          "manager")
+
+      .def(
+          "Deregister",
+          [](G4DNAChemistryManager *self, py::object pychemlist) {
+            if (!pychemlist) {
+              throw std::runtime_error(
+                  "Deregister() requires a ChemistryList object");
+            }
+            auto ptr = pychemlist.cast<G4VUserChemistryList *>();
+            if (!ptr) {
+              throw std::runtime_error("Invalid ChemistryList: null pointer");
+            }
+            self->Deregister(*ptr);
+          },
+          py::arg("chemistry_list"),
+          "Deregister a chemistry list from the DNA chemistry manager")
+
+      .def("Initialize",
+           py::overload_cast<>(&G4DNAChemistryManager::Initialize),
+           py::call_guard<py::gil_scoped_release>(),
+           "Initialize the DNA chemistry system")
+
+      .def("SetChemistryActivation",
+           &G4DNAChemistryManager::SetChemistryActivation,
+           py::arg("chemistry_active_flag"),
+           "Enable or disable Geant4-DNA chemistry")
+
+      .def_static("IsActivated", &G4DNAChemistryManager::IsActivated,
+                  "Return True if DNA chemistry is active")
+
+      .def("Run", &G4DNAChemistryManager::Run,
+           py::call_guard<py::gil_scoped_release>(),
+           "Run the chemistry stage using the underlying G4Scheduler")
+
+      // expose the underlying scheduler (read-only)
+      .def_property_readonly(
+          "scheduler",
+          [](G4DNAChemistryManager *self) { return G4Scheduler::Instance(); },
+          py::return_value_policy::reference,
+          "Return the underlying G4Scheduler instance");
+}

core/opengate_core/g4_bindings/pyG4EmParameters.cpp

@@ -14,6 +14,12 @@ namespace py = pybind11;
 #include "G4EmParameters.hh"
 
 void init_G4EmParameters(py::module &m) {
+  py::enum_<G4ChemTimeStepModel>(m, "G4ChemTimeStepModel")
+      .value("Unknown", G4ChemTimeStepModel::Unknown)
+      .value("SBS", G4ChemTimeStepModel::SBS)
+      .value("IRT", G4ChemTimeStepModel::IRT)
+      .value("IRT_syn", G4ChemTimeStepModel::IRT_syn);
+
   // (prevent to delete from py side with py::nodelete)
   py::class_<G4EmParameters, std::unique_ptr<G4EmParameters, py::nodelete>>(
       m, "G4EmParameters")
@@ -249,6 +255,9 @@ void init_G4EmParameters(py::module &m) {
       .def("SetNuclearFormfactorType",
            &G4EmParameters::SetNuclearFormfactorType)
 
+      .def("SetTimeStepModel", &G4EmParameters::SetTimeStepModel)
+      .def("GetTimeStepModel", &G4EmParameters::GetTimeStepModel)
+
       .def("SetDNAeSolvationSubType", &G4EmParameters::SetDNAeSolvationSubType)
 
       // 5d

core/opengate_core/g4_bindings/pyG4ITTrackingInteractivity.cpp

@@ -0,0 +1,41 @@
+/* --------------------------------------------------
+   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 "G4ITTrackingInteractivity.hh"
+#include "G4Step.hh"
+#include "G4Track.hh"
+
+class PyG4ITTrackingInteractivity : public G4ITTrackingInteractivity {
+public:
+  using G4ITTrackingInteractivity::G4ITTrackingInteractivity;
+
+  void StartTracking(G4Track *track) override {
+    PYBIND11_OVERLOAD(void, G4ITTrackingInteractivity, StartTracking, track);
+  }
+
+  void AppendStep(G4Track *track, G4Step *step) override {
+    PYBIND11_OVERLOAD(void, G4ITTrackingInteractivity, AppendStep, track, step);
+  }
+
+  void EndTracking(G4Track *track) override {
+    PYBIND11_OVERLOAD(void, G4ITTrackingInteractivity, EndTracking, track);
+  }
+};
+
+void init_G4ITTrackingInteractivity(py::module &m) {
+
+  py::class_<G4ITTrackingInteractivity, PyG4ITTrackingInteractivity,
+             std::unique_ptr<G4ITTrackingInteractivity, py::nodelete>>(
+      m, "G4ITTrackingInteractivity")
+      .def(py::init())
+      .def("StartTracking", &G4ITTrackingInteractivity::StartTracking)
+      .def("AppendStep", &G4ITTrackingInteractivity::AppendStep)
+      .def("EndTracking", &G4ITTrackingInteractivity::EndTracking);
+}

core/opengate_core/g4_bindings/pyG4MoleculeCounter.cpp

@@ -0,0 +1,40 @@
+#include "pybind11/pybind11.h"
+#include "pybind11/stl.h"
+
+#include "G4MoleculeCounter.hh"
+#include "G4MoleculeTable.hh"
+
+namespace py = pybind11;
+
+void init_G4MoleculeCounter(py::module &m) {
+  py::class_<G4MoleculeCounter,
+             std::unique_ptr<G4MoleculeCounter, py::nodelete>>(
+      m, "G4MoleculeCounter")
+      .def(py::init<>())
+      .def(py::init<G4String>())
+      .def("Initialize", &G4MoleculeCounter::Initialize)
+      .def("GetName", &G4MoleculeCounter::GetName)
+      .def("SetVerbose", &G4MoleculeCounter::SetVerbose)
+      .def("SetTimeComparer", &G4MoleculeCounter::SetTimeComparer)
+      .def(
+          "IgnoreMolecule",
+          [](G4MoleculeCounter *self, const std::string &name) {
+            auto *molecule =
+                G4MoleculeTable::Instance()->GetMoleculeDefinition(name, false);
+            if (molecule == nullptr) {
+              throw std::runtime_error("Unknown molecule name: " + name);
+            }
+            self->IgnoreMolecule(molecule);
+          },
+          py::arg("name"))
+      .def("RegisterAll", &G4MoleculeCounter::RegisterAll)
+      .def("SetCheckTimeConsistencyWithScheduler",
+           &G4MoleculeCounter::SetCheckTimeConsistencyWithScheduler)
+      .def("SetCheckRecordedTimeConsistency",
+           &G4MoleculeCounter::SetCheckRecordedTimeConsistency)
+      .def("SetActiveLowerBound", &G4MoleculeCounter::SetActiveLowerBound,
+           py::arg("time"), py::arg("inclusive") = true)
+      .def("SetActiveUpperBound", &G4MoleculeCounter::SetActiveUpperBound,
+           py::arg("time"), py::arg("inclusive") = true)
+      .def("GetManagedId", &G4MoleculeCounter::GetManagedId);
+}

core/opengate_core/g4_bindings/pyG4MoleculeCounterManager.cpp

@@ -0,0 +1,50 @@
+#include "pybind11/pybind11.h"
+
+#include "G4MoleculeCounter.hh"
+#include "G4MoleculeCounterManager.hh"
+#include "G4MoleculeReactionCounter.hh"
+
+namespace py = pybind11;
+
+void init_G4MoleculeCounterManager(py::module &m) {
+  py::class_<G4MoleculeCounterManager,
+             std::unique_ptr<G4MoleculeCounterManager, py::nodelete>>(
+      m, "G4MoleculeCounterManager")
+      .def_static("Instance", &G4MoleculeCounterManager::Instance,
+                  py::return_value_policy::reference)
+      .def("SetResetCountersBeforeEvent",
+           &G4MoleculeCounterManager::SetResetCountersBeforeEvent,
+           py::arg("flag") = true)
+      .def("SetResetCountersBeforeRun",
+           &G4MoleculeCounterManager::SetResetCountersBeforeRun,
+           py::arg("flag") = true)
+      .def("SetResetMasterCounterWithWorkers",
+           &G4MoleculeCounterManager::SetResetMasterCounterWithWorkers,
+           py::arg("flag") = true)
+      .def("SetAccumulateCounterIntoMaster",
+           &G4MoleculeCounterManager::SetAccumulateCounterIntoMaster,
+           py::arg("flag") = true)
+      .def("GetResetCountersBeforeEvent",
+           &G4MoleculeCounterManager::GetResetCountersBeforeEvent)
+      .def("GetResetCountersBeforeRun",
+           &G4MoleculeCounterManager::GetResetCountersBeforeRun)
+      .def("GetResetMasterCounterWithWorkers",
+           &G4MoleculeCounterManager::GetResetMasterCounterWithWorkers)
+      .def("GetAccumulateCounterIntoMaster",
+           &G4MoleculeCounterManager::GetAccumulateCounterIntoMaster)
+      .def(
+          "RegisterMoleculeCounter",
+          [](G4MoleculeCounterManager *self, G4MoleculeCounter *counter) {
+            return self->RegisterCounter(
+                std::unique_ptr<G4VMoleculeCounter>(counter));
+          },
+          py::arg("counter"))
+      .def(
+          "RegisterReactionCounter",
+          [](G4MoleculeCounterManager *self,
+             G4MoleculeReactionCounter *counter) {
+            return self->RegisterCounter(
+                std::unique_ptr<G4VMoleculeReactionCounter>(counter));
+          },
+          py::arg("counter"));
+}

core/opengate_core/g4_bindings/pyG4MoleculeCounterTimeComparer.cpp

@@ -0,0 +1,20 @@
+#include "pybind11/pybind11.h"
+
+#include "G4MoleculeCounterTimeComparer.hh"
+
+namespace py = pybind11;
+
+void init_G4MoleculeCounterTimeComparer(py::module &m) {
+  py::class_<G4MoleculeCounterTimeComparer>(m, "G4MoleculeCounterTimeComparer")
+      .def(py::init<>())
+      .def("SetFixedPrecision",
+           &G4MoleculeCounterTimeComparer::SetFixedPrecision)
+      .def_static("CreateWithFixedPrecision",
+                  &G4MoleculeCounterTimeComparer::CreateWithFixedPrecision)
+      .def_static(
+          "CreateWithVariablePrecision",
+          py::overload_cast<const std::map<G4double, G4double> &>(
+              &G4MoleculeCounterTimeComparer::CreateWithVariablePrecision))
+      .def("GetPrecisionAtTime",
+           &G4MoleculeCounterTimeComparer::GetPrecisionAtTime);
+}

core/opengate_core/g4_bindings/pyG4MoleculeReactionCounter.cpp

@@ -0,0 +1,28 @@
+#include "pybind11/pybind11.h"
+
+#include "G4MoleculeReactionCounter.hh"
+
+namespace py = pybind11;
+
+void init_G4MoleculeReactionCounter(py::module &m) {
+  py::class_<G4MoleculeReactionCounter,
+             std::unique_ptr<G4MoleculeReactionCounter, py::nodelete>>(
+      m, "G4MoleculeReactionCounter")
+      .def(py::init<>())
+      .def(py::init<G4String>())
+      .def("Initialize", &G4MoleculeReactionCounter::Initialize)
+      .def("GetName", &G4MoleculeReactionCounter::GetName)
+      .def("SetVerbose", &G4MoleculeReactionCounter::SetVerbose)
+      .def("SetTimeComparer", &G4MoleculeReactionCounter::SetTimeComparer)
+      .def("SetCheckTimeConsistencyWithScheduler",
+           &G4MoleculeReactionCounter::SetCheckTimeConsistencyWithScheduler)
+      .def("SetCheckRecordedTimeConsistency",
+           &G4MoleculeReactionCounter::SetCheckRecordedTimeConsistency)
+      .def("SetActiveLowerBound",
+           &G4MoleculeReactionCounter::SetActiveLowerBound, py::arg("time"),
+           py::arg("inclusive") = true)
+      .def("SetActiveUpperBound",
+           &G4MoleculeReactionCounter::SetActiveUpperBound, py::arg("time"),
+           py::arg("inclusive") = true)
+      .def("GetManagedId", &G4MoleculeReactionCounter::GetManagedId);
+}