Add Kidder test

src/language/modules/VariationalSchemeModule.cpp

@@ -10,6 +10,7 @@
 #include <scheme/P1P0VariationalSolver.hpp>
 #include <scheme/VariationalSolver.hpp>
 #include <scheme/VariationalSolverDevelopedReconstruction.hpp>
+#include <scheme/VariationalSolverKidder.hpp>
 #include <scheme/VariationalSolverO1.hpp>
 #include <scheme/WallBoundaryConditionDescriptor.hpp>
 
@@ -39,6 +40,29 @@ VariationalSchemeModule::VariationalSchemeModule()
 
                               ));
 
+  this->_addBuiltinFunction("variational_solver_kidder",
+                            std::function(
+
+                              [](const size_t& degree, 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>& a,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list,
+                                 const double& tau, const double& omega, const double& dt,
+                                 const double& t) -> std::tuple<std::shared_ptr<const MeshVariant>,
+                                                                std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return VariationalSolverKidderHandler{getCommonMesh({rho, u, E, c, a})}
+                                  .solver()
+                                  .apply(degree, dt, VariationalSolverKidderHandler::VelocityBCTreatment::elimination,
+                                         rho, u, E, c, a, bc_descriptor_list, tau, omega, t);
+                              }
+
+                              ));
+
   this->_addBuiltinFunction("variational_solver_with_source",
                             std::function(
 

src/scheme/CMakeLists.txt

@@ -19,6 +19,7 @@ add_library(
   PolynomialReconstruction.cpp
   VariationalSolver.cpp
   VariationalSolverDevelopedReconstruction.cpp
+  VariationalSolverKidder.cpp
   VariationalSolverO1.cpp
 )
 

src/scheme/VariationalSolverKidder.hpp

+#ifndef VARIATIONAL_SOLVER_KIDDER_HPP
+#define VARIATIONAL_SOLVER_KIDDER_HPP
+
+#include <mesh/MeshTraits.hpp>
+
+#include <memory>
+#include <tuple>
+#include <vector>
+
+class DiscreteFunctionVariant;
+class IBoundaryConditionDescriptor;
+class MeshVariant;
+class ItemValueVariant;
+class SubItemValuePerItemVariant;
+
+class VariationalSolverKidderHandler
+{
+ public:
+  enum class VelocityBCTreatment
+  {
+    penalty,
+    elimination
+  };
+
+ private:
+  struct IVariationalSolverKidder
+  {
+    virtual std::tuple<std::shared_ptr<const MeshVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>,
+                       std::shared_ptr<const DiscreteFunctionVariant>>
+    apply(const size_t& order,
+          const double& dt,
+          const VelocityBCTreatment& velocity_bc_treatment,
+          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>& a,
+          const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list,
+          const double& tau,
+          const double& omega,
+          const double& t) const = 0;
+
+    IVariationalSolverKidder()                                      = default;
+    IVariationalSolverKidder(IVariationalSolverKidder&&)            = default;
+    IVariationalSolverKidder& operator=(IVariationalSolverKidder&&) = default;
+
+    virtual ~IVariationalSolverKidder() = default;
+  };
+
+  template <MeshConcept MeshTypeT, size_t mesh_edges_degree>
+  class VariationalSolverKidder;
+
+  std::unique_ptr<IVariationalSolverKidder> m_acoustic_solver;
+
+ public:
+  const IVariationalSolverKidder&
+  solver() const
+  {
+    return *m_acoustic_solver;
+  }
+
+  VariationalSolverKidderHandler(const std::shared_ptr<const MeshVariant>& mesh);
+};
+
+#endif   // VARIATIONAL_SOLVER_KIDDER_HPP