add link to language

src/language/modules/SchemeModule.cpp

@@ -35,6 +35,7 @@
 #include <scheme/FourierBoundaryConditionDescriptor.hpp>
 #include <scheme/FreeBoundaryConditionDescriptor.hpp>
 #include <scheme/HyperelasticSolver.hpp>
+#include <scheme/HypoelasticSolver.hpp>
 #include <scheme/IBoundaryConditionDescriptor.hpp>
 #include <scheme/IDiscreteFunctionDescriptor.hpp>
 #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
@@ -578,6 +579,120 @@ SchemeModule::SchemeModule()
 
                               ));
 
+  this->_addBuiltinFunction("hypoelastic_eucclhyd_fluxes",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aL,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aT,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+                                 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>> {
+                                return HypoelasticSolverHandler{getCommonMesh({rho, aL, aT, u, sigma, p})}
+                                  .solver()
+                                  .compute_fluxes(HypoelasticSolverHandler::SolverType::Eucclhyd, rho, aL, aT, u, sigma,
+                                                  p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("hypoelastic_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>& CG,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aL,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aT,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+                                 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>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return HypoelasticSolverHandler{getCommonMesh({rho, u, E, CG, aL, aT, sigma, p})}
+                                  .solver()
+                                  .apply(HypoelasticSolverHandler::SolverType::Eucclhyd, dt, rho, u, E, CG, aL, aT,
+                                         sigma, p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("hypoelastic_glace_fluxes",
+                            std::function(
+
+                              [](const std::shared_ptr<const DiscreteFunctionVariant>& rho,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aL,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aT,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& u,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list)
+                                -> std::tuple<std::shared_ptr<const ItemValueVariant>,
+                                              std::shared_ptr<const SubItemValuePerItemVariant>> {
+                                return HypoelasticSolverHandler{getCommonMesh({rho, aL, aT, u, sigma})}
+                                  .solver()
+                                  .compute_fluxes(HypoelasticSolverHandler::SolverType::Glace,   //
+                                                  rho, aL, aT, u, sigma, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("hypoelastic_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>& CG,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aL,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& aT,
+                                 const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+                                 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>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return HypoelasticSolverHandler{getCommonMesh({rho, u, E, CG, aL, aT, sigma})}
+                                  .solver()
+                                  .apply(HypoelasticSolverHandler::SolverType::Glace, dt, rho, u, E, CG, aL, aT, sigma,
+                                         p, bc_descriptor_list);
+                              }
+
+                              ));
+
+  this->_addBuiltinFunction("apply_hypoelastic_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 DiscreteFunctionVariant>& CG,       //
+                                 const std::shared_ptr<const ItemValueVariant>& ur,              //
+                                 const std::shared_ptr<const SubItemValuePerItemVariant>& Fjr,   //
+                                 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>,
+                                                                 std::shared_ptr<const DiscreteFunctionVariant>> {
+                                return HypoelasticSolverHandler{getCommonMesh({rho, u, E, CG})}   //
+                                  .solver()
+                                  .apply_fluxes(dt, rho, u, E, CG, ur, Fjr);
+                              }
+
+                              ));
+
   this->_addBuiltinFunction("lagrangian",
                             std::function(
 
@@ -643,6 +758,14 @@ SchemeModule::SchemeModule()
                                                  }
 
                                                  ));
+  this->_addBuiltinFunction("hypoelastic_dt", std::function(
+
+                                                [](const std::shared_ptr<const DiscreteFunctionVariant>& c) -> double {
+                                                  return hypoelastic_dt(c);
+                                                }
+
+                                                ));
+
   this->_addBuiltinFunction("fluxing_advection",
                             std::function(
 

src/scheme/CMakeLists.txt

@@ -4,6 +4,7 @@ add_library(
   PugsScheme
   AcousticSolver.cpp
   HyperelasticSolver.cpp
+  HypoelasticSolver.cpp
   DiscreteFunctionIntegrator.cpp
   DiscreteFunctionInterpoler.cpp
   DiscreteFunctionUtils.cpp

src/scheme/HypoelasticSolver.cpp

-#include <scheme/HyperelasticSolver.hpp>
+#include <scheme/HypoelasticSolver.hpp>
 
 #include <language/utils/InterpolateItemValue.hpp>
 #include <mesh/ItemValueUtils.hpp>
@@ -400,6 +400,7 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
                  const std::shared_ptr<const DiscreteFunctionVariant>& aT_v,
                  const std::shared_ptr<const DiscreteFunctionVariant>& u_v,
                  const std::shared_ptr<const DiscreteFunctionVariant>& sigma_v,
+                 const std::shared_ptr<const DiscreteFunctionVariant>& p_v,
                  const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list) const
   {
     std::shared_ptr i_mesh = getCommonMesh({rho_v, aL_v, aT_v, u_v, sigma_v});
@@ -446,7 +447,8 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
                const DiscreteScalarFunction& rho,
                const DiscreteVectorFunction& u,
                const DiscreteScalarFunction& E,
-               const DiscreteTensorFunction& CG,
+               const DiscreteTensorFunction& sigma,
+               const DiscreteScalarFunction& p,
                const NodeValue<const Rd>& ur,
                const NodeValuePerCell<const Rd>& Fjr) const
   {
@@ -469,7 +471,7 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
     CellValue<double> new_rho = copy(rho.cellValues());
     CellValue<Rd> new_u       = copy(u.cellValues());
     CellValue<double> new_E   = copy(E.cellValues());
-    CellValue<Rdxd> new_CG    = copy(CG.cellValues());
+    CellValue<Rdxd> new_sigma = copy(sigma.cellValues());
 
     parallel_for(
       mesh.numberOfCells(), PUGS_LAMBDA(CellId j) {
@@ -484,14 +486,15 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
           momentum_fluxes += Fjr(j, R);
           energy_fluxes += dot(Fjr(j, R), ur[r]);
         }
-        const Rdxd cauchy_green_fluxes = gradv * CG[j] + CG[j] * transpose(gradv);
+        // TODO
+        // const Rdxd cauchy_green_fluxes = gradv * CG[j] + CG[j] * transpose(gradv);
         const double dt_over_Mj = dt / (rho[j] * Vj[j]);
         const double dt_over_Vj = dt / Vj[j];
         new_u[j] += dt_over_Mj * momentum_fluxes;
         new_E[j] += dt_over_Mj * energy_fluxes;
-        new_CG[j] += dt_over_Vj * cauchy_green_fluxes;
-        new_CG[j] += transpose(new_CG[j]);
-        new_CG[j] *= 0.5;
+        // new_CG[j] += dt_over_Vj * cauchy_green_fluxes;
+        // new_CG[j] += transpose(new_CG[j]);
+        // new_CG[j] *= 0.5;
       });
 
     CellValue<const double> new_Vj = MeshDataManager::instance().getMeshData(*new_mesh).Vj();
@@ -502,7 +505,7 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
     return {new_mesh, std::make_shared<DiscreteFunctionVariant>(DiscreteScalarFunction(new_mesh, new_rho)),
             std::make_shared<DiscreteFunctionVariant>(DiscreteVectorFunction(new_mesh, new_u)),
             std::make_shared<DiscreteFunctionVariant>(DiscreteScalarFunction(new_mesh, new_E)),
-            std::make_shared<DiscreteFunctionVariant>(DiscreteTensorFunction(new_mesh, new_CG))};
+            std::make_shared<DiscreteFunctionVariant>(DiscreteTensorFunction(new_mesh, new_sigma))};
   }
 
   std::tuple<std::shared_ptr<const IMesh>,
@@ -514,7 +517,8 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
                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>& CG,
+               const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+               const std::shared_ptr<const DiscreteFunctionVariant>& p,
                const std::shared_ptr<const ItemValueVariant>& ur,
                const std::shared_ptr<const SubItemValuePerItemVariant>& Fjr) const
   {
@@ -532,7 +536,8 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
                               rho->get<DiscreteScalarFunction>(),       //
                               u->get<DiscreteVectorFunction>(),         //
                               E->get<DiscreteScalarFunction>(),         //
-                              CG->get<DiscreteTensorFunction>(),        //
+                              sigma->get<DiscreteTensorFunction>(),     //
+                              p->get<DiscreteScalarFunction>(),         //
                               ur->get<NodeValue<const Rd>>(),           //
                               Fjr->get<NodeValuePerCell<const Rd>>());
   }
@@ -547,14 +552,14 @@ class HypoelasticSolverHandler::HypoelasticSolver final : public HypoelasticSolv
         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>& CG,
+        const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
         const std::shared_ptr<const DiscreteFunctionVariant>& aL,
         const std::shared_ptr<const DiscreteFunctionVariant>& aT,
-        const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+        const std::shared_ptr<const DiscreteFunctionVariant>& p,
         const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list) const
   {
-    auto [ur, Fjr] = compute_fluxes(solver_type, rho, aL, aT, u, sigma, bc_descriptor_list);
-    return apply_fluxes(dt, rho, u, E, CG, ur, Fjr);
+    auto [ur, Fjr] = compute_fluxes(solver_type, rho, aL, aT, u, sigma, p, bc_descriptor_list);
+    return apply_fluxes(dt, rho, u, E, sigma, p, ur, Fjr);
   }
 
   HypoelasticSolver()                    = default;

src/scheme/HypoelasticSolver.hpp

@@ -34,6 +34,7 @@ class HypoelasticSolverHandler
       const std::shared_ptr<const DiscreteFunctionVariant>& aT,
       const std::shared_ptr<const DiscreteFunctionVariant>& u,
       const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+      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>,
@@ -45,7 +46,8 @@ class HypoelasticSolverHandler
                  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>& CG,
+                 const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
+                 const std::shared_ptr<const DiscreteFunctionVariant>& p,
                  const std::shared_ptr<const ItemValueVariant>& ur,
                  const std::shared_ptr<const SubItemValuePerItemVariant>& Fjr) const = 0;
 
@@ -59,7 +61,7 @@ class HypoelasticSolverHandler
           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>& CG,
+          const std::shared_ptr<const DiscreteFunctionVariant>& sigma,
           const std::shared_ptr<const DiscreteFunctionVariant>& aL,
           const std::shared_ptr<const DiscreteFunctionVariant>& aT,
           const std::shared_ptr<const DiscreteFunctionVariant>& p,