From e714f3789ac2cc0a4271d591a95a3d492e4ce89d Mon Sep 17 00:00:00 2001
From: HOCH PHILIPPE <philippe.hoch@gmail.com>
Date: Sat, 1 Mar 2025 19:57:32 +0100
Subject: [PATCH] Add composite_scheme module

---
 src/language/modules/CMakeLists.txt           |   1 +
 .../modules/CompositeSchemeModule.cpp         | 385 ++++++++++++++++++
 .../modules/CompositeSchemeModule.hpp         |  23 ++
 src/language/modules/SchemeModule.cpp         | 361 ----------------
 4 files changed, 409 insertions(+), 361 deletions(-)
 create mode 100644 src/language/modules/CompositeSchemeModule.cpp
 create mode 100644 src/language/modules/CompositeSchemeModule.hpp

diff --git a/src/language/modules/CMakeLists.txt b/src/language/modules/CMakeLists.txt
index 1ecbe1db5..96050d0bf 100644
--- a/src/language/modules/CMakeLists.txt
+++ b/src/language/modules/CMakeLists.txt
@@ -4,6 +4,7 @@ add_library(
   PugsLanguageModules
   BinaryOperatorRegisterForVh.cpp
   BuiltinModule.cpp
+  CompositeSchemeModule.cpp
   CoreModule.cpp
   DevUtilsModule.cpp
   LinearSolverModule.cpp
diff --git a/src/language/modules/CompositeSchemeModule.cpp b/src/language/modules/CompositeSchemeModule.cpp
new file mode 100644
index 000000000..8c8a7f4d5
--- /dev/null
+++ b/src/language/modules/CompositeSchemeModule.cpp
@@ -0,0 +1,385 @@
+#include <language/modules/CompositeSchemeModule.hpp>
+
+#include <language/modules/MeshModuleTypes.hpp>
+#include <language/modules/SchemeModuleTypes.hpp>
+#include <language/utils/BuiltinFunctionEmbedder.hpp>
+#include <language/utils/TypeDescriptor.hpp>
+#include <scheme/DiscreteFunctionVariant.hpp>
+#include <scheme/IBoundaryConditionDescriptor.hpp>
+
+#include <language/modules/ModuleRepository.hpp>
+
+#include <scheme/AcousticCompositeSolver.hpp>
+#include <scheme/RoeViscousFormEulerianCompositeSolver_v2.hpp>
+#include <scheme/RoeViscousFormEulerianCompositeSolver_v2_o2.hpp>
+#include <scheme/RusanovEulerianCompositeSolver.hpp>
+#include <scheme/RusanovEulerianCompositeSolver_o2.hpp>
+#include <scheme/RusanovEulerianCompositeSolver_v2.hpp>
+#include <scheme/RusanovEulerianCompositeSolver_v2_o2.hpp>
+#include <scheme/RusanovEulerianCompositeSolver_v2_order_n.hpp>
+
+CompositeSchemeModule::CompositeSchemeModule()
+{
+  this->_addBuiltinFunction("composite_glace_fluxes",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list)
+                                -> std::tuple<std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>,
+                                              std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>,
+                                              std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>> {
+                                return AcousticCompositeSolverHandler{getCommonMesh({rho, c, u, p})}
+                                  .solver()
+                                  .compute_fluxes(AcousticCompositeSolverHandler::SolverType::GlaceComposite, rho, c, u,
+                                                  p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("composite_glace_solver",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const MeshVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return AcousticCompositeSolverHandler{getCommonMesh({rho, u, E, c, p})}
+                                  .solver()
+                                  .apply(AcousticCompositeSolverHandler::SolverType::GlaceComposite, dt, rho, u, E, c,
+                                         p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver(rho, u, E, gamma, c, p,   // degree,
+                                                                      bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1_with_checks",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver(rho, u, E, gamma, c, p,   // degree,
+                                                                      bc_descriptor_list, dt, true);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1_o2",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_o2(rho, u, E, gamma, c, p,   // degree,
+                                                                         bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1_o2_with_checks",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_o2(rho, u, E, gamma, c, p,   // degree,
+                                                                         bc_descriptor_list, dt, true);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
+                                                                         bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_with_checks",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
+                                                                         bc_descriptor_list, dt, true);
+                              }));
+  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return roeViscousFormEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
+                                                                                bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2_with_checks",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return roeViscousFormEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
+                                                                                bc_descriptor_list, dt, true);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_o2",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
+                                                                            bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_order_n",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p, const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_v2_order_n(rho, u, E, gamma, c, p, degree,
+                                                                                 bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_o2_with_checks",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return rusanovEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
+                                                                            bc_descriptor_list, dt, true);
+                              }));
+
+  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2_o2",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return roeViscousFormEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
+                                                                                   bc_descriptor_list, dt);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2_o2_with_checks",
+                            std::function(
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return roeViscousFormEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
+                                                                                   bc_descriptor_list, dt, true);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("composite_eucclhyd_fluxes",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list)
+                                -> std::tuple<std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>,
+                                              std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>,
+                                              std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>> {
+                                return AcousticCompositeSolverHandler{getCommonMesh({rho, c, u, p})}
+                                  .solver()
+                                  .compute_fluxes(AcousticCompositeSolverHandler::SolverType::EucclhydComposite, rho, c,
+                                                  u, p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("composite_eucclhyd_solver",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& dt) -> std::tuple<std::shared_ptr<const MeshVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return AcousticCompositeSolverHandler{getCommonMesh({rho, u, E, c, p})}
+                                  .solver()
+                                  .apply(AcousticCompositeSolverHandler::SolverType::EucclhydComposite, dt, rho, u, E,
+                                         c, p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("apply_acoustic_composite_fluxes",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,      //
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,        //
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& E,        //
+                                 const std::shared_ptr<const ItemValueVariant>& ur,              //
+                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fjr,   //
+                                 const std::shared_ptr<const ItemValueVariant>& ue,              //
+                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fje,   //
+                                 const std::shared_ptr<const ItemValueVariant>& uf,              //
+                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fjf,   //
+                                 const double& dt) -> std::tuple<std::shared_ptr<const MeshVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return AcousticCompositeSolverHandler{getCommonMesh({rho, u, E})}   //
+                                  .solver()
+                                  .apply_fluxes(dt, rho, u, E, ur, Fjr, ue, Fje, uf, Fjf);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("compute_dt", std::function(
+
+                                            [](const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                               const std::shared_ptr<const DiscreteFunctionVariant>& c) -> double {
+                                              return toolsCompositeSolver::compute_dt(u, c);
+                                            }));
+}
+
+void
+CompositeSchemeModule::registerOperators() const
+{}
+
+void
+CompositeSchemeModule::registerCheckpointResume() const
+{}
+
+ModuleRepository::Subscribe<CompositeSchemeModule> composite_scheme_module;
diff --git a/src/language/modules/CompositeSchemeModule.hpp b/src/language/modules/CompositeSchemeModule.hpp
new file mode 100644
index 000000000..c59eb5d40
--- /dev/null
+++ b/src/language/modules/CompositeSchemeModule.hpp
@@ -0,0 +1,23 @@
+#ifndef COMPOSITE_SCHEME_MODULE_HPP
+#define COMPOSITE_SCHEME_MODULE_HPP
+
+#include <language/modules/BuiltinModule.hpp>
+
+class CompositeSchemeModule : public BuiltinModule
+{
+ public:
+  std::string_view
+  name() const final
+  {
+    return "composite_scheme";
+  }
+
+  void registerOperators() const final;
+  void registerCheckpointResume() const final;
+
+  CompositeSchemeModule();
+
+  ~CompositeSchemeModule() = default;
+};
+
+#endif   // COMPOSITE_SCHEME_MODULE_HPP
diff --git a/src/language/modules/SchemeModule.cpp b/src/language/modules/SchemeModule.cpp
index 6ffb816b4..40cc703cc 100644
--- a/src/language/modules/SchemeModule.cpp
+++ b/src/language/modules/SchemeModule.cpp
@@ -24,7 +24,6 @@
 #include <mesh/MeshRandomizer.hpp>
 #include <mesh/MeshSmoother.hpp>
 #include <mesh/MeshTraits.hpp>
-#include <scheme/AcousticCompositeSolver.hpp>
 #include <scheme/AcousticSolver.hpp>
 #include <scheme/AxisBoundaryConditionDescriptor.hpp>
 #include <scheme/DirichletBoundaryConditionDescriptor.hpp>
@@ -49,14 +48,6 @@
 #include <scheme/InflowListBoundaryConditionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/OutflowBoundaryConditionDescriptor.hpp>
-#include <scheme/RoeViscousFormEulerianCompositeSolver_v2.hpp>
-#include <scheme/RoeViscousFormEulerianCompositeSolver_v2_o2.hpp>
-#include <scheme/RusanovEulerianCompositeSolver.hpp>
-#include <scheme/RusanovEulerianCompositeSolver_o2.hpp>
-#include <scheme/RusanovEulerianCompositeSolver_v2.hpp>
-#include <scheme/RusanovEulerianCompositeSolver_v2_o2.hpp>
-#include <scheme/RusanovEulerianCompositeSolver_v2_order_n.hpp>
-
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
 #include <scheme/VariableBCDescriptor.hpp>
 #include <scheme/WallBoundaryConditionDescriptor.hpp>
@@ -469,29 +460,6 @@ SchemeModule::SchemeModule()
 
                                               ));
 
-  this->_addBuiltinFunction("composite_glace_fluxes",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list)
-                                -> std::tuple<std::shared_ptr<const ItemValueVariant>,
-                                              std::shared_ptr<const SubItemValuePerItemVariant>,
-                                              std::shared_ptr<const ItemValueVariant>,
-                                              std::shared_ptr<const SubItemValuePerItemVariant>,
-                                              std::shared_ptr<const ItemValueVariant>,
-                                              std::shared_ptr<const SubItemValuePerItemVariant>> {
-                                return AcousticCompositeSolverHandler{getCommonMesh({rho, c, u, p})}
-                                  .solver()
-                                  .compute_fluxes(AcousticCompositeSolverHandler::SolverType::GlaceComposite, rho, c, u,
-                                                  p, bc_descriptor_list);
-                              }
-
-                              ));
-
   this->_addBuiltinFunction("glace_solver",
                             std::function(
 
@@ -514,261 +482,6 @@ SchemeModule::SchemeModule()
 
                               ));
 
-  this->_addBuiltinFunction("composite_glace_solver",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const MeshVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return AcousticCompositeSolverHandler{getCommonMesh({rho, u, E, c, p})}
-                                  .solver()
-                                  .apply(AcousticCompositeSolverHandler::SolverType::GlaceComposite, dt, rho, u, E, c,
-                                         p, bc_descriptor_list);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver(rho, u, E, gamma, c, p,   // degree,
-                                                                      bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1_with_checks",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver(rho, u, E, gamma, c, p,   // degree,
-                                                                      bc_descriptor_list, dt, true);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1_o2",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_o2(rho, u, E, gamma, c, p,   // degree,
-                                                                         bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version1_o2_with_checks",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_o2(rho, u, E, gamma, c, p,   // degree,
-                                                                         bc_descriptor_list, dt, true);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
-                                                                         bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_with_checks",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
-                                                                         bc_descriptor_list, dt, true);
-                              }));
-  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return roeViscousFormEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
-                                                                                bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2_with_checks",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return roeViscousFormEulerianCompositeSolver_v2(rho, u, E, gamma, c, p,   // degree,
-                                                                                bc_descriptor_list, dt, true);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_o2",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
-                                                                            bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_order_n",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p, const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_v2_order_n(rho, u, E, gamma, c, p, degree,
-                                                                                 bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("rusanov_eulerian_composite_solver_version2_o2_with_checks",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return rusanovEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
-                                                                            bc_descriptor_list, dt, true);
-                              }));
-
-  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2_o2",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return roeViscousFormEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
-                                                                                   bc_descriptor_list, dt);
-                              }
-
-                              ));
-
-  this->_addBuiltinFunction("roe_viscosityform_eulerian_composite_solver_version2_o2_with_checks",
-                            std::function(
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E, const double& gamma,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,   // const size_t& degree,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return roeViscousFormEulerianCompositeSolver_v2_o2(rho, u, E, gamma, c, p,   // degree,
-                                                                                   bc_descriptor_list, dt, true);
-                              }
-
-                              ));
-
   this->_addBuiltinFunction("eucclhyd_fluxes",
                             std::function(
 
@@ -788,29 +501,6 @@ SchemeModule::SchemeModule()
 
                               ));
 
-  this->_addBuiltinFunction("composite_eucclhyd_fluxes",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list)
-                                -> std::tuple<std::shared_ptr<const ItemValueVariant>,
-                                              std::shared_ptr<const SubItemValuePerItemVariant>,
-                                              std::shared_ptr<const ItemValueVariant>,
-                                              std::shared_ptr<const SubItemValuePerItemVariant>,
-                                              std::shared_ptr<const ItemValueVariant>,
-                                              std::shared_ptr<const SubItemValuePerItemVariant>> {
-                                return AcousticCompositeSolverHandler{getCommonMesh({rho, c, u, p})}
-                                  .solver()
-                                  .compute_fluxes(AcousticCompositeSolverHandler::SolverType::EucclhydComposite, rho, c,
-                                                  u, p, bc_descriptor_list);
-                              }
-
-                              ));
-
   this->_addBuiltinFunction("eucclhyd_solver",
                             std::function(
 
@@ -833,28 +523,6 @@ SchemeModule::SchemeModule()
 
                               ));
 
-  this->_addBuiltinFunction("composite_eucclhyd_solver",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& c,
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
-                                   bc_descriptor_list,
-                                 const double& dt) -> std::tuple<std::shared_ptr<const MeshVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return AcousticCompositeSolverHandler{getCommonMesh({rho, u, E, c, p})}
-                                  .solver()
-                                  .apply(AcousticCompositeSolverHandler::SolverType::EucclhydComposite, dt, rho, u, E,
-                                         c, p, bc_descriptor_list);
-                              }
-
-                              ));
-
   this->_addBuiltinFunction("apply_acoustic_fluxes",
                             std::function(
 
@@ -872,28 +540,6 @@ SchemeModule::SchemeModule()
                                   .apply_fluxes(dt, rho, u, E, ur, Fjr);
                               }
 
-                              ));
-  this->_addBuiltinFunction("apply_acoustic_composite_fluxes",
-                            std::function(
-
-                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,      //
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,        //
-                                 const std::shared_ptr<const DiscreteFunctionVariant>& E,        //
-                                 const std::shared_ptr<const ItemValueVariant>& ur,              //
-                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fjr,   //
-                                 const std::shared_ptr<const ItemValueVariant>& ue,              //
-                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fje,   //
-                                 const std::shared_ptr<const ItemValueVariant>& uf,              //
-                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fjf,   //
-                                 const double& dt) -> std::tuple<std::shared_ptr<const MeshVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
-                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
-                                return AcousticCompositeSolverHandler{getCommonMesh({rho, u, E})}   //
-                                  .solver()
-                                  .apply_fluxes(dt, rho, u, E, ur, Fjr, ue, Fje, uf, Fjf);
-                              }
-
                               ));
 
   this->_addBuiltinFunction("hyperelastic_eucclhyd_fluxes",
@@ -1024,13 +670,6 @@ SchemeModule::SchemeModule()
 
                                              ));
 
-  this->_addBuiltinFunction("compute_dt", std::function(
-
-                                            [](const std::shared_ptr<const DiscreteFunctionVariant>& u,
-                                               const std::shared_ptr<const DiscreteFunctionVariant>& c) -> double {
-                                              return toolsCompositeSolver::compute_dt(u, c);
-                                            }));
-
   this->_addBuiltinFunction("cell_volume",
                             std::function(
 
-- 
GitLab