diff --git a/src/language/modules/LocalFSIModule.cpp b/src/language/modules/LocalFSIModule.cpp index 9915d4e8d9417bd5948c41cc1b32fddc154a97e4..0df2b95344a231490914a62adea82a55eb7dba32 100644 --- a/src/language/modules/LocalFSIModule.cpp +++ b/src/language/modules/LocalFSIModule.cpp @@ -410,9 +410,15 @@ LocalFSIModule::LocalFSIModule() const std::shared_ptr<const DiscreteFunctionVariant>& p2, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list2, - const double& lambda1, const double& mu1, - const double& lambda2, const double& mu2, - const double& gamma1, const double& gamma2 , const double& dt1) + const std::shared_ptr<const DiscreteFunctionVariant>& lambda1, + const std::shared_ptr<const DiscreteFunctionVariant>& mu1, + const std::shared_ptr<const DiscreteFunctionVariant>& lambda2, + const std::shared_ptr<const DiscreteFunctionVariant>& mu2, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma1, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf1, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma2, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf2, + const double& dt1) -> std::tuple< std::shared_ptr<const MeshVariant>, std::shared_ptr<const DiscreteFunctionVariant>, std::shared_ptr<const DiscreteFunctionVariant>, @@ -429,7 +435,7 @@ LocalFSIModule::LocalFSIModule() .solver() .apply(Order2LocalDtHyperelasticSolverHandler::SolverType::Eucclhyd, 1, dt1, rho1, rho2, u1, u2, E1, E2, CG1, CG2, aL1, aL2, aT1, aT2, sigma1, sigma2, p1, p2, bc_descriptor_list1, - bc_descriptor_list2, lambda1, mu1, lambda2, mu2, gamma1, 0, gamma2, 0); + bc_descriptor_list2, lambda1, mu1, lambda2, mu2, gamma1, p_inf1, gamma2, p_inf2); } )); @@ -457,10 +463,15 @@ LocalFSIModule::LocalFSIModule() const std::shared_ptr<const DiscreteFunctionVariant>& p2, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list2, - const double& lambda1, const double& mu1, - const double& lambda2, const double& mu2, - const double& gamma1, const double& p_inf1, - const double& gamma2, const double& p_inf2, const double& dt1) + const std::shared_ptr<const DiscreteFunctionVariant>& lambda1, + const std::shared_ptr<const DiscreteFunctionVariant>& mu1, + const std::shared_ptr<const DiscreteFunctionVariant>& lambda2, + const std::shared_ptr<const DiscreteFunctionVariant>& mu2, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma1, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf1, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma2, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf2, + const double& dt1) -> std::tuple< std::shared_ptr<const MeshVariant>, std::shared_ptr<const DiscreteFunctionVariant>, std::shared_ptr<const DiscreteFunctionVariant>, diff --git a/src/scheme/LocalDtUtils.hpp b/src/scheme/LocalDtUtils.hpp index cfd8ab7ff3264e1d1e888d5e1fe870583b3e4d7d..fc59315ac326ac7d65a7bf7d6d931252de465447 100644 --- a/src/scheme/LocalDtUtils.hpp +++ b/src/scheme/LocalDtUtils.hpp @@ -67,7 +67,7 @@ std::tuple<const std::shared_ptr<const DiscreteFunctionVariant>, aT_d = sqrt(mu_d / rho_d); } else if (law == 2){ p_d = (gamma_d - 1) * rho_d * eps_d - gamma_d * p_inf_d; - sigma_d = mu_d / sqrt(det(CG_d)) * (CG_d - 1. / 3. * trace(CG_d) * I) - p_d * I; + sigma_d = 2*mu_d / sqrt(det(CG_d)) * (CG_d - 1. / 3. * trace(CG_d) * I) - p_d * I; aL_d = sqrt((2 * mu_d) / rho_d + (gamma_d * (p_d + p_inf_d)) / rho_d); aT_d = sqrt(mu_d / rho_d); } else { @@ -97,8 +97,8 @@ std::tuple<const std::shared_ptr<const DiscreteFunctionVariant>, std::vector<NodeId>& map1, std::vector<NodeId>& map2) { - const MeshType mesh1 = *i_mesh1->get<MeshType>(); - const MeshType mesh2 = *i_mesh2->get<MeshType>(); + const MeshType& mesh1 = *i_mesh1->get<MeshType>(); + const MeshType& mesh2 = *i_mesh2->get<MeshType>(); NodeValue<TinyVector<MeshType::Dimension>> xr1 = copy(mesh1.xr()); NodeValue<TinyVector<MeshType::Dimension>> new_xr2 = copy(mesh2.xr()); @@ -112,13 +112,14 @@ std::tuple<const std::shared_ptr<const DiscreteFunctionVariant>, } std::shared_ptr<const MeshType> new_mesh2 = std::make_shared<MeshType>(mesh2.shared_connectivity(), new_xr2); + const std::shared_ptr<const MeshVariant>& mesh_copy = std::make_shared<MeshVariant>(new_mesh2); - const std::shared_ptr<const DiscreteFunctionVariant>& new_rho = shallowCopy(new_mesh2, rho); - const std::shared_ptr<const DiscreteFunctionVariant>& new_u = shallowCopy(new_mesh2, u); - const std::shared_ptr<const DiscreteFunctionVariant>& new_E = shallowCopy(new_mesh2, E); - const std::shared_ptr<const DiscreteFunctionVariant>& new_CG = shallowCopy(new_mesh2, CG); + const std::shared_ptr<const DiscreteFunctionVariant>& new_rho = shallowCopy(mesh_copy, rho); + const std::shared_ptr<const DiscreteFunctionVariant>& new_u = shallowCopy(mesh_copy, u); + const std::shared_ptr<const DiscreteFunctionVariant>& new_E = shallowCopy(mesh_copy, E); + const std::shared_ptr<const DiscreteFunctionVariant>& new_CG = shallowCopy(mesh_copy, CG); - return std::make_tuple(new_mesh2,new_rho,new_u,new_E,new_CG); + return std::make_tuple(mesh_copy,new_rho,new_u,new_E,new_CG); } #endif //LOCAL_DT_UTILS_HPP \ No newline at end of file diff --git a/src/scheme/Order2LocalDtHyperelasticSolver.cpp b/src/scheme/Order2LocalDtHyperelasticSolver.cpp index 0dfe808d2171ee0bc61cff2b929f8167fafb664b..2def47e16c7ba64386df3566558da343cfef6353 100644 --- a/src/scheme/Order2LocalDtHyperelasticSolver.cpp +++ b/src/scheme/Order2LocalDtHyperelasticSolver.cpp @@ -24,6 +24,8 @@ #include <scheme/HyperelasticSolver.hpp> #include <scheme/IBoundaryConditionDescriptor.hpp> #include <scheme/IDiscreteFunctionDescriptor.hpp> +#include <scheme/LocalDtUtils.hpp> +#include <scheme/Order2Limiters.hpp> #include <scheme/PolynomialReconstruction.hpp> #include <scheme/PolynomialReconstructionDescriptor.hpp> #include <scheme/SymmetryBoundaryConditionDescriptor.hpp> @@ -1799,64 +1801,6 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi Fjr_o1->get<NodeValuePerCell<const Rd>>()); } - std::tuple<std::shared_ptr<const MeshVariant>, - std::shared_ptr<const DiscreteFunctionVariant>, - std::shared_ptr<const DiscreteFunctionVariant>, - std::shared_ptr<const DiscreteFunctionVariant>, - std::shared_ptr<const DiscreteFunctionVariant>> - mesh_correction(const MeshType& mesh1, - const MeshType& mesh2, - const DiscreteScalarFunction& rho, - const DiscreteVectorFunction& u, - const DiscreteScalarFunction& E, - const DiscreteTensorFunction& CG, - std::vector<NodeId>& map1, - std::vector<NodeId>& map2) const - { - NodeValue<Rd> xr1 = copy(mesh1.xr()); - NodeValue<Rd> new_xr2 = copy(mesh2.xr()); - - size_t n = map1.size(); - - for (size_t i = 0; i < n; i++) { - for (size_t j = 0; j < Dimension; j++) { - new_xr2[map2[i]][j] = xr1[map1[i]][j]; - } - } - - std::shared_ptr<const MeshType> new_mesh2 = std::make_shared<MeshType>(mesh2.shared_connectivity(), new_xr2); - - 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()); - - return {std::make_shared<MeshVariant>(new_mesh2), - std::make_shared<DiscreteFunctionVariant>(DiscreteScalarFunction(new_mesh2, new_rho)), - std::make_shared<DiscreteFunctionVariant>(DiscreteVectorFunction(new_mesh2, new_u)), - std::make_shared<DiscreteFunctionVariant>(DiscreteScalarFunction(new_mesh2, new_E)), - std::make_shared<DiscreteFunctionVariant>(DiscreteTensorFunction(new_mesh2, new_CG))}; - } - - std::tuple<std::shared_ptr<const MeshVariant>, - std::shared_ptr<const DiscreteFunctionVariant>, - std::shared_ptr<const DiscreteFunctionVariant>, - std::shared_ptr<const DiscreteFunctionVariant>, - std::shared_ptr<const DiscreteFunctionVariant>> - mesh_correction(const std::shared_ptr<const MeshVariant>& i_mesh1, - const std::shared_ptr<const MeshVariant>& i_mesh2, - 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, - std::vector<NodeId>& map1, - std::vector<NodeId>& map2) const - { - return this->mesh_correction(*i_mesh1->get<MeshType>(), *i_mesh2->get<MeshType>(), - rho->get<DiscreteScalarFunction>(), u->get<DiscreteVectorFunction>(), - E->get<DiscreteScalarFunction>(), CG->get<DiscreteTensorFunction>(), map1, map2); - } - std::tuple<std::shared_ptr<const MeshVariant>, std::shared_ptr<const DiscreteFunctionVariant>, std::shared_ptr<const DiscreteFunctionVariant>, @@ -1874,21 +1818,25 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi NodeValue<Rd> CR_ur, NodeValuePerCell<Rd> CR_Fjr, std::vector<NodeId> map2, - const size_t& chi_solid, - const double& lambda, - const double& mu, - const double& gamma, - const double& p_inf) const + const std::shared_ptr<const DiscreteFunctionVariant>& lambda, + const std::shared_ptr<const DiscreteFunctionVariant>& mu, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf) const { - std::shared_ptr sub_m = getCommonMesh({rho, u}); + std::shared_ptr sub_m = getCommonMesh({rho, u, E, CG}); std::shared_ptr<const DiscreteFunctionVariant> sub_rho = rho; std::shared_ptr<const DiscreteFunctionVariant> sub_u = u; std::shared_ptr<const DiscreteFunctionVariant> sub_E = E; std::shared_ptr<const DiscreteFunctionVariant> sub_CG = CG; + std::shared_ptr<const DiscreteFunctionVariant> sub_lambda = lambda; + std::shared_ptr<const DiscreteFunctionVariant> sub_mu = mu; + std::shared_ptr<const DiscreteFunctionVariant> sub_gamma = gamma; + std::shared_ptr<const DiscreteFunctionVariant> sub_p_inf = p_inf; + double sum_dt = 0; while(sum_dt < dt){ - const auto& [sigma, aL, aT, p] = _apply_state_law(law,sub_rho,sub_u,sub_E,sub_CG,chi_solid,lambda,mu,gamma,p_inf); + const auto& [sigma, p, aL, aT] = apply_state_law<MeshType>(law,sub_rho,sub_u,sub_E,sub_CG,sub_lambda,sub_mu,sub_gamma,sub_p_inf); const DiscreteScalarFunction& aL_d = aL->template get<DiscreteScalarFunction>(); const DiscreteScalarFunction& aT_d = aT->template get<DiscreteScalarFunction>(); @@ -1905,6 +1853,11 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi std::tie(sub_m, sub_rho, sub_u, sub_E, sub_CG) = apply_fluxes(sub_dt, sub_rho, sub_u, sub_E, sub_CG, sub_ur2, sub_ur2_o1, sub_Fjr2, sub_Fjr2_o1); + sub_lambda = shallowCopy(sub_m,sub_lambda); + sub_mu = shallowCopy(sub_m,sub_mu); + sub_gamma = shallowCopy(sub_m,sub_gamma); + sub_p_inf = shallowCopy(sub_m,sub_p_inf); + sum_dt += sub_dt; } @@ -1928,11 +1881,10 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi NodeValue<Rd> CR_ur, NodeValuePerCell<Rd> CR_Fjr, std::vector<NodeId> map2, - const size_t& chi_solid, - const double& lambda, - const double& mu, - const double& gamma, - const double& p_inf) const + const std::shared_ptr<const DiscreteFunctionVariant>& lambda, + const std::shared_ptr<const DiscreteFunctionVariant>& mu, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf) const { std::shared_ptr sub_m = getCommonMesh({rho, u}); std::shared_ptr<const DiscreteFunctionVariant> sub_rho = rho; @@ -1942,7 +1894,11 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi double sum_dt = 0; while(sum_dt < dt){ - const auto& [sigma, aL, aT, p] = _apply_state_law(law,sub_rho,sub_u,sub_E,sub_CG,chi_solid,lambda,mu,gamma,p_inf); + const std::shared_ptr<const DiscreteFunctionVariant> sub_lambda = shallowCopy(sub_m,lambda); + const std::shared_ptr<const DiscreteFunctionVariant> sub_mu = shallowCopy(sub_m,mu); + const std::shared_ptr<const DiscreteFunctionVariant> sub_gamma = shallowCopy(sub_m,gamma); + const std::shared_ptr<const DiscreteFunctionVariant> sub_p_inf = shallowCopy(sub_m,p_inf); + const auto& [sigma, p, aL, aT] = apply_state_law<MeshType>(law,sub_rho,sub_u,sub_E,sub_CG,sub_lambda,sub_mu,sub_gamma,sub_p_inf); const DiscreteScalarFunction& aL_d = aL->template get<DiscreteScalarFunction>(); const DiscreteScalarFunction& aT_d = aT->template get<DiscreteScalarFunction>(); @@ -1959,7 +1915,11 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi auto [sub_m_app, sub_rho_app, sub_u_app, sub_E_app, sub_CG_app] = apply_fluxes(sub_dt/2., sub_rho, sub_u, sub_E, sub_CG, sub_ur, sub_ur_o1, sub_Fjr, sub_Fjr_o1); - const auto& [sigma_app, aL_app, aT_app, p_app] = _apply_state_law(law,sub_rho_app,sub_u_app,sub_E_app,sub_CG_app,chi_solid,lambda,mu,gamma,p_inf); + const std::shared_ptr<const DiscreteFunctionVariant> sub_lambda_app = shallowCopy(sub_m_app,lambda); + const std::shared_ptr<const DiscreteFunctionVariant> sub_mu_app = shallowCopy(sub_m_app,mu); + const std::shared_ptr<const DiscreteFunctionVariant> sub_gamma_app = shallowCopy(sub_m_app,gamma); + const std::shared_ptr<const DiscreteFunctionVariant> sub_p_inf_app = shallowCopy(sub_m_app,p_inf); + const auto& [sigma_app, p_app, aL_app, aT_app] = apply_state_law<MeshType>(law,sub_rho_app,sub_u_app,sub_E_app,sub_CG_app,sub_lambda_app,sub_mu_app,sub_gamma_app,sub_p_inf_app); auto [sub_ur_app, sub_Fjr_app] = compute_fluxes(solver_type, sub_rho_app, aL_app, aT_app, sub_u_app, sigma_app, p_app, bc_descriptor_list, CR_ur, CR_Fjr, map2); auto [sub_ur_o1_app, sub_Fjr_o1_app] = compute_fluxes(solver_type, sub_rho_app, aL_app, aT_app, sub_u_app, sigma_app, bc_descriptor_list, CR_ur, CR_Fjr, map2); @@ -2099,43 +2059,46 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi const std::shared_ptr<const DiscreteFunctionVariant>& p2, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list1, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list2, - const double& lambda_f, - const double& mu_f, - const double& lambda_s, - const double& mu_s, - const double& gamma_f, - const double& p_inf_f, - const double& gamma_s, - const double& p_inf_s) const + const std::shared_ptr<const DiscreteFunctionVariant>& lambda1, + const std::shared_ptr<const DiscreteFunctionVariant>& mu1, + const std::shared_ptr<const DiscreteFunctionVariant>& lambda2, + const std::shared_ptr<const DiscreteFunctionVariant>& mu2, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma1, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf1, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma2, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf2) const { std::shared_ptr m2 = getCommonMesh({rho2, aL2, aT2, u2, sigma2}); std::shared_ptr m1 = getCommonMesh({rho1, aL1, aT1, u1, sigma1}); auto [map1, map2] = _computeMapping(m1,m2,bc_descriptor_list1,bc_descriptor_list2); - //Préparation au calcul des lois d'états - size_t chi_solid = 0; - if((mu_s!=0) or (lambda_s!=0)){ - chi_solid = 1; - } - const size_t chi_fluid = 1-chi_solid; - auto [ur1, Fjr1, ur2, Fjr2, CR_ur, CR_Fjr] = compute_fluxes(solver_type,rho1,aL1,aT1,u1,sigma1,p1,bc_descriptor_list1,rho2,aL2,aT2,u2,sigma2,p2,bc_descriptor_list2,map1,map2); auto [ur1_o1, Fjr1_o1, ur2_o1, Fjr2_o1, CR_ur_o1, CR_Fjr_o1] = compute_fluxes(solver_type,rho1,aL1,aT1,u1,sigma1,bc_descriptor_list1,rho2,aL2,aT2,u2,sigma2,bc_descriptor_list2,map1,map2); - + auto [m1_app, rho1_app, u1_app, E1_app, CG1_app] = apply_fluxes(dt1/2., rho1, u1, E1, CG1, ur1, ur1_o1, Fjr1, Fjr1_o1); - const auto& [sigma1_app, aL1_app, aT1_app, p1_app] = _apply_state_law(law, rho1_app, u1_app, E1_app, CG1_app, chi_fluid, lambda_f, mu_f, gamma_f, p_inf_f); - auto [m2_app, rho2_app, u2_app, E2_app, CG2_app] = compute_sub_iterations(solver_type,law,0.03,dt1/2.,rho2,u2,E2,CG2,bc_descriptor_list2,CR_ur,CR_Fjr,map2,chi_solid,lambda_s,mu_s,gamma_s,p_inf_s); - const auto& [sigma2_app, aL2_app, aT2_app, p2_app] = _apply_state_law(law, rho2_app, u2_app, E2_app, CG2_app, chi_solid, lambda_s, mu_s, gamma_s, p_inf_s); + const std::shared_ptr<const DiscreteFunctionVariant>& lambda1_app = shallowCopy(m1_app,lambda1); + const std::shared_ptr<const DiscreteFunctionVariant>& mu1_app = shallowCopy(m1_app,mu1); + const std::shared_ptr<const DiscreteFunctionVariant>& gamma1_app = shallowCopy(m1_app,gamma1); + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf1_app = shallowCopy(m1_app,p_inf1); + const auto& [sigma1_app, p1_app, aL1_app, aT1_app] = apply_state_law<MeshType>(law, rho1_app, u1_app, E1_app, CG1_app, lambda1_app, mu1_app, gamma1_app, p_inf1_app); + + auto [m2_app, rho2_app, u2_app, E2_app, CG2_app] = compute_sub_iterations(solver_type,law,0.4,dt1/2.,rho2,u2,E2,CG2,bc_descriptor_list2,CR_ur,CR_Fjr,map2,lambda2,mu2,gamma2,p_inf2); + + const std::shared_ptr<const DiscreteFunctionVariant>& lambda2_app = shallowCopy(m2_app,lambda2); + const std::shared_ptr<const DiscreteFunctionVariant>& mu2_app = shallowCopy(m2_app,mu2); + const std::shared_ptr<const DiscreteFunctionVariant>& gamma2_app = shallowCopy(m2_app,gamma2); + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf2_app = shallowCopy(m2_app,p_inf2); + const auto& [sigma2_app, p2_app, aL2_app, aT2_app] = apply_state_law<MeshType>(law, rho2_app, u2_app, E2_app, CG2_app, lambda2_app, mu2_app, gamma2_app, p_inf2_app); auto [ur1_app, Fjr1_app, ur2_app, Fjr2_app, CR_ur_app, CR_Fjr_app] = compute_fluxes(solver_type,rho1_app,aL1_app,aT1_app,u1_app,sigma1_app,p1_app,bc_descriptor_list1,rho2_app,aL2_app,aT2_app,u2_app,sigma2_app,p2_app,bc_descriptor_list2,map1,map2); auto [ur1_o1_app, Fjr1_o1_app, ur2_o1_app, Fjr2_o1_app, CR_ur_o1_app, CR_Fjr_o1_app] = compute_fluxes(solver_type,rho1_app,aL1_app,aT1_app,u1_app,sigma1_app,bc_descriptor_list1,rho2_app,aL2_app,aT2_app,u2_app,sigma2_app,bc_descriptor_list2,map1,map2); const auto [new_m1, new_rho1, new_u1, new_E1, new_CG1] = order2_apply_fluxes(dt1, rho1, u1, E1, CG1, rho1_app, CG1_app, ur1_app, ur1_o1_app, Fjr1_app, Fjr1_o1_app); - auto [new_m2, new_rho2, new_u2, new_E2, new_CG2] = compute_sub_iterations_midpoint_method(solver_type,law,0.03,dt1,rho2,u2,E2,CG2,bc_descriptor_list2,CR_ur_app,CR_Fjr_app,map2,chi_solid,lambda_s,mu_s,gamma_s,p_inf_s); + auto [new_m2, new_rho2, new_u2, new_E2, new_CG2] = compute_sub_iterations_midpoint_method(solver_type,law,0.4,dt1,rho2,u2,E2,CG2,bc_descriptor_list2,CR_ur_app,CR_Fjr_app,map2,lambda2,mu2,gamma2,p_inf2); - std::tie(new_m2, new_rho2, new_u2, new_E2, new_CG2) = mesh_correction(new_m1, new_m2, new_rho2, new_u2, new_E2, new_CG2, map1, map2); + std::tie(new_m2, new_rho2, new_u2, new_E2, new_CG2) = mesh_correction<MeshType>(new_m1, new_m2, new_rho2, new_u2, new_E2, new_CG2, map1, map2); return {new_m1, new_rho1, new_u1, new_E1, new_CG1, new_m2, new_rho2, new_u2, new_E2, new_CG2}; diff --git a/src/scheme/Order2LocalDtHyperelasticSolver.hpp b/src/scheme/Order2LocalDtHyperelasticSolver.hpp index b0682e12a0875449ed3ac4dbf762a56a8ca9288f..8712feaf2d3e3bead44f2a5b83d61440ce5ef61c 100644 --- a/src/scheme/Order2LocalDtHyperelasticSolver.hpp +++ b/src/scheme/Order2LocalDtHyperelasticSolver.hpp @@ -89,14 +89,14 @@ class Order2LocalDtHyperelasticSolverHandler const std::shared_ptr<const DiscreteFunctionVariant>& p2, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list1, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list2, - const double& lambda_f, - const double& mu_f, - const double& lambda_s, - const double& mu_s, - const double& gamma_f, - const double& p_inf_f, - const double& gamma_s, - const double& p_inf_s) const = 0; + const std::shared_ptr<const DiscreteFunctionVariant>& lambda1, + const std::shared_ptr<const DiscreteFunctionVariant>& mu1, + const std::shared_ptr<const DiscreteFunctionVariant>& lambda2, + const std::shared_ptr<const DiscreteFunctionVariant>& mu2, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma1, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf1, + const std::shared_ptr<const DiscreteFunctionVariant>& gamma2, + const std::shared_ptr<const DiscreteFunctionVariant>& p_inf2) const = 0; IOrder2LocalDtHyperelasticSolver() = default; IOrder2LocalDtHyperelasticSolver(IOrder2LocalDtHyperelasticSolver&&) = default;