def Piola1(d_, w_, lambda_, mu_s, E_func=None):
I = Identity(2)
if callable(E_func):
E = E_func(d_, w_)
else:
F = I + grad(d_["n"])
E = 0.5 * ((F.T * F) - I)
return F * (lambda_ * tr(E) * I + 2 * mu_s * E)
def _solve(self, z, x=None):
# problem variables
du = TrialFunction(self.V) # incremental displacement
v = TestFunction(self.V) # test function
u = Function(self.V) # displacement from previous iteration
# kinematics
ii = Identity(3) # identity tensor dimension 3
f = ii + grad(u) # deformation gradient
c = f.T * f # right Cauchy-Green tensor
# invariants of deformation tensors
ic = tr(c)
j = det(f)
# elasticity parameters
if type(z) in [list, np.ndarray]:
param = self.param_remapper(z[0]) if self.param_remapper is not None else z[0]
else:
param = self.param_remapper(z) if self.param_remapper is not None else z
e_var = variable(Constant(param)) # Young's modulus
nu = Constant(.3) # Shear modulus (Lamè's second parameter)
mu, lmbda = e_var / (2 * (1 + nu)), e_var * nu / ((1 + nu) * (1 - 2 * nu))
# strain energy density, total potential energy
psi = (mu / 2) * (ic - 3) - mu * ln(j) + (lmbda / 2) * (ln(j)) ** 2
pi = psi * dx - self.time * dot(self.f, u) * self.ds(3)
ff = derivative(pi, u, v) # compute first variation of pi
jj = derivative(ff, u, du) # compute jacobian of f
# solving
if x is not None:
numeric_evals = np.zeros(shape=(x.shape[1], len(self.times)))
evals = np.zeros(shape=(x.shape[1], len(self.eval_times)))
else:
numeric_evals = None
evals = None
for it, t in enumerate(self.times):
self.time.t = t
self.solver(ff == 0, u, self.bcs, J=jj, bcs=self.bcs, solver_parameters=self.solver_parameters)
if x is not None:
numeric_evals[:, it] = np.log(np.array([-u(x_)[2] for x_ in x.T]).T)
# time-interpolation
if x is not None:
for i in range(evals.shape[0]):
evals[i, :] = np.interp(self.eval_times, self.times, numeric_evals[i, :])
return (evals, u) if x is not None else u
def sigma(u):
return lambda_ * nabla_div(u) * Identity(dim) + 2 * mu * epsilon(u)
def F_(U):
I = Identity(U.ufl_shape[0])
return (I + grad(U))
def ab_on_F(d_, w_, k):
F1 = grad(1.5 * d_["n-1"] - 0.5 * d_["n-2"]) - Identity(2)
F2 = 0.5 * grad(d_["n"] + d_["n-1"])
E = F1.T * F2 - I
return 0.5 * E