Prepare scheme infrastructure for local dt stepping

src/language/modules/SchemeModule.cpp

@@ -35,6 +35,7 @@
 #include <scheme/HyperelasticSolver.hpp>
 #include <scheme/IBoundaryConditionDescriptor.hpp>
 #include <scheme/IDiscreteFunctionDescriptor.hpp>
+#include <scheme/LocalDtAcousticSolver.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
 #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
 #include <utils/Socket.hpp>
@@ -394,6 +395,50 @@ SchemeModule::SchemeModule()
 
                               ));
 
+  this->_addBuiltinFunction("local_dt_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 IMesh>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return LocalDtAcousticSolverHandler{getCommonMesh({rho, u, E, c, p})}
+                                  .solver()
+                                  .apply(LocalDtAcousticSolverHandler::SolverType::Glace, dt, rho, u, E, c, p,
+                                         bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("local_dt_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 IMesh>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return LocalDtAcousticSolverHandler{getCommonMesh({rho, u, E, c, p})}
+                                  .solver()
+                                  .apply(LocalDtAcousticSolverHandler::SolverType::Eucclhyd, dt, rho, u, E, c, p,
+                                         bc_descriptor_list);
+                              }
+
+                              ));
+
   this->_addBuiltinFunction("apply_acoustic_fluxes",
                             std::function(
 

src/scheme/CMakeLists.txt

@@ -8,4 +8,5 @@ add_library(
   DiscreteFunctionInterpoler.cpp
   DiscreteFunctionUtils.cpp
   DiscreteFunctionVectorIntegrator.cpp
-  DiscreteFunctionVectorInterpoler.cpp)
+  DiscreteFunctionVectorInterpoler.cpp
+  LocalDtAcousticSolver.cpp)

src/scheme/LocalDtAcousticSolver.hpp

+#ifndef LOCAL_DT_ACOUSTIC_SOLVER_HPP
+#define LOCAL_DT_ACOUSTIC_SOLVER_HPP
+
+#include <memory>
+#include <tuple>
+#include <vector>
+
+class DiscreteFunctionVariant;
+class IBoundaryConditionDescriptor;
+class IMesh;
+class ItemValueVariant;
+class SubItemValuePerItemVariant;
+
+class LocalDtAcousticSolverHandler
+{
+ public:
+  enum class SolverType
+  {
+    Glace,
+    Eucclhyd
+  };
+
+ private:
+  struct ILocalDtAcousticSolver
+  {
+    virtual std::tuple<const std::shared_ptr<const ItemValueVariant>,
+                       const std::shared_ptr<const SubItemValuePerItemVariant>>
+    compute_fluxes(
+      const SolverType& solver_type,
+      const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+      const std::shared_ptr<const DiscreteFunctionVariant>& c,
+      const std::shared_ptr<const DiscreteFunctionVariant>& u,
+      const std::shared_ptr<const DiscreteFunctionVariant>& p,
+      const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list) const = 0;
+
+    virtual std::tuple<std::shared_ptr<const IMesh>,
+                       std::shared_ptr<const DiscreteFunctionVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>>
+    apply_fluxes(const double& dt,
+                 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 = 0;
+
+    virtual std::tuple<std::shared_ptr<const IMesh>,
+                       std::shared_ptr<const DiscreteFunctionVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>>
+    apply(const SolverType& solver_type,
+          const double& dt,
+          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 = 0;
+
+    ILocalDtAcousticSolver()                         = default;
+    ILocalDtAcousticSolver(ILocalDtAcousticSolver&&) = default;
+    ILocalDtAcousticSolver& operator=(ILocalDtAcousticSolver&&) = default;
+
+    virtual ~ILocalDtAcousticSolver() = default;
+  };
+
+  template <size_t Dimension>
+  class LocalDtAcousticSolver;
+
+  std::unique_ptr<ILocalDtAcousticSolver> m_acoustic_solver;
+
+ public:
+  const ILocalDtAcousticSolver&
+  solver() const
+  {
+    return *m_acoustic_solver;
+  }
+
+  LocalDtAcousticSolverHandler(const std::shared_ptr<const IMesh>& mesh);
+};
+
+#endif   // LOCAL_DT_ACOUSTIC_SOLVER_HPP