def __call__(self, eps):
I1 = df.tr(eps)
J2 = 0.5 * df.tr(df.dot(eps, eps)) - 1.0 / 6.0 * df.tr(eps) * df.tr(eps)
A = (self.T2 * I1) ** 2 + self.T3 * J2
A_pos = max(A, 1.0e-14)
return self.T1 * I1 + df.sqrt(A_pos) / (2.0 * self.k)
def flux_derivative(self, u, coeff):
"""First derivative of flux."""
lmbda, mu = coeff
Du = self.differential_op(u)
I = Identity(u.cell().d)
Dsigma = 2.0 * mu * div(Du) + dot(nabla_grad(lmbda), tr(Du) * I)
if element_degree(u) >= 2:
Dsigma += lmbda * div(tr(Du) * I)
return Dsigma
def strain_energy(self, F_):
F = self.Fe(F_)
E = kinematics.GreenLagrangeStrain(F, isochoric=self.isochoric)
W = self.lmbda / 2 * (dolfin.tr(E)**2) + self.mu * dolfin.tr(E * E)
# Active stress
Wactive = self.Wactive(F, diff=0)
return W + Wactive
def __init__(self, u):
'''Deformation measures.'''
self.d = d = len(u)
self.I = I = Identity(d)
self.F = F = variable(I + grad(u))
self.C = C = F.T * F
self.E = 0.5 * (C - I)
self.J = det(F)
self.I1 = tr(C)
self.I2 = 0.5 * (tr(C)**2 - tr(C * C))
self.I3 = det(C)
def strain_energy(self, F_):
F = self.Fe(F_)
dim = get_dimesion(F)
gradu = F - dolfin.Identity(dim)
epsilon = 0.5 * (gradu + gradu.T)
W = self.lmbda / 2 * (dolfin.tr(epsilon)**2) + self.mu * dolfin.tr(
epsilon * epsilon, )
# Active stress
Wactive = self.Wactive(F, diff=0)
return W + Wactive
def _get_zero_form(block_function_space, index):
zero = Constant(0.)
assert len(index) in (1, 2)
if len(index) == 2:
test = TestFunction(block_function_space[0][index[0]],
block_function_space=block_function_space[0],
block_index=index[0])
trial = TrialFunction(block_function_space[1][index[1]],
block_function_space=block_function_space[1],
block_index=index[1])
len_test_shape = len(test.ufl_shape)
len_trial_shape = len(trial.ufl_shape)
assert len_test_shape in (0, 1, 2)
assert len_trial_shape in (0, 1, 2)
if len_test_shape == 0 and len_trial_shape == 0:
return zero * test * trial * dx
elif len_test_shape == 0 and len_trial_shape == 1:
return zero * test * _vec_sum(trial) * dx
elif len_test_shape == 0 and len_trial_shape == 2:
return zero * test * tr(trial) * dx
elif len_test_shape == 1 and len_trial_shape == 0:
return zero * _vec_sum(test) * trial * dx
elif len_test_shape == 1 and len_trial_shape == 1:
return zero * inner(test, trial) * dx
elif len_test_shape == 1 and len_trial_shape == 2:
return zero * _vec_sum(test) * tr(trial) * dx
elif len_test_shape == 2 and len_trial_shape == 0:
return zero * tr(test) * trial * dx
elif len_test_shape == 2 and len_trial_shape == 1:
return zero * tr(test) * _vec_sum(trial) * dx
elif len_test_shape == 2 and len_trial_shape == 2:
return zero * inner(test, trial) * dx
else:
raise AssertionError("Invalid case in _get_zero_form.")
else:
test = TestFunction(block_function_space[0][index[0]],
block_function_space=block_function_space[0],
block_index=index[0])
len_test_shape = len(test.ufl_shape)
assert len_test_shape in (0, 1, 2)
if len_test_shape == 0:
return zero * test * dx
elif len_test_shape == 1:
return zero * _vec_sum(test) * dx
elif len_test_shape == 2:
return zero * tr(test) * dx
else:
raise AssertionError("Invalid case in _get_zero_form.")
def dw_int(self, u, v):
"""
Construct internal energy.
Parameters
----------
u: TrialFunction
v: TestFunction
"""
# u TrialFunction (only in the linear case)
assert isinstance(u, dlfn.function.argument.Argument)
# v TestFunction
assert isinstance(v, dlfn.function.argument.Argument)
assert hasattr(self, "_elastic_ratio")
assert hasattr(self, "_I")
def sym_grad(w):
return dlfn.Constant(0.5) * (grad(w).T + grad(w))
sigma = self._elastic_ratio * dlfn.tr(sym_grad(u)) * self._I \
+ dlfn.Constant(2.0) * sym_grad(u)
return inner(sigma, sym_grad(v))
def Wactive_transversally(Ta, C, f0, eta=0.0):
"""
Return active strain energy when activation is only
working along the fibers, with a possible transverse
component defined by eta
Arguments
---------
Ta : dolfin.Function or dolfin.Constant
A scalar function representng the mangnitude of the
active stress in the reference configuration (firt Pioala)
C : ufl.Form
The right Cauchy-Green deformation tensor
f0 : dolfin.Function
A vector function representng the direction of the
active stress
eta : float
Amount of active stress in the transverse direction
(relative to f0)
"""
I4f = dolfin.inner(C * f0, f0)
I1 = dolfin.tr(C)
return dolfin.Constant(0.5) * Ta * ((I4f - 1) + eta * ((I1 - 3) -
(I4f - 1)))
def get_residual_form(u, v, rho_e, method='RAMP'):
df.dx = df.dx(metadata={"quadrature_degree": 4})
# stiffness = rho_e/(1 + 8. * (1. - rho_e))
if method == 'SIMP':
stiffness = rho_e**3
else: #RAMP
stiffness = rho_e / (1 + 8. * (1. - rho_e))
# print('the value of stiffness is:', rho_e.vector().get_local())
# Kinematics
k = 3e1
E = k * stiffness
nu = 0.3
mu, lmbda = (E / (2 * (1 + nu))), (E * nu / ((1 + nu) * (1 - 2 * nu)))
d = len(u)
I = df.Identity(d) # Identity tensor
F = I + df.grad(u) # Deformation gradient
C = F.T * F # Right Cauchy-Green tensor
E_ = 0.5 * (C - I) # Green--Lagrange strain
S = 2.0 * mu * E_ + lmbda * df.tr(E_) * df.Identity(
d) # stress tensor (C:eps)
psi = 0.5 * df.inner(S, E_) # 0.5*eps:C:eps
# Total potential energy
Pi = psi * df.dx
# Solve weak problem obtained by differentiating Pi:
res = df.derivative(Pi, u, v)
return res
def get_residual_form(u, v, rho_e, Th, k=199.5e9, alpha=15.4e-6):
C = rho_e / (1 + 8. * (1. - rho_e))
E = k * C # C is the design variable, its values is from 0 to 1
nu = 0.3 # Poisson's ratio
Th = Th - df.Constant(20.)
Th = 0.
lambda_ = E * nu / (1. + nu) / (1 - 2 * nu)
mu = E / 2 / (1 + nu) #lame's parameters
# Th = df.Constant(7)
w_ij = 0.5 * (df.grad(u) + df.grad(u).T)
v_ij = 0.5 * (df.grad(v) + df.grad(v).T)
d = len(u)
sigm = (lambda_ * df.tr(w_ij) - alpha *
(3. * lambda_ + 2. * mu) * Th) * df.Identity(d) + 2 * mu * w_ij
a = df.inner(sigm, v_ij) * df.dx
return a
def dw_int(self, u, v):
"""
Construct internal energy.
Parameters
----------
u: Function
v: TestFunction
"""
# u Function (in the nonlinear case)
assert isinstance(u, dlfn.function.function.Function)
# v TestFunction
assert isinstance(v, dlfn.function.argument.Argument)
assert hasattr(self, "_elastic_ratio")
assert hasattr(self, "_I")
# deformation gradient
F = self._I + grad(u)
# right Cauchy-Green tensor
C = F.T * F
# strain
E = dlfn.Constant(0.5) * (C - self._I)
# 2. Piola-Kirchhoff stress
S = self._elastic_ratio * dlfn.tr(E) * self._I \
+ dlfn.Constant(2.0) * E
dE = dlfn.Constant(0.5) * (F.T * grad(v) + grad(v).T * F)
return inner(S, dE)
def neumann_elasticity_data():
'''
Return:
a bilinear form in the neumann elasticity problem
L linear form in therein
V function space, where a, L are defined
bc homog. dirichlet conditions for case where we want pos. def problem
z list of orthonormal vectors in the nullspace of A that form basis
of ker(A)
'''
mesh = UnitSquareMesh(40, 40)
V = VectorFunctionSpace(mesh, 'CG', 1)
u = TrialFunction(V)
v = TestFunction(V)
f = Expression(('sin(pi*x[0])', 'cos(pi*x[1])'))
epsilon = lambda u: sym(grad(u))
# Material properties
E, nu = 10.0, 0.3
mu, lmbda = Constant(E/(2*(1 + nu))), Constant(E*nu/((1 + nu)*(1 - 2*nu)))
sigma = lambda u: 2*mu*epsilon(u) + lmbda*tr(epsilon(u))*Identity(2)
a = inner(sigma(u), epsilon(v))*dx
L = inner(f, v)*dx # Zero stress
bc = DirichletBC(V, Constant((0, 0)), DomainBoundary())
z0 = interpolate(Constant((1, 0)), V).vector()
normalize(z0, 'l2')
z1 = interpolate(Constant((0, 1)), V).vector()
normalize(z1, 'l2')
X = mesh.coordinates().reshape((-1, 2))
c0, c1 = np.sum(X, axis=0)/len(X)
z2 = interpolate(Expression(('x[1]-c1',
'-(x[0]-c0)'), c0=c0, c1=c1), V).vector()
normalize(z2, 'l2')
z = [z0, z1, z2]
# Check that this is orthonormal basis
I = np.zeros((3, 3))
for i, zi in enumerate(z):
for j, zj in enumerate(z):
I[i, j] = zi.inner(zj)
print I
print la.norm(I-np.eye(3))
assert la.norm(I-np.eye(3)) < 1E-13
return a, L, V, bc, z
def cal_neoHookean(F, physParams):
"""
neoHookean elastic energy density: psi
"""
lmbda, mu = physParams.lmbda, physParams.mu
ln = dl.ln
J = dl.det(F)
Ic = dl.tr(F.T * F) # Invariants of deformation tensors
return (lmbda / 4) * (J**2 - 2 * ln(J) - 1) + (mu / 2) * (Ic -
2) - mu * ln(J)
def les_setup(u_, mesh, Wale, bcs, CG1Function, nut_krylov_solver, **NS_namespace):
"""Set up for solving Wale LES model
"""
DG = FunctionSpace(mesh, "DG", 0)
CG1 = FunctionSpace(mesh, "CG", 1)
delta = Function(DG)
delta.vector().zero()
delta.vector().axpy(1.0, assemble(TestFunction(DG)*dx))
Gij = grad(u_)
Sij = sym(Gij)
Skk = tr(Sij)
dim = mesh.geometry().dim()
Sd = sym(Gij*Gij) - 1./3.*Identity(mesh.geometry().dim())*Skk*Skk
nut_form = Wale['Cw']**2 * pow(delta, 2./dim) * pow(inner(Sd, Sd), 1.5) / (Max(pow(inner(Sij, Sij), 2.5) + pow(inner(Sd, Sd), 1.25), 1e-6))
ff = FacetFunction("size_t", mesh, 0)
bcs_nut = derived_bcs(CG1, bcs['u0'], u_)
nut_ = CG1Function(nut_form, mesh, method=nut_krylov_solver, bcs=bcs_nut, name='nut', bounded=True)
return dict(Sij=Sij, Sd=Sd, Skk=Skk, nut_=nut_, delta=delta, bcs_nut=bcs_nut)
def les_setup(u_, mesh, Wale, bcs, CG1Function, nut_krylov_solver, **NS_namespace):
"""Set up for solving Wale LES model
"""
DG = FunctionSpace(mesh, "DG", 0)
CG1 = FunctionSpace(mesh, "CG", 1)
# Compute cell size and put in delta
delta = Function(DG)
delta.vector().zero()
delta.vector().axpy(1.0, assemble(TestFunction(DG)*dx))
# Set up Wale form
Gij = grad(u_)
Sij = sym(Gij)
Skk = tr(Sij)
dim = mesh.geometry().dim()
Sd = sym(Gij*Gij) - 1./3.*Identity(mesh.geometry().dim())*Skk*Skk
nut_form = Wale['Cw']**2 * pow(delta, 2./dim) * pow(inner(Sd, Sd), 1.5) / (Max(pow(inner(Sij, Sij), 2.5) + pow(inner(Sd, Sd), 1.25), 1e-6))
ff = FacetFunction("size_t", mesh, 0)
bcs_nut = derived_bcs(CG1, bcs['u0'], u_)
nut_ = CG1Function(nut_form, mesh, method=nut_krylov_solver, bcs=bcs_nut, name='nut', bounded=True)
return dict(Sij=Sij, Sd=Sd, Skk=Skk, nut_=nut_, delta=delta, bcs_nut=bcs_nut)
def initialize_with_field(self, u):
super().initialize_with_field(u)
I = Identity(len(u))
eps = sym(grad(u))
for m in self.material_parameters:
E = m.get('E', None)
nu = m.get('nu', None)
mu = m.get('mu', None)
lm = m.get('lm', None)
if mu is None:
if E is None or nu is None:
raise RuntimeError(
'Material model requires parameter "mu"; '
'otherwise, require parameters "E" and "nu".')
mu = E / (2 * (1 + nu))
if lm is None:
if E is None or nu is None:
raise RuntimeError(
'Material model requires parameter "lm"; '
'otherwise, require parameters "E" and "nu".')
lm = E * nu / ((1 + nu) * (1 - 2 * nu))
sig = 2 * mu * eps + lm * tr(eps) * I
psi = 0.5 * inner(sig, eps)
self.psi.append(psi)
self.pk1.append(sig)
self.pk2.append(sig)
def stress_strain(eps):
return lambda_*dolfin.tr(eps)*I2+2*mu*eps
def sigma(v):
return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(
grad(v))) * Identity(2)
def STVK(U, alfa_mu, alfa_lam):
return alfa_lam * tr(eps(U)) * Identity(
len(U)) + 2.0 * alfa_mu * eps(U)
def __init__(self, mesh):
self.mesh = mesh
# Write mesh to file (for debugging only)
# write_mesh(self.mesh, '/tmp/meshfromslicer.vtu')
# define function space
element_degree = 1
quadrature_degree = element_degree + 1
print("Degree of element: ", element_degree)
print("Degree of quadrature: ", quadrature_degree)
self.V = dolfin.VectorFunctionSpace(self.mesh, "Lagrange",
element_degree)
# Mark boundary subdomains
zmin = min(self.mesh.coordinates()[:, 2])
zmax = max(self.mesh.coordinates()[:, 2])
print("zmin:", zmin)
print("zmax:", zmax)
bot = dolfin.CompiledSubDomain("near(x[2], side) && on_boundary",
side=zmin)
top = dolfin.CompiledSubDomain("near(x[2], side) && on_boundary",
side=zmax)
# Define Dirichlet boundary (z = 0 or z = 1)
c = dolfin.Constant((0.0, 0.0, 0.0))
self.r = dolfin.Expression((
"scale*(x0 + (x[0] - x0)*cos(theta) - (x[1] - y0)*sin(theta) - x[0])",
"scale*(y0 + (x[0] - x0)*sin(theta) + (x[1] - y0)*cos(theta) - x[1])",
"displacement"),
scale=1.0,
x0=0.5,
y0=0.5,
theta=0.0,
displacement=0.0,
degree=2)
self.bcs = [
dolfin.DirichletBC(self.V, c, bot),
dolfin.DirichletBC(self.V, self.r, top)
]
# Define functions
du = dolfin.TrialFunction(self.V) # Incremental displacement
v = dolfin.TestFunction(self.V) # Test function
# Displacement from previous iteration
self.u = dolfin.Function(self.V)
# Body force per unit volume
self.B = dolfin.Constant((0.0, 0.0, 0.0))
# Traction force on the boundary
self.T = dolfin.Constant((0.0, 0.0, 0.0))
# Kinematics
d = len(self.u)
I = dolfin.Identity(d) # Identity tensor
F = I + dolfin.grad(self.u) # Deformation gradient
C = F.T * F # Right Cauchy-Green tensor
# Invariants of deformation tensors
Ic = dolfin.tr(C)
J = dolfin.det(F)
# Elasticity parameters
E = 10.0
nu = 0.3
mu = dolfin.Constant(E / (2 * (1 + nu)))
lmbda = dolfin.Constant(E * nu / ((1 + nu) * (1 - 2 * nu)))
# Stored strain energy density (compressible neo-Hookean model)
psi = (mu / 2) * (Ic - 3) - mu * dolfin.ln(J) + (lmbda /
2) * (dolfin.ln(J))**2
dx = dolfin.Measure("dx",
domain=mesh,
metadata={'quadrature_degree': quadrature_degree})
ds = dolfin.Measure("ds",
domain=mesh,
metadata={'quadrature_degree': quadrature_degree})
print(dx)
print(ds)
Pi = psi*dx - dolfin.dot(self.B, self.u)*dx - \
dolfin.dot(self.T, self.u)*ds
self.F = dolfin.derivative(Pi, self.u, v)
self.J = dolfin.derivative(self.F, self.u, du)
def stress(eps, lamb, mu):
return lamb * dolfin.tr(eps) * dolfin.Identity(
mesh.geometric_dimension()) + 2 * mu * eps
def get_residual_form(u,
v,
rho_e,
V_density,
tractionBC,
T,
iteration_number,
additive='strain',
k=8.,
method='RAMP'):
df.dx = df.dx(metadata={"quadrature_degree": 4})
# stiffness = rho_e/(1 + 8. * (1. - rho_e))
if method == 'SIMP':
stiffness = rho_e**3
else:
stiffness = rho_e / (1 + 8. * (1. - rho_e))
# print('the value of stiffness is:', rho_e.vector().get_local())
# Kinematics
d = len(u)
I = df.Identity(d) # Identity tensor
F = I + df.grad(u) # Deformation gradient
C = F.T * F # Right Cauchy-Green tensor
# Invariants of deformation tensors
Ic = df.tr(C)
J = df.det(F)
stiffen_pow = 1.
threshold_vol = 1.
eps_star = 0.05
# print("eps_star--------")
if additive == 'strain':
print("additive == strain")
if iteration_number == 1:
print('iteration_number == 1')
eps = df.sym(df.grad(u))
eps_dev = eps - 1 / 3 * df.tr(eps) * df.Identity(2)
eps_eq = df.sqrt(2.0 / 3.0 * df.inner(eps_dev, eps_dev))
# eps_eq_proj = df.project(eps_eq, density_function_space)
ratio = eps_eq / eps_star
ratio_proj = df.project(ratio, V_density)
c1_e = k * (5.e-2) / (1 + 8. * (1. - (5.e-2))) / 6
c2_e = df.Function(V_density)
c2_e.vector().set_local(5e-4 * np.ones(V_density.dim()))
fFile = df.HDF5File(df.MPI.comm_world, "c2_e_proj.h5", "w")
fFile.write(c2_e, "/f")
fFile.close()
fFile = df.HDF5File(df.MPI.comm_world, "ratio_proj.h5", "w")
fFile.write(ratio_proj, "/f")
fFile.close()
iteration_number += 1
E = k * stiffness
phi_add = (1 - stiffness) * ((c1_e * (Ic - 3)) + (c2_e *
(Ic - 3))**2)
else:
ratio_proj = df.Function(V_density)
fFile = df.HDF5File(df.MPI.comm_world, "ratio_proj.h5", "r")
fFile.read(ratio_proj, "/f")
fFile.close()
c2_e = df.Function(V_density)
fFile = df.HDF5File(df.MPI.comm_world, "c2_e_proj.h5", "r")
fFile.read(c2_e, "/f")
fFile.close()
c1_e = k * (5.e-2) / (1 + 8. * (1. - (5.e-2))) / 6
c2_e = df.conditional(df.le(ratio_proj, eps_star),
c2_e * df.sqrt(ratio_proj),
c2_e * (ratio_proj**3))
phi_add = (1 - stiffness) * ((c1_e * (Ic - 3)) + (c2_e *
(Ic - 3))**2)
E = k * stiffness
c2_e_proj = df.project(c2_e, V_density)
print('c2_e projected -------------')
eps = df.sym(df.grad(u))
eps_dev = eps - 1 / 3 * df.tr(eps) * df.Identity(2)
eps_eq = df.sqrt(2.0 / 3.0 * df.inner(eps_dev, eps_dev))
# eps_eq_proj = df.project(eps_eq, V_density)
ratio = eps_eq / eps_star
ratio_proj = df.project(ratio, V_density)
fFile = df.HDF5File(df.MPI.comm_world, "c2_e_proj.h5", "w")
fFile.write(c2_e_proj, "/f")
fFile.close()
fFile = df.HDF5File(df.MPI.comm_world, "ratio_proj.h5", "w")
fFile.write(ratio_proj, "/f")
fFile.close()
elif additive == 'vol':
print("additive == vol")
stiffness = stiffness / (df.det(F)**stiffen_pow)
# stiffness = df.conditional(df.le(df.det(F),threshold_vol), (stiffness/(df.det(F)/threshold_vol))**stiffen_pow, stiffness)
E = k * stiffness
elif additive == 'False':
print("additive == False")
E = k * stiffness # rho_e is the design variable, its values is from 0 to 1
nu = 0.4 # Poisson's ratio
lambda_ = E * nu / (1. + nu) / (1 - 2 * nu)
mu = E / 2 / (1 + nu) #lame's parameters
# Stored strain energy density (compressible neo-Hookean model)
psi = (mu / 2) * (Ic - 3) - mu * df.ln(J) + (lambda_ / 2) * (df.ln(J))**2
# print('the length of psi is:',len(psi.vector()))
if additive == 'strain':
psi += phi_add
B = df.Constant((0.0, 0.0))
# Total potential energy
'''The first term in this equation provided this error'''
Pi = psi * df.dx - df.dot(B, u) * df.dx - df.dot(T, u) * tractionBC
res = df.derivative(Pi, u, v)
return res
def _I1(self, F):
C = RightCauchyGreen(F, self._isochoric)
I1 = tr(C)
return I1
def flux(self, u, coeff):
lmbda, mu = coeff
Du = self.differential_op(u)
I = Identity(u.cell().d)
return 2.0 * mu * Du + lmbda * tr(Du) * I
bcs.append(DirichletBC(Vz, zero, fixed_vertex_010, "pointwise"))
### Define hyperelastic material model
material_parameters = {'E': Constant(1.0), 'nu': Constant(0.0)}
E, nu = material_parameters.values()
d = len(u) # Displacement dimension
I = dolfin.Identity(d)
F = dolfin.variable(I + dolfin.grad(u))
C = F.T * F
J = dolfin.det(F)
I1 = dolfin.tr(C)
# Lame material parameters
lm = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
mu = E / (2.0 + 2.0 * nu)
# Energy density of a Neo-Hookean material model
psi = (mu / 2.0) * (I1 - d - 2.0 * dolfin.ln(J)) + (lm / 2.0) * dolfin.ln(J)**2
# First Piola-Kirchhoff
pk1 = dolfin.diff(psi, F)
# Boundary traction
N = dolfin.FacetNormal(mesh)
PN = dolfin.dot(pk1, N)
def _I2(self, F):
C = RightCauchyGreen(F, self._isochoric)
return 0.5 * (self._I1(F) * self._I1(F) - tr(C * C))
def I2(F, isochoric=False):
C = RightCauchyGreen(F, isochoric)
return 0.5 * (I1(F) * I1(F) - tr(C * C))
def I1(F, isochoric=False):
C = RightCauchyGreen(F, isochoric)
I1 = tr(C)
return I1
def sigma(v):
return lmbda * fe.tr(eps(v)) * fe.Identity(2) + 2.0 * mu * eps(v)
def S(U, lamda_s, mu_s):
I = Identity(len(U))
return 2 * mu_s * E(U) + lamda_s * tr(E(U)) * I
## Next make a function space
V = d.VectorFunctionSpace(mesh, 'Lagrange', 1)
# Create a test function and a trial function, and a source term:
u = d.TrialFunction(V)
w = d.TestFunction(V)
b = d.Constant((1.0,0.,0.))
# Elasticity parameters:
E, nu = 10., 0.3
mu, lambda_param = E / (2. * (1.+nu)), E * nu / ((1. + nu) * (1.-2. * nu))
# Stress tensor:
# + usually of form \sigma_{ij} = \lambda e_{kk}\delta_{ij} + 2\mu e_{ij},
# + or = \lambda Tr(e_{ij})I + 2\mu e_{ij}, for e_{ij} the strain tensor.
sigma = lambda_param*d.tr(d.grad(u)) * d.Identity(w.cell().d) + 2 * mu * d.sym(d.grad(u))
# Governing balance equation:
F = d.inner(sigma, d.grad(w)) * d.dx - d.dot(b,w)*d.dx
# Extract the bi- and linear forms from F:
a = d.lhs(F)
L = d.rhs(F)
# Dirichlet BC on entire boundary:
c = d.Constant((0.,0.,0.))
bc = d.DirichletBC(V, c, d.DomainBoundary())
## Testing some new boundary definitions:
def bzo_boundary(r_vec, on_boundary):
# Th = df.Constant(7)
I = df.Identity(len(displacements_function))
# w_ij = 0.5 * (df.grad(displacements_function) + df.grad(displacements_function).T) - ALPHA * I * temperature_function
# sigm = lambda_*df.div(displacements_function)* I + 2*mu*w_ij
# s = sigm - (1./3)*df.tr(sigm)*I
# von_Mises = df.sqrt(3./2*df.inner(s, s))
# von_Mises_form = (1/df.CellVolume(mesh)) * von_Mises * df.TestFunction(density_function_space) * df.dx
# T = df.TensorFunctionSpace(mesh, "CG", 1)
# T.vector.set_local()
T_00 = df.Constant(20)
w_ij = 0.5 * (df.grad(displacements_function) + df.grad(
displacements_function).T) - C * ALPHA * I * (temperature_function - T_00)
sigm = lambda_ * df.div(displacements_function) * I + 2 * mu * w_ij
s = sigm - (1. / 3) * df.tr(sigm) * I
scalar_ = 5e8
# scalar_ = 5e5
von_Mises = df.sqrt(3. / 2 * df.inner(s / scalar_, s / scalar_))
von_Mises_form = (1 / df.CellVolume(mesh)) * von_Mises * df.TestFunction(
density_function_space) * df.dx
# von_Mises_form = von_Mises * df.TestFunction(density_function_space) /volume * df.dx
pde_problem.add_field_output('von_Mises', von_Mises_form, 'mixed_states',
'density')
x
'''
4. 3. Add bcs
'''
bc_displacements = df.DirichletBC(
def sigma(self):
eps, E, nu = self.eps(), self.mat.E, self.mat.nu
lmbda = E * nu / (1.0 + nu) / (1.0 - 2.0 * nu)
mu = E / 2.0 / (1.0 + nu)
return 2 * mu * eps + lmbda * df.tr(eps) * df.Identity(self.mesh.geometric_dimension())
def stress_strain(eps, lambda_, mu):
I = dolfin.Identity(DIM)
return lambda_ * dolfin.tr(eps) * I + 2 * mu * eps
def sigma(self, uu): return 2.*self.mu*self.epsilon(uu) + self.ll*dolfin.tr(self.epsilon(uu))*dolfin.Identity(self.basedim)
