How long should the hyperelastic equations be solved before updating the mesh? To be specific, I'm interested in the hyperelastic model with a neo-Hookean solid:
$$ \nabla\cdot\sigma + f = \rho\ddot{{u}}\\ \sigma = \mu F + (\lambda\log\det F - \mu)F^{-T}\\ F = I + \nabla u $$
where
- $\sigma$ - Stress tensor
- $F$ - Deformation gradient
- $u$ - Displacement
- $\lambda, \mu$ - Lamé parameters
- $f$ - External force
There's another question asking about what algorithms can be used to solve this problem, but it sounded like a standard Galerkin finite element method would work. Meaning, solve the above equations for the displacements and then use the displacements to update the location of the nodes in the mesh. Certainly, there's a lot of nuance to this, but what I would like to understand better is what considerations should be taken into how long the above equations can or should be solved for the displacements before stopping the simulation and updating the mesh. Alternatively, is there a name for this kind of algorithm to make it easier to search for additional resources?
Edit 1
Since there's some confusion, I don't have a definite algorithm for this problem, which is partly why I'm asking for clarification and assistance.
I'm proposing solving the hyperelastic equations using a Galerkin finite element method with piecewise linear elements to discretize the spatial components and a Runge-Kutta method to discretize and solve an initial value problem over time. Assuming that this works, we generate the displacement, $u$, which can be evaluated at any point in the solved time. Of course, having a displacement means that we can move and deform the object itself, which means move and deform the mesh. I propose moving the nodal points of the mesh based on the displacement $u$. Once we deform the mesh, we could continue to solve the hyperelastic equations with the new domain. Again, assuming this works, what's not clear to me is how long to solve the original PDE before deforming the mesh. I don't know how to generate an error measure to check, whether such algorithms actually converge, and what they are potentially called.