diff --git a/src/language/modules/LocalFSIModule.cpp b/src/language/modules/LocalFSIModule.cpp
index 0df2b95344a231490914a62adea82a55eb7dba32..eeffc83f5486b0dcfe09480e3c300ff91f268532 100644
--- a/src/language/modules/LocalFSIModule.cpp
+++ b/src/language/modules/LocalFSIModule.cpp
@@ -440,6 +440,63 @@ LocalFSIModule::LocalFSIModule()
));
+ this->_addBuiltinFunction("local_dt_hyperelastic_eucclhyd_neohook_solver_order2",
+ std::function(
+
+ [](const std::shared_ptr<const DiscreteFunctionVariant>& rho1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& p1,
+ const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+ bc_descriptor_list1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& rho2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& p2,
+ const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+ bc_descriptor_list2,
+ 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,
+ const size_t& q)
+ -> 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>,
+ 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>> {
+ return Order2LocalDtHyperelasticSolverHandler{getCommonMesh(
+ {rho1, u1, E1, CG1, aL1, aT1, sigma1}),
+ getCommonMesh(
+ {rho2, u2, E2, CG2, aL2, aT2, sigma2})}
+ .solver()
+ .apply(Order2LocalDtHyperelasticSolverHandler::SolverType::Eucclhyd, 1, dt1, q, 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, p_inf1, gamma2, p_inf2);
+ }
+
+ ));
+
+
this->_addBuiltinFunction("local_dt_hyperelastic_eucclhyd_neohook2_solver_order2",
std::function(
@@ -493,6 +550,62 @@ LocalFSIModule::LocalFSIModule()
));
+ this->_addBuiltinFunction("local_dt_hyperelastic_eucclhyd_neohook2_solver_order2",
+ std::function(
+
+ [](const std::shared_ptr<const DiscreteFunctionVariant>& rho1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& p1,
+ const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+ bc_descriptor_list1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& rho2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& p2,
+ const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+ bc_descriptor_list2,
+ 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,
+ const size_t& q)
+ -> 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>,
+ 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>> {
+ return Order2LocalDtHyperelasticSolverHandler{getCommonMesh(
+ {rho1, u1, E1, CG1, aL1, aT1, sigma1}),
+ getCommonMesh(
+ {rho2, u2, E2, CG2, aL2, aT2, sigma2})}
+ .solver()
+ .apply(Order2LocalDtHyperelasticSolverHandler::SolverType::Eucclhyd, 2, dt1, q, 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, p_inf1, gamma2, p_inf2);
+ }
+
+ ));
+
this->_addBuiltinFunction("local_dt_hyperelastic_glace_solver",
std::function(
diff --git a/src/scheme/Order2LocalDtHyperelasticSolver.cpp b/src/scheme/Order2LocalDtHyperelasticSolver.cpp
index 2def47e16c7ba64386df3566558da343cfef6353..dfcf6d6c8d200b23e5947f97629ab9ec2fdafbba 100644
--- a/src/scheme/Order2LocalDtHyperelasticSolver.cpp
+++ b/src/scheme/Order2LocalDtHyperelasticSolver.cpp
@@ -229,8 +229,7 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
const NodeValuePerCell<const Rdxd>& Ajr,
DiscreteFunctionDPk<Dimension, const Rd> DPk_u,
DiscreteFunctionDPk<Dimension, const Rdxd> DPk_S,
- DiscreteFunctionDPk<Dimension, const double> DPk_p,
- CellValue<double> lambda, NodeValuePerCell<double> coef) const
+ DiscreteFunctionDPk<Dimension, const double> DPk_p) const
{
MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(mesh);
@@ -252,7 +251,7 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
for (size_t j = 0; j < node_to_cell.size(); ++j) {
const CellId J = node_to_cell[j];
const unsigned int R = node_local_number_in_its_cells[j];
- const Rdxd sigma_r = sqrt(lambda[J]+(1-lambda[J])*coef(J,R))*DPk_S[J](xr[r]) - DPk_p[J](xr[r])*I;
+ const Rdxd sigma_r = DPk_S[J](xr[r]) - DPk_p[J](xr[r])*I;
br += Ajr(J, R) * DPk_u[J](xr[r]) - sigma_r * Cjr(J, R);
}
@@ -533,8 +532,7 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
const NodeValue<const Rd>& ur,
DiscreteFunctionDPk<Dimension, const Rd> DPk_uh,
DiscreteFunctionDPk<Dimension, const Rdxd> DPk_S,
- DiscreteFunctionDPk<Dimension, const double> DPk_p,
- CellValue<double> lambda, NodeValuePerCell<double> coef) const
+ DiscreteFunctionDPk<Dimension, const double> DPk_p) const
{
MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(mesh);
@@ -551,7 +549,7 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
const auto& cell_nodes = cell_to_node_matrix[j];
for(size_t r = 0; r < cell_nodes.size(); ++r) {
- Rdxd sigma_r = sqrt(lambda[j]+(1-lambda[j])*coef(j,r))*DPk_S[j](xr[cell_nodes[r]]) - DPk_p[j](xr[cell_nodes[r]])*I;
+ Rdxd sigma_r = DPk_S[j](xr[cell_nodes[r]]) - DPk_p[j](xr[cell_nodes[r]])*I;
F(j,r) = -Ajr(j,r) * (DPk_uh[j](xr[cell_nodes[r]]) - ur[cell_nodes[r]]) + sigma_r*Cjr(j,r);
}
});
@@ -640,408 +638,6 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
return std::make_tuple(map1, map2);
}
- void
- _scalar_limiter(const MeshType& mesh,
- const DiscreteFunctionP0<const double>& f,
- DiscreteFunctionDPk<Dimension, double>& DPk_fh) const
- {
- MeshData<MeshType>& mesh_data = MeshDataManager::instance().getMeshData(mesh);
- StencilManager::BoundaryDescriptorList symmetry_boundary_descriptor_list;
- StencilDescriptor stencil_descriptor{1, StencilDescriptor::ConnectionType::by_nodes};
- auto stencil = StencilManager::instance().getCellToCellStencilArray(mesh.connectivity(), stencil_descriptor, symmetry_boundary_descriptor_list);
-
- const auto xj = mesh_data.xj();
-
- CellValue<double> alph_J2{mesh.connectivity()};
-
- parallel_for(mesh.numberOfCells(), PUGS_LAMBDA(const CellId cell_id){
- const double fj = f[cell_id];
-
- double f_min = fj;
- double f_max = fj;
-
- const auto cell_stencil = stencil[cell_id];
- for(size_t i_cell = 0; i_cell < cell_stencil.size(); ++i_cell){
- f_min = std::min(f_min, f[cell_stencil[i_cell]]);
- f_max = std::max(f_max, f[cell_stencil[i_cell]]);
- }
-
- double f_bar_min = fj;
- double f_bar_max = fj;
-
- for(size_t i_cell = 0; i_cell < cell_stencil.size(); ++i_cell){
- const CellId cell_k_id = cell_stencil[i_cell];
- const double f_xk = DPk_fh[cell_id](xj[cell_k_id]);
-
- f_bar_min = std::min(f_bar_min, f_xk);
- f_bar_max = std::max(f_bar_max, f_xk);
- }
-
- const double eps = 1E-14;
- double coef1 = 1;
- if (std::abs(f_bar_max - fj) > eps) {
- coef1 = (f_max - fj) / ((f_bar_max - fj));
- }
-
- double coef2 = 1.;
- if (std::abs(f_bar_min - fj) > eps) {
- coef2 = (f_min - fj) / ((f_bar_min - fj));
- }
-
- const double lambda = std::max(0., std::min(1., std::min(coef1, coef2)));
- alph_J2[cell_id] = lambda;
-
- auto coefficients = DPk_fh.coefficients(cell_id);
-
- coefficients[0] = (1 - lambda) * f[cell_id] + lambda * coefficients[0];
- for (size_t i = 1; i < coefficients.size(); ++i) {
- coefficients[i] *= lambda;
- }
- });
- }
-
- void
- _vector_limiter(const MeshType& mesh,
- const DiscreteFunctionP0<const Rd>& f,
- DiscreteFunctionDPk<Dimension, Rd> DPk_fh,
- const CellValue<const Rdxd>& grad_u) const
- {
- MeshData<MeshType>& mesh_data = MeshDataManager::instance().getMeshData(mesh);
- StencilManager::BoundaryDescriptorList symmetry_boundary_descriptor_list;
- StencilDescriptor stencil_descriptor{1, StencilDescriptor::ConnectionType::by_nodes};
- auto stencil = StencilManager::instance().getCellToCellStencilArray(mesh.connectivity(), stencil_descriptor,
- symmetry_boundary_descriptor_list);
-
- const auto xj = mesh_data.xj();
-
- CellValue<Rdxd> sym_grad_u{mesh.connectivity()};
- parallel_for(
- mesh.numberOfCells(), PUGS_LAMBDA(const CellId j){
- sym_grad_u[j] = grad_u[j] + transpose(grad_u[j]);
- });
-
- CellValue<SmallArray<double>> eigunvalues{mesh.connectivity()};
- CellValue<std::vector<SmallVector<double>>> eigunvectors{mesh.connectivity()};
- for(CellId j = 0; j < mesh.numberOfCells(); ++j){
- EigenvalueSolver{}.computeForSymmetricMatrix(sym_grad_u[j],eigunvalues[j],eigunvectors[j]);
- }
-
- CellValue<Rd> n{mesh.connectivity()};
- CellValue<Rd> t{mesh.connectivity()};
- CellValue<Rd> l{mesh.connectivity()};
- parallel_for(
- mesh.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
- n[cell_id] = zero;
- t[cell_id] = zero;
- l[cell_id] = zero;
- if(frobeniusNorm(sym_grad_u[cell_id]) > 1E-5){
- if constexpr(Dimension == 2){
- Rd nj;
- Rd tj;
- for(size_t i = 0; i < Dimension; ++i){
- nj[i] = eigunvectors[cell_id][0][i];
- tj[i] = eigunvectors[cell_id][1][i];
- }
- n[cell_id] = nj;
- t[cell_id] = tj;
- if(l2Norm(nj) != 0){
- n[cell_id] = (1/l2Norm(nj))*n[cell_id];
- }
- if(l2Norm(tj) != 0){
- t[cell_id] = (1/l2Norm(tj))*t[cell_id];
- }
- }
- else{
- if constexpr(Dimension == 3){
- Rd nj;
- Rd tj;
- Rd lj;
- for(size_t i = 0; i < Dimension; ++i){
- nj[i] = eigunvectors[cell_id][0][i];
- tj[i] = eigunvectors[cell_id][1][i];
- lj[i] = eigunvectors[cell_id][2][i];
- }
- n[cell_id] = nj;
- t[cell_id] = tj;
- l[cell_id] = lj;
- if(l2Norm(nj) != 0){
- n[cell_id] = (1/l2Norm(nj))*n[cell_id];
- }
- if(l2Norm(tj) != 0){
- t[cell_id] = (1/l2Norm(tj))*t[cell_id];
- }
- if(l2Norm(lj) != 0){
- l[cell_id] = (1/l2Norm(lj))*l[cell_id];
- }
- }
- }
- }
- });
-
- parallel_for(
- mesh.numberOfCells(), PUGS_LAMBDA(const CellId cell_id){
- const double fn = dot(f[cell_id],n[cell_id]);
- const double ft = dot(f[cell_id],t[cell_id]);
- const double fl = dot(f[cell_id],l[cell_id]);
-
- double fn_min = fn;
- double fn_max = fn;
- double ft_min = ft;
- double ft_max = ft;
- double fl_min = fl;
- double fl_max = fl;
-
- const auto cell_stencil = stencil[cell_id];
- for(size_t i_cell = 0; i_cell < cell_stencil.size(); ++i_cell){
- const double fn_k = dot(f[cell_stencil[i_cell]],n[cell_id]);
- fn_min = std::min(fn_min,fn_k);
- fn_max = std::max(fn_max,fn_k);
-
- const double ft_k = dot(f[cell_stencil[i_cell]],t[cell_id]);
- ft_min = std::min(ft_min,ft_k);
- ft_max = std::max(ft_max,ft_k);
-
- const double fl_k = dot(f[cell_stencil[i_cell]],l[cell_id]);
- fl_min = std::min(fl_min,fl_k);
- fl_max = std::max(fl_max,fl_k);
- }
-
- double fn_bar_min = fn;
- double fn_bar_max = fn;
- double ft_bar_min = ft;
- double ft_bar_max = ft;
- double fl_bar_min = fl;
- double fl_bar_max = fl;
-
- for(size_t i_cell = 0; i_cell < cell_stencil.size(); ++i_cell){
- const CellId cell_k_id = cell_stencil[i_cell];
- const Rd f_xk = DPk_fh[cell_id](xj[cell_k_id]);
-
- const double fn_xk = dot(f_xk,n[cell_id]);
- fn_bar_min = std::min(fn_bar_min,fn_xk);
- fn_bar_max = std::max(fn_bar_max,fn_xk);
-
- const double ft_xk = dot(f_xk,t[cell_id]);
- ft_bar_min = std::min(ft_bar_min,ft_xk);
- ft_bar_max = std::max(ft_bar_max,ft_xk);
-
- const double fl_xk = dot(f_xk,l[cell_id]);
- fl_bar_min = std::min(fl_bar_min,fl_xk);
- fl_bar_max = std::max(fl_bar_max,fl_xk);
- }
-
- const double eps = 1E-14;
- double coef1_n = 1;
- if(std::abs(fn_bar_max - fn) > eps){
- coef1_n = (fn_max - fn) / (fn_bar_max - fn);
- }
- double coef2_n = 1;
- if(std::abs(fn_bar_min - fn) > eps){
- coef2_n = (fn_min - fn) / (fn_bar_min - fn);
- }
-
- double coef1_t = 1;
- if(std::abs(ft_bar_max - ft) > eps){
- coef1_t = (ft_max - ft) / (ft_bar_max - ft);
- }
- double coef2_t = 1;
- if(std::abs(ft_bar_min - ft) > eps){
- coef2_t = (ft_min - ft) / (ft_bar_min - ft);
- }
-
- double coef1_l = 1;
- if(std::abs(fl_bar_max - fl) > eps){
- coef1_l = (fl_max - fl) / (fl_bar_max - fl);
- }
- double coef2_l = 1;
- if(std::abs(fl_bar_min - fl) > eps){
- coef2_l = (fl_min - fl) / (fl_bar_min - fl);
- }
-
- const double lambda_n = std::max(0., std::min(1., std::min(coef1_n,coef2_n)));
- const double lambda_t = std::max(0., std::min(1., std::min(coef1_t,coef2_t)));
- const double lambda_l = std::max(0., std::min(1., std::min(coef1_l,coef2_l)));
-
- auto coefficients = DPk_fh.coefficients(cell_id);
- coefficients[0] = (1 - lambda_n)*fn*n[cell_id] + lambda_n*dot(coefficients[0],n[cell_id])*n[cell_id]
- + (1 - lambda_t)*ft*t[cell_id] + lambda_t*dot(coefficients[0],t[cell_id])*t[cell_id]
- + (1 - lambda_l)*fl*l[cell_id] + lambda_l*dot(coefficients[0],l[cell_id])*l[cell_id];
- for(size_t i = 1; i < coefficients.size(); ++i){
- coefficients[i] = lambda_n*dot(coefficients[i],n[cell_id])*n[cell_id]
- + lambda_t*dot(coefficients[i],t[cell_id])*t[cell_id]
- + lambda_l*dot(coefficients[i],l[cell_id])*l[cell_id];
- }
- });
- }
-
- CellValue<double>
- _matrix_limiter(const MeshType& mesh,
- const DiscreteFunctionP0<const Rdxd>& S,
- DiscreteFunctionDPk<Dimension, Rdxd>& DPk_Sh) const
- {
- MeshData<MeshType>& mesh_data = MeshDataManager::instance().getMeshData(mesh);
- StencilManager::BoundaryDescriptorList symmetry_boundary_descriptor_list;
- StencilDescriptor stencil_descriptor{1, StencilDescriptor::ConnectionType::by_nodes};
- auto stencil = StencilManager::instance().getCellToCellStencilArray(mesh.connectivity(), stencil_descriptor,
- symmetry_boundary_descriptor_list);
-
- const auto xj = mesh_data.xj();
-
- //A retirer + tard
- const auto xr = mesh.xr();
- const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix();
- //
-
- CellValue<double> lambda{mesh.connectivity()};
- const DiscreteScalarFunction& inv2 = 0.5*trace(transpose(S)*S);
- parallel_for(
- mesh.numberOfCells(), PUGS_LAMBDA(const CellId cell_id){
- const double inv2j = inv2[cell_id];
-
- double inv2_min = inv2j;
- double inv2_max = inv2j;
-
- const auto cell_stencil = stencil[cell_id];
- for(size_t i_cell = 0; i_cell < cell_stencil.size(); ++i_cell){
- inv2_min = std::min(inv2_min, inv2[cell_stencil[i_cell]]);
- inv2_max = std::max(inv2_max, inv2[cell_stencil[i_cell]]);
- }
-
- double inv2_bar_min = inv2j;
- double inv2_bar_max = inv2j;
-
- const auto& cell_nodes = cell_to_node_matrix[cell_id];
- for(size_t r = 0; r < cell_nodes.size(); ++r){
- const double inv2_xr = 0.5*trace(transpose(DPk_Sh[cell_id](xr[cell_nodes[r]]))*DPk_Sh[cell_id](xr[cell_nodes[r]]));
-
- inv2_bar_min = std::min(inv2_bar_min, inv2_xr);
- inv2_bar_max = std::max(inv2_bar_max, inv2_xr);
- }
-
- const double eps = 1E-14;
- double coef1 = 1.;
- double coef2 = 1.;
- if(std::abs(inv2_bar_max - inv2j) > eps){
- coef1 = (inv2_max - inv2j) / (inv2_bar_max - inv2j);
- }
- if(std::abs(inv2_bar_min - inv2j) > eps){
- coef2 = (inv2_min - inv2j) / (inv2_bar_min - inv2j);
- }
-
- const double lambda_inv2 = std::max(0., std::min(1., std::min(coef1, coef2)));
- lambda[cell_id] = lambda_inv2;
- });
- return lambda;
- }
-
- std::tuple<const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>>
- _apply_NeoHook(const DiscreteScalarFunction rho,
- const DiscreteVectorFunction u,
- const DiscreteScalarFunction E,
- const DiscreteTensorFunction CG,
- const size_t& chi_solid,
- const double& lambda,
- const double& mu,
- const double& gamma,
- const double& p_inf) const
- {
- const TinyMatrix<Dimension> I = identity;
-
- const DiscreteScalarFunction& eps = E - 0.5 * dot(u,u);
- const DiscreteScalarFunction& p_d = (1-chi_solid)*(gamma-1) * rho * eps - p_inf*gamma;
- const DiscreteTensorFunction& sigma_d = chi_solid * (mu / sqrt(det(CG)) * (CG - I) + lambda / sqrt(det(CG)) * log(sqrt(det(CG))) * I) - p_d * I;
- const DiscreteScalarFunction& aL_d = sqrt(chi_solid * (lambda + 2 * mu) / rho + gamma * (p_d + p_inf) / rho);
- const DiscreteScalarFunction& aT_d = sqrt(chi_solid * mu / rho);
-
- return {std::make_shared<DiscreteFunctionVariant>(sigma_d),
- std::make_shared<DiscreteFunctionVariant>(aL_d),
- std::make_shared<DiscreteFunctionVariant>(aT_d),
- std::make_shared<DiscreteFunctionVariant>(p_d)};
- }
-
- std::tuple<const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>>
- _apply_NeoHook2(const DiscreteScalarFunction rho,
- const DiscreteVectorFunction u,
- const DiscreteScalarFunction E,
- const DiscreteTensorFunction CG,
- const size_t& chi_solid,
- const double& mu,
- const double& gamma,
- const double& p_inf) const
- {
- const TinyMatrix<Dimension> I = identity;
-
- const DiscreteScalarFunction& eps = E - 0.5 * dot(u,u);
- const DiscreteScalarFunction& p_d = (gamma-1) * rho * eps - p_inf*gamma;
- const DiscreteTensorFunction& sigma_d = chi_solid * 2*mu/sqrt(det(CG))*(CG-1./3. * trace(CG)*I) - p_d * I;
- const DiscreteScalarFunction& aL_d = sqrt(chi_solid * (2 * mu) / rho + ((1-chi_solid)*gamma * p_d + chi_solid * (gamma*(p_d+p_inf))) / rho);
- const DiscreteScalarFunction& aT_d = sqrt(chi_solid * mu / rho);
-
- return {std::make_shared<DiscreteFunctionVariant>(sigma_d),
- std::make_shared<DiscreteFunctionVariant>(aL_d),
- std::make_shared<DiscreteFunctionVariant>(aT_d),
- std::make_shared<DiscreteFunctionVariant>(p_d)};
- }
-
- std::tuple<const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>,
- const std::shared_ptr<const DiscreteFunctionVariant>>
- _apply_state_law(const size_t law,
- const std::shared_ptr<const DiscreteFunctionVariant>& rho_v,
- const std::shared_ptr<const DiscreteFunctionVariant>& u_v,
- const std::shared_ptr<const DiscreteFunctionVariant>& E_v,
- const std::shared_ptr<const DiscreteFunctionVariant>& CG_v,
- const size_t& chi_solid,
- const double& lambda,
- const double& mu,
- const double& gamma,
- const double& p_inf) const
- {
- const DiscreteScalarFunction& rho_d = rho_v->get<DiscreteScalarFunction>();
- const DiscreteVectorFunction& u_d = u_v->get<DiscreteVectorFunction>();
- const DiscreteScalarFunction& E_d = E_v->get<DiscreteScalarFunction>();
- const DiscreteTensorFunction& CG_d = CG_v->get<DiscreteTensorFunction>();
-
- if(law == 1){
- return _apply_NeoHook(rho_d,u_d,E_d,CG_d,chi_solid,lambda,mu,gamma,p_inf);
- } else {
- return _apply_NeoHook2(rho_d,u_d,E_d,CG_d,chi_solid,mu,gamma,p_inf);
- }
- }
-
- NodeValuePerCell<double>
- _compute_inv2_coefficient(const MeshType& mesh,
- const DiscreteTensorFunction& S,
- const DiscreteFunctionDPk<Dimension, Rdxd>& DPk_Sh) const
- {
- const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix();
- const NodeValue<const Rd>& xr = mesh.xr();
-
- const DiscreteScalarFunction& J2 = 0.5 * trace(transpose(S)*S);
- NodeValuePerCell<double> coef{mesh.connectivity()};
- parallel_for(
- mesh.numberOfCells(), PUGS_LAMBDA(const CellId j){
- const auto& cell_nodes = cell_to_node_matrix[j];
- for(size_t r = 0; r < cell_nodes.size(); ++r){
- const double J2_p = 0.5*trace(transpose(DPk_Sh[j](xr[cell_nodes[r]]))*DPk_Sh[j](xr[cell_nodes[r]]));
- if(J2_p != 0.){
- coef(j,r) = J2[j]/J2_p;
- }else{
- coef(j,r) = 0;
- }
- }
- });
-
- return coef;
- }
-
public:
std::tuple<const std::shared_ptr<const ItemValueVariant>,
const std::shared_ptr<const SubItemValuePerItemVariant>,
@@ -1136,12 +732,9 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
DiscreteFunctionDPk<Dimension, double> p1_lim = copy(DPk_ph1);
const CellValue<const Rdxd> grad_u1 = this->_computeGradU(solver_type,rho1_v,aL1_v,aT1_v,u1_v,sigma1_v,bc_descriptor_list1);
- this->_vector_limiter(mesh1,u1,u1_lim,grad_u1);
- CellValue<double> lambda1 = this->_matrix_limiter(mesh1, S1, S1_lim);
- this->_scalar_limiter(mesh1, p1, p1_lim);
-
- auto copy_DPk_Sh1 = copy(DPk_Sh1);
- const NodeValuePerCell<double> coef1 = _compute_inv2_coefficient(mesh1, S1, copy_DPk_Sh1);
+ vector_limiter(mesh1,u1,u1_lim,grad_u1);
+ matrix_limiter(mesh1, S1, S1_lim);
+ scalar_limiter(mesh1, p1, p1_lim);
auto reconstruction2 = PolynomialReconstruction{reconstruction_descriptor2}.build(u2_v, S2_v, p2_v);
auto DPk_uh2 = reconstruction2[0]->get<DiscreteFunctionDPk<Dimension, const Rd>>();
@@ -1153,20 +746,17 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
DiscreteFunctionDPk<Dimension, double> p2_lim = copy(DPk_ph2);
const CellValue<const Rdxd> grad_u2 = this->_computeGradU(solver_type,rho2_v,aL2_v,aT2_v,u2_v,sigma2_v,bc_descriptor_list2);
- this->_vector_limiter(mesh2,u2,u2_lim,grad_u2);
- CellValue<double> lambda2 = this->_matrix_limiter(mesh2, S2, S2_lim);
- this->_scalar_limiter(mesh2, p2, p2_lim);
-
- auto copy_DPk_Sh2 = copy(DPk_Sh2);
- const NodeValuePerCell<double> coef2 = _compute_inv2_coefficient(mesh2, S2, copy_DPk_Sh2);
+ vector_limiter(mesh2,u2,u2_lim,grad_u2);
+ matrix_limiter(mesh2, S2, S2_lim);
+ scalar_limiter(mesh2, p2, p2_lim);
NodeValuePerCell<const Rdxd> Ajr1 = this->_computeAjr(solver_type, mesh1, rho1 * aL1, rho1 * aT1);
NodeValuePerCell<const Rdxd> Ajr2 = this->_computeAjr(solver_type, mesh2, rho2 * aL2, rho2 * aT2);
NodeValue<Rdxd> Ar1 = this->_computeAr(mesh1, Ajr1);
- NodeValue<Rd> br1 = this->_computeBr(mesh1, Ajr1, u1_lim, S1_lim, p1_lim, lambda1, coef1);
+ NodeValue<Rd> br1 = this->_computeBr(mesh1, Ajr1, u1_lim, S1_lim, p1_lim);
NodeValue<Rdxd> Ar2 = this->_computeAr(mesh2, Ajr2);
- NodeValue<Rd> br2 = this->_computeBr(mesh2, Ajr2, u2_lim, S2_lim, p2_lim, lambda2, coef2);
+ NodeValue<Rd> br2 = this->_computeBr(mesh2, Ajr2, u2_lim, S2_lim, p2_lim);
const BoundaryConditionList bc_list1 = this->_getBCList(mesh1, bc_descriptor_list1);
const BoundaryConditionList bc_list2 = this->_getBCList(mesh2, bc_descriptor_list2);
@@ -1183,8 +773,8 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
this->_applyCouplingBC2(Ar1,Ar2,ur1,ur2,map1,map2);
- NodeValuePerCell<Rd> Fjr1 = this->_computeFjr(mesh1, Ajr1, ur1, u1_lim, S1_lim, p1_lim, lambda1, coef1);
- NodeValuePerCell<Rd> Fjr2 = this->_computeFjr(mesh2, Ajr2, ur2, u2_lim, S2_lim, p2_lim, lambda2, coef2);
+ NodeValuePerCell<Rd> Fjr1 = this->_computeFjr(mesh1, Ajr1, ur1, u1_lim, S1_lim, p1_lim);
+ NodeValuePerCell<Rd> Fjr2 = this->_computeFjr(mesh2, Ajr2, ur2, u2_lim, S2_lim, p2_lim);
NodeValue<Rd> CR_ur = copy(ur2);
NodeValuePerCell<Rd> CR_Fjr = copy(Fjr2);
@@ -1352,17 +942,14 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
DiscreteFunctionDPk<Dimension, double> p_lim = copy(DPk_ph);
const CellValue<const Rdxd> grad_u = this->_computeGradU(solver_type,rho_v,aL_v,aT_v,u_v,sigma_v,bc_descriptor_list);
- this->_vector_limiter(mesh,u,u_lim,grad_u);
- CellValue<double> lambda = this->_matrix_limiter(mesh, S, S_lim);
- this->_scalar_limiter(mesh, p, p_lim);
-
- auto copy_DPk_Sh = copy(DPk_Sh);
- const NodeValuePerCell<double> coef = _compute_inv2_coefficient(mesh, S, copy_DPk_Sh);
+ vector_limiter(mesh,u,u_lim,grad_u);
+ matrix_limiter(mesh, S, S_lim);
+ scalar_limiter(mesh, p, p_lim);
NodeValuePerCell<const Rdxd> Ajr = this->_computeAjr(solver_type, mesh, rho * aL, rho * aT);
NodeValue<Rdxd> Ar = this->_computeAr(mesh, Ajr);
- NodeValue<Rd> br = this->_computeBr(mesh, Ajr, u_lim, S_lim, p_lim, lambda, coef);
+ NodeValue<Rd> br = this->_computeBr(mesh, Ajr, u_lim, S_lim, p_lim);
const BoundaryConditionList bc_list = this->_getBCList(mesh, bc_descriptor_list);
this->_applyBoundaryConditions(bc_list, mesh, Ar, br);
@@ -1371,7 +958,7 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
synchronize(br);
NodeValue<Rd> ur = this->_computeUr(mesh, Ar, br);
- NodeValuePerCell<Rd> Fjr = this->_computeFjr(mesh, Ajr, ur, u_lim, S_lim, p_lim, lambda, coef);
+ NodeValuePerCell<Rd> Fjr = this->_computeFjr(mesh, Ajr, ur, u_lim, S_lim, p_lim);
this->_applyCouplingBC(mesh, ur, CR_ur, Fjr, CR_Fjr, map2);
@@ -1864,6 +1451,71 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
return {sub_m, sub_rho, sub_u, sub_E, sub_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>>
+ compute_sub_iterations(const SolverType& solver_type,
+ const size_t& law,
+ const double& dt,
+ const size_t& q,
+ 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::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list,
+ NodeValue<Rd> CR_ur,
+ NodeValuePerCell<Rd> CR_Fjr,
+ std::vector<NodeId> map2,
+ 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, 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 sub_dt = dt / q;
+ double sum_dt = 0.;
+ for(size_t i = 0; i < q; ++i){
+
+ if( i == q - 1){
+ sub_dt = dt - sum_dt;
+ }
+
+ 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>();
+ const std::shared_ptr<const DiscreteFunctionVariant>& c =
+ std::make_shared<const DiscreteFunctionVariant>(aL_d + aT_d);
+
+ auto [sub_ur2, sub_Fjr2] = compute_fluxes(solver_type, sub_rho, aL, aT, sub_u, sigma, p, bc_descriptor_list, CR_ur, CR_Fjr, map2);
+ auto [sub_ur2_o1, sub_Fjr2_o1] = compute_fluxes(solver_type, sub_rho, aL, aT, sub_u, sigma, bc_descriptor_list, CR_ur, CR_Fjr, map2);
+
+ 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;
+
+ }
+
+ return {sub_m, sub_rho, sub_u, sub_E, sub_CG};
+ }
+
std::tuple<std::shared_ptr<const MeshVariant>,
std::shared_ptr<const DiscreteFunctionVariant>,
std::shared_ptr<const DiscreteFunctionVariant>,
@@ -1932,101 +1584,149 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
return {sub_m, sub_rho, sub_u, sub_E, sub_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>,
- // 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>>
- //apply(const SolverType& solver_type,
- // const double& dt1,
- // const size_t& q,
- // const std::shared_ptr<const DiscreteFunctionVariant>& rho1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& rho2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& u1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& u2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& E1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& E2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& CG1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& CG2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aL1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aL2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aT1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aT2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& sigma1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& sigma2,
- // const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list1,
- // const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list2,
- // const double& mu,
- // const double& lambda) const
- //{
- // std::shared_ptr new_m2 = getCommonMesh({rho2, aL2, aT2, u2, sigma2});
- // std::shared_ptr m1 = getCommonMesh({rho1, aL1, aT1, u1, sigma1});
-//
- // std::shared_ptr<const DiscreteFunctionVariant> new_rho2 = rho2;
- // std::shared_ptr<const DiscreteFunctionVariant> new_u2 = u2;
- // std::shared_ptr<const DiscreteFunctionVariant> new_E2 = E2;
- // std::shared_ptr<const DiscreteFunctionVariant> new_CG2 = CG2;
-//
- // auto [map1, map2] = _computeMapping(m1, new_m2, bc_descriptor_list1, bc_descriptor_list2);
-//
- // auto [ur1, Fjr1, ur2, Fjr2, CR_ur, CR_Fjr] =
- // compute_fluxes(solver_type, rho1, aL1, aT1, u1, sigma1, bc_descriptor_list1, rho2, aL2, aT2, u2, sigma2,
- // bc_descriptor_list2, map1, map2);
- // const auto [new_m1, new_rho1, new_u1, new_E1, new_CG1] = apply_fluxes(dt1, rho1, u1, E1, CG1, ur1, Fjr1);
-//
- // double dt2 = dt1 / q;
- // const double gamma = 1.4;
- // const TinyMatrix<Dimension> I = identity;
- // double sum_dt = 0;
-//
- // size_t fluid = 0;
- // if ((mu == 0) and (lambda == 0)) {
- // fluid = 1;
- // }
-//
- // for (size_t i = 0; i < q; i++) {
- // if (i == q - 1) {
- // dt2 = dt1 - sum_dt;
- // }
-//
- // const DiscreteScalarFunction& rho_d = new_rho2->get<DiscreteScalarFunction>();
- // const DiscreteVectorFunction& u_d = new_u2->get<DiscreteVectorFunction>();
- // const DiscreteScalarFunction& E_d = new_E2->get<DiscreteScalarFunction>();
- // const DiscreteScalarFunction& eps = E_d - 0.5 * dot(u_d, u_d);
- // const DiscreteTensorFunction& CG_d = new_CG2->get<DiscreteTensorFunction>();
- // const DiscreteScalarFunction& p = fluid * (gamma - 1) * rho_d * eps;
- // const DiscreteTensorFunction& sigma_d =
- // mu / sqrt(det(CG_d)) * (CG_d - I) + lambda / sqrt(det(CG_d)) * log(sqrt(det(CG_d))) * I - p * I;
- // const DiscreteScalarFunction& aL_d = sqrt((lambda + 2 * mu) / rho_d + gamma * p / rho_d);
-//
- // const DiscreteScalarFunction& aT_d = sqrt(mu / rho_d);
-//
- // const std::shared_ptr<const DiscreteFunctionVariant>& new_sigma2 =
- // std::make_shared<const DiscreteFunctionVariant>(sigma_d);
- // const std::shared_ptr<const DiscreteFunctionVariant>& new_aL2 =
- // std::make_shared<const DiscreteFunctionVariant>(aL_d);
- // const std::shared_ptr<const DiscreteFunctionVariant>& new_aT2 =
- // std::make_shared<const DiscreteFunctionVariant>(aT_d);
-//
- // auto [sub_ur2, sub_Fjr2] = compute_fluxes(solver_type, new_rho2, new_aL2, new_aT2, new_u2, new_sigma2,
- // bc_descriptor_list2, CR_ur, CR_Fjr, map2);
-//
- // std::tie(new_m2, new_rho2, new_u2, new_E2, new_CG2) =
- // apply_fluxes(dt2, new_rho2, new_u2, new_E2, new_CG2, sub_ur2, sub_Fjr2);
-//
- // sum_dt += dt2;
- // }
-//
- // 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);
-//
- // return {new_m1, new_rho1, new_u1, new_E1, new_CG1, new_m2, new_rho2, new_u2, new_E2, new_CG2};
- //}
+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>>
+compute_sub_iterations_midpoint_method(const SolverType& solver_type,
+ const size_t& law,
+ const double& dt,
+ const size_t q,
+ 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::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list,
+ NodeValue<Rd> CR_ur,
+ NodeValuePerCell<Rd> CR_Fjr,
+ std::vector<NodeId> map2,
+ 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;
+ std::shared_ptr<const DiscreteFunctionVariant> sub_u = u;
+ std::shared_ptr<const DiscreteFunctionVariant> sub_E = E;
+ std::shared_ptr<const DiscreteFunctionVariant> sub_CG = CG;
+
+ double sub_dt = dt / q;
+ double sum_dt = 0;
+ for(size_t i = 0; i < q; ++i){
+
+ if( i == q - 1){
+ sub_dt = dt - sum_dt;
+ }
+
+ 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>();
+ const std::shared_ptr<const DiscreteFunctionVariant>& c = std::make_shared<const DiscreteFunctionVariant>(aL_d + aT_d);
+
+ auto [sub_ur, sub_Fjr] = compute_fluxes(solver_type, sub_rho, aL, aT, sub_u, sigma, p, bc_descriptor_list, CR_ur, CR_Fjr, map2);
+ auto [sub_ur_o1, sub_Fjr_o1] = compute_fluxes(solver_type, sub_rho, aL, aT, sub_u, sigma, bc_descriptor_list, CR_ur, CR_Fjr, map2);
+
+ 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 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);
+
+ std::tie(sub_m, sub_rho, sub_u, sub_E, sub_CG) = order2_apply_fluxes(sub_dt, sub_rho, sub_u, sub_E, sub_CG, sub_rho_app, sub_CG_app, sub_ur_app, sub_ur_o1_app, sub_Fjr_app, sub_Fjr_o1_app);
+
+ sum_dt += sub_dt;
+ }
+
+ return {sub_m, sub_rho, sub_u, sub_E, sub_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>,
+ 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>>
+ apply(const SolverType& solver_type,
+ const size_t& law,
+ const double& dt1,
+ const size_t& q,
+ const std::shared_ptr<const DiscreteFunctionVariant>& rho1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& rho2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& p1,
+ 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 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);
+
+ 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 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,dt1/2.,q,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,dt1,q,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<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};
+ }
std::tuple<std::shared_ptr<const MeshVariant>,
std::shared_ptr<const DiscreteFunctionVariant>,
@@ -2101,7 +1801,6 @@ class Order2LocalDtHyperelasticSolverHandler::Order2LocalDtHyperelasticSolver fi
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};
-
}
Order2LocalDtHyperelasticSolver() = default;
diff --git a/src/scheme/Order2LocalDtHyperelasticSolver.hpp b/src/scheme/Order2LocalDtHyperelasticSolver.hpp
index 8712feaf2d3e3bead44f2a5b83d61440ce5ef61c..633a87ccc2e93b074d4abee64b6d2b323d10e44d 100644
--- a/src/scheme/Order2LocalDtHyperelasticSolver.hpp
+++ b/src/scheme/Order2LocalDtHyperelasticSolver.hpp
@@ -26,37 +26,46 @@ class Order2LocalDtHyperelasticSolverHandler
private:
struct IOrder2LocalDtHyperelasticSolver
{
- //virtual 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>,
- // 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>>
- //apply(const SolverType& solver_type,
- // const double& dt1,
- // const size_t& q,
- // const std::shared_ptr<const DiscreteFunctionVariant>& rho1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& rho2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& u1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& u2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& E1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& E2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& CG1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& CG2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aL1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aL2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aT1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& aT2,
- // const std::shared_ptr<const DiscreteFunctionVariant>& sigma1,
- // const std::shared_ptr<const DiscreteFunctionVariant>& sigma2,
- // const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list1,
- // const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list2,
- // const double& mu,
- // const double& lambda) const = 0;
+ virtual 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>,
+ 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>>
+ apply(const SolverType& solver_type,
+ const size_t& law,
+ const double& dt1,
+ const size_t& q,
+ const std::shared_ptr<const DiscreteFunctionVariant>& rho1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& rho2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& u2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& E2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& CG2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aL2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& aT2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma1,
+ const std::shared_ptr<const DiscreteFunctionVariant>& sigma2,
+ const std::shared_ptr<const DiscreteFunctionVariant>& p1,
+ 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 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;
virtual std::tuple<std::shared_ptr<const MeshVariant>,
std::shared_ptr<const DiscreteFunctionVariant>,