def extrapolate_setup(extype, mesh_file, d, w, phi, dx_f, d_,
**semimp_namespace):
alpha = 1. / det(Identity(len(d_["n"])) + grad(d_["n"]))
F_extrapolate = alpha*inner(grad(d), grad(phi))*dx_f \
- inner(Constant((0, 0)), phi)*dx_f
return dict(F_extrapolate=F_extrapolate)
def updateG(self, dt):
""" Update the G tensor of a tissue.
Args:
dt (:obj:`float`): Timestep
"""
self.tissue.G.project(
(self.initial * dt + Identity(3)) * self.tissue.G)
def compute(self, get):
u = get("Velocity")
p = get("Pressure")
mu = get("DynamicViscosity")
if isinstance(mu, (float, int)):
mu = Constant(mu)
expr = mu * (grad(u) + grad(u).T) - p * Identity(len(u))
return self.expr2function(expr, self._function)
def projectAGG(self,
a=Constant(0.0),
g=Constant(0.0),
gamma=Constant([0, 0, 1])):
""" Calculate and project growth function from given :math:`a`, :math:`g` and :math:`\gamma` values
"""
self.a.project(a)
self.g.project(g)
self.gamma.project(gamma / sqrt(inner(gamma, gamma)))
g0 = g * (1 - a)
g1 = g * (1 + 2 * a)
self.project(Identity(3) * g0 + (g1 - g0) * outer(gamma, gamma))
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 set_model(self):
measures = [self.dx, self.ds, self.dS]
# import pdb; pdb.set_trace()
if self.parameters['material']['p'] == 'zero':
from plate_lib import ActuationOverNematicFoundation
actuation = ActuationOverNematicFoundation(self.z, self.mesh,
self.parameters,
measures)
elif self.parameters['material']['p'] == 'neg':
from plate_lib import ActuationOverNematicFoundationPneg
actuation = ActuationOverNematicFoundationPneg(
self.z, self.mesh, self.parameters, measures)
else:
raise NotImplementedError
x = Expression(['x[0]', 'x[1]', '0.'], degree=0)
self.load = Expression('s', s=1., degree=0)
e1 = Constant([1, 0, 0])
e3 = Constant([0, 0, 1])
# self.n = Expression('sin(theta)*_e1 + cos(theta)*_e3',
# _e1 = e1, _e3 = e3, theta = 0., degree = 0)
self.n = Expression(['sin(theta)', 0, 'cos(theta)'], theta=0, degree=0)
# import pdb; pdb.set_trace()
# print('Nematic: {}'.format(self.parameters["material"]["nematic"]))
if self.parameters["material"]["nematic"] == 'e1':
n = e1
elif self.parameters["material"]["nematic"] == 'e3':
n = e3
elif self.parameters["material"]["nematic"] == 'tilt':
n = (e1 - e3) / np.sqrt(2)
else:
raise NotImplementedError
Qn = outer(self.n, self.n) - 1. / 3. * Identity(3)
actuation.Q0n = self.load * Qn
self.Q0 = actuation.Q0n
actuation.define_variational_equation()
self.F = actuation.F
self.J = actuation.jacobian
self.energy_mem = actuation.energy_mem
self.energy_ben = actuation.energy_ben
self.energy_nem = actuation.energy_nem
self.work = actuation.work
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 __init__(self, mesh0=UnitCubeMesh(8, 8, 8), params={}):
parameters['form_compiler']['representation'] = 'uflacs'
parameters['form_compiler']['optimize'] = True
parameters['form_compiler']['quadrature_degree'] = 4
self.mesh0 = Mesh(mesh0)
self.mesh = Mesh(mesh0)
if not 'C1' in params:
params['C1'] = 100
self.params = params
self.b = Constant((0.0, 0.0, 0.0))
self.h = Constant((0.0, 0.0, 0.0))
self.C0 = FunctionSpace(self.mesh0, "Lagrange", 2)
self.V0 = VectorFunctionSpace(self.mesh0, "Lagrange", 1)
self.W0 = TensorFunctionSpace(self.mesh0, "Lagrange", 1)
self.C = FunctionSpace(self.mesh, "Lagrange", 2)
self.V = VectorFunctionSpace(self.mesh, "Lagrange", 1)
self.W = TensorFunctionSpace(self.mesh, "Lagrange", 1)
self.G = project(Identity(3), self.W0)
self.ut = Function(self.V0)
self.du = TestFunction(self.V0)
self.w = TrialFunction(self.V0)
self.n0 = FacetNormal(self.mesh0)
self.v = Function(self.V)
self.t = 0.0
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 sigma(u):
return lambda_ * div(u) * Identity(d) + 2 * mu * epsilon(u)
def initialization(mesh, subdomains, boundaries):
TM = TensorFunctionSpace(mesh, 'DG', 0)
PM = FunctionSpace(mesh, 'DG', 0)
UCG = VectorElement("CG", mesh.ufl_cell(), 2)
BDM = FiniteElement("BDM", mesh.ufl_cell(), 1)
PDG = FiniteElement("DG", mesh.ufl_cell(), 0)
UCG_F = FunctionSpace(mesh, UCG)
BDM_F = FunctionSpace(mesh, BDM)
PDG_F = FunctionSpace(mesh, PDG)
W = BlockFunctionSpace([BDM_F, PDG_F], restrict=[None, None])
U = BlockFunctionSpace([UCG_F])
I = Identity(mesh.topology().dim())
C_cg = FiniteElement("CG", mesh.ufl_cell(), 1)
C_dg = FiniteElement("DG", mesh.ufl_cell(), 0)
mini = C_cg + C_dg
C = FunctionSpace(mesh, mini)
C = BlockFunctionSpace([C])
#TODO
solution0_h = BlockFunction(W)
solution0_m = BlockFunction(U)
solution0_c = BlockFunction(C)
solution1_h = BlockFunction(W)
solution1_m = BlockFunction(U)
solution1_c = BlockFunction(C)
solution2_h = BlockFunction(W)
solution2_m = BlockFunction(U)
solution2_c = BlockFunction(C)
solution_h = BlockFunction(W)
solution_m = BlockFunction(U)
solution_c = BlockFunction(C)
## mechanics
# 0 properties
alpha1 = 0.74
K1 = 8.4 * 1000.e6
nu1 = 0.18
alpha2 = 0.74
K2 = 8.4 * 1000.e6
nu2 = 0.18
alpha_values = [alpha1, alpha2]
K_values = [K1, K2]
nu_values = [nu1, nu2]
alpha_0 = Function(PM)
K_0 = Function(PM)
nu_0 = Function(PM)
alpha_0 = init_scalar_parameter(alpha_0, alpha_values[0], 500, subdomains)
K_0 = init_scalar_parameter(K_0, K_values[0], 500, subdomains)
nu_0 = init_scalar_parameter(nu_0, nu_values[0], 500, subdomains)
alpha_0 = init_scalar_parameter(alpha_0, alpha_values[1], 501, subdomains)
K_0 = init_scalar_parameter(K_0, K_values[1], 501, subdomains)
nu_0 = init_scalar_parameter(nu_0, nu_values[1], 501, subdomains)
K_mult_min = 1.0
K_mult_max = 1.0
mu_l_0, lmbda_l_0, Ks_0, K_0 = \
bulk_modulus_update(mesh,solution0_c[0],K_mult_min,K_mult_max,K_0,nu_0,alpha_0,K_0)
# n-1 properties
alpha1 = 0.74
K1 = 8.4 * 1000.e6
nu1 = 0.18
alpha2 = 0.74
K2 = 8.4 * 1000.e6
nu2 = 0.18
alpha_values = [alpha1, alpha2]
K_values = [K1, K2]
nu_values = [nu1, nu2]
alpha_1 = Function(PM)
K_1 = Function(PM)
nu_1 = Function(PM)
alpha_1 = init_scalar_parameter(alpha_1, alpha_values[0], 500, subdomains)
K_1 = init_scalar_parameter(K_1, K_values[0], 500, subdomains)
nu_1 = init_scalar_parameter(nu_1, nu_values[0], 500, subdomains)
alpha_1 = init_scalar_parameter(alpha_1, alpha_values[1], 501, subdomains)
K_1 = init_scalar_parameter(K_1, K_values[1], 501, subdomains)
nu_1 = init_scalar_parameter(nu_1, nu_values[1], 501, subdomains)
K_mult_min = 1.0
K_mult_max = 1.0
mu_l_1, lmbda_l_1, Ks_1, K_1 = \
bulk_modulus_update(mesh,solution0_c[0],K_mult_min,K_mult_max,K_1,nu_1,alpha_1,K_0)
# n properties
alpha1 = 0.74
K2 = 8.4 * 1000.e6
nu1 = 0.18
alpha2 = 0.74
K2 = 8.4 * 1000.e6
nu2 = 0.18
alpha_values = [alpha1, alpha2]
K_values = [K1, K2]
nu_values = [nu1, nu2]
alpha = Function(PM)
K = Function(PM)
nu = Function(PM)
alpha = init_scalar_parameter(alpha, alpha_values[0], 500, subdomains)
K = init_scalar_parameter(K, K_values[0], 500, subdomains)
nu = init_scalar_parameter(nu, nu_values[0], 500, subdomains)
alpha = init_scalar_parameter(alpha, alpha_values[1], 501, subdomains)
K = init_scalar_parameter(K, K_values[1], 501, subdomains)
nu = init_scalar_parameter(nu, nu_values[1], 501, subdomains)
K_mult_min = 1.0
K_mult_max = 1.0
mu_l, lmbda_l, Ks, K = \
bulk_modulus_update(mesh,solution0_c[0],K_mult_min,K_mult_max,K,nu,alpha,K_0)
## flow
# 0 properties
cf1 = 1e-10
phi1 = 0.2
rho1 = 1000.0
mu1 = 1.
kx = 8.802589710965712e-10
ky = 8.802589710965712e-11
k1 = np.array([kx, 0., 0., ky])
cf2 = 1e-10
phi2 = 0.2
rho2 = 1000.0
mu2 = 1.
kx = 8.802589710965712e-10
ky = 8.802589710965712e-11
k2 = np.array([kx, 0., 0., ky])
cf_values = [cf1, cf2]
phi_values = [phi1, phi2]
rho_values = [rho1, rho2]
mu_values = [mu1, mu2]
k_values = [k1, k2]
cf_0 = Function(PM)
phi_0 = Function(PM)
rho_0 = Function(PM)
mu_0 = Function(PM)
k_0 = Function(TM)
cf_0 = init_scalar_parameter(cf_0, cf_values[0], 500, subdomains)
phi_0 = init_scalar_parameter(phi_0, phi_values[0], 500, subdomains)
rho_0 = init_scalar_parameter(rho_0, rho_values[0], 500, subdomains)
mu_0 = init_scalar_parameter(mu_0, mu_values[0], 500, subdomains)
k_0 = init_tensor_parameter(k_0, k_values[0], 500, subdomains,
mesh.topology().dim())
cf_0 = init_scalar_parameter(cf_0, cf_values[1], 501, subdomains)
phi_0 = init_scalar_parameter(phi_0, phi_values[1], 501, subdomains)
rho_0 = init_scalar_parameter(rho_0, rho_values[1], 501, subdomains)
mu_0 = init_scalar_parameter(mu_0, mu_values[1], 501, subdomains)
k_0 = init_tensor_parameter(k_0, k_values[1], 501, subdomains,
mesh.topology().dim())
#filename = "perm4.csv"
#k_0 = init_from_file_parameter(k_0,0.,0.,filename)
# n-1 properties
cf1 = 1e-10
phi1 = 0.2
rho1 = 1000.0
mu1 = 1.
kx = 8.802589710965712e-10
ky = 8.802589710965712e-11
k1 = np.array([kx, 0., 0., ky])
cf2 = 1e-10
phi2 = 0.2
rho2 = 1000.0
mu2 = 1.
kx = 8.802589710965712e-10
ky = 8.802589710965712e-11
k2 = np.array([kx, 0., 0., ky])
cf_values = [cf1, cf2]
phi_values = [phi1, phi2]
rho_values = [rho1, rho2]
mu_values = [mu1, mu2]
k_values = [k1, k2]
cf_1 = Function(PM)
phi_1 = Function(PM)
rho_1 = Function(PM)
mu_1 = Function(PM)
k_1 = Function(TM)
cf_1 = init_scalar_parameter(cf_1, cf_values[0], 500, subdomains)
phi_1 = init_scalar_parameter(phi_1, phi_values[0], 500, subdomains)
rho_1 = init_scalar_parameter(rho_1, rho_values[0], 500, subdomains)
mu_1 = init_scalar_parameter(mu_1, mu_values[0], 500, subdomains)
k_1 = init_tensor_parameter(k_1, k_values[0], 500, subdomains,
mesh.topology().dim())
cf_1 = init_scalar_parameter(cf_1, cf_values[1], 501, subdomains)
phi_1 = init_scalar_parameter(phi_1, phi_values[1], 501, subdomains)
rho_1 = init_scalar_parameter(rho_1, rho_values[1], 501, subdomains)
mu_1 = init_scalar_parameter(mu_1, mu_values[1], 501, subdomains)
k_1 = init_tensor_parameter(k_1, k_values[1], 501, subdomains,
mesh.topology().dim())
#filename = "perm4.csv"
#k_1 = init_from_file_parameter(k_1,0.,0.,filename)
# n properties
cf1 = 1e-10
phi1 = 0.2
rho1 = 1000.0
mu1 = 1.
kx = 8.802589710965712e-10
ky = 8.802589710965712e-11
k1 = np.array([kx, 0., 0., ky])
cf2 = 1e-10
phi2 = 0.2
rho2 = 1000.0
mu2 = 1.
kx = 8.802589710965712e-10
ky = 8.802589710965712e-11
k2 = np.array([kx, 0., 0., ky])
cf_values = [cf1, cf2]
phi_values = [phi1, phi2]
rho_values = [rho1, rho2]
mu_values = [mu1, mu2]
k_values = [k1, k2]
cf = Function(PM)
phi = Function(PM)
rho = Function(PM)
mu = Function(PM)
k = Function(TM)
cf = init_scalar_parameter(cf, cf_values[0], 500, subdomains)
phi = init_scalar_parameter(phi, phi_values[0], 500, subdomains)
rho = init_scalar_parameter(rho, rho_values[0], 500, subdomains)
mu = init_scalar_parameter(mu, mu_values[0], 500, subdomains)
k = init_tensor_parameter(k, k_values[0], 500, subdomains,
mesh.topology().dim())
cf = init_scalar_parameter(cf, cf_values[1], 501, subdomains)
phi = init_scalar_parameter(phi, phi_values[1], 501, subdomains)
rho = init_scalar_parameter(rho, rho_values[1], 501, subdomains)
mu = init_scalar_parameter(mu, mu_values[1], 501, subdomains)
k = init_tensor_parameter(k, k_values[1], 501, subdomains,
mesh.topology().dim())
#filename = "perm4.csv"
#k = init_from_file_parameter(k,0.,0.,filename)
### transport
# 0
dx1 = 1e-12
dy1 = 1e-12
d1 = np.array([dx1, 0., 0., dy1])
dx2 = 1e-12
dy2 = 1e-12
d2 = np.array([dx2, 0., 0., dy2])
d_values = [d1, d2]
d_0 = Function(TM)
d_0 = init_tensor_parameter(d_0, d_values[0], 500, subdomains,
mesh.topology().dim())
d_0 = init_tensor_parameter(d_0, d_values[1], 501, subdomains,
mesh.topology().dim())
# n-1
dx1 = 1e-12
dy1 = 1e-12
d1 = np.array([dx1, 0., 0., dy1])
dx2 = 1e-12
dy2 = 1e-12
d2 = np.array([dx2, 0., 0., dy2])
d_values = [d1, d2]
d_1 = Function(TM)
d_1 = init_tensor_parameter(d_1, d_values[0], 500, subdomains,
mesh.topology().dim())
d_1 = init_tensor_parameter(d_1, d_values[1], 501, subdomains,
mesh.topology().dim())
# n
dx1 = 1e-12
dy1 = 1e-12
d1 = np.array([dx1, 0., 0., dy1])
dx2 = 1e-12
dy2 = 1e-12
d2 = np.array([dx2, 0., 0., dy2])
d_values = [d1, d2]
d = Function(TM)
d = init_tensor_parameter(d, d_values[0], 500, subdomains,
mesh.topology().dim())
d = init_tensor_parameter(d, d_values[1], 501, subdomains,
mesh.topology().dim())
####initialization
# initial
u_0 = Constant((0.0, 0.0))
u_0_project = project(u_0, U[0])
assign(solution0_m.sub(0), u_0_project)
p_0 = Constant(1.e6)
p_0_project = project(p_0, W[1])
assign(solution0_h.sub(1), p_0_project)
# v_0 = Constant((0.0, 0.0))
# v_0_project = project(v_0, W[0])
# assign(solution0_h.sub(0), v_0_project)
c0 = c_sat_cal(1.e6, 20.)
c0_project = project(c0, C[0])
assign(solution0_c.sub(0), c0_project)
# n - 1
u_0 = Constant((0.0, 0.0))
u_0_project = project(u_0, U[0])
assign(solution1_m.sub(0), u_0_project)
p_0 = Constant(1.e6)
p_0_project = project(p_0, W[1])
assign(solution1_h.sub(1), p_0_project)
# v_0 = Constant((0.0, 0.0))
# v_0_project = project(v_0, W[0])
# assign(solution1_h.sub(0), v_0_project)
c0 = c_sat_cal(1.e6, 20.)
c0_project = project(c0, C[0])
assign(solution1_c.sub(0), c0_project)
# n - 2
u_0 = Constant((0.0, 0.0))
u_0_project = project(u_0, U[0])
assign(solution2_m.sub(0), u_0_project)
p_0 = Constant(1.e6)
p_0_project = project(p_0, W[1])
assign(solution2_h.sub(1), p_0_project)
# v_0 = Constant((0.0, 0.0))
# v_0_project = project(v_0, W[0])
# assign(solution2_h.sub(0), v_0_project)
c0 = c_sat_cal(1.e6, 20.)
c0_project = project(c0, C[0])
assign(solution2_c.sub(0), c0_project)
# n
u_0 = Constant((0.0, 0.0))
u_0_project = project(u_0, U[0])
assign(solution_m.sub(0), u_0_project)
p_0 = Constant(1.e6)
p_0_project = project(p_0, W[1])
assign(solution_h.sub(1), p_0_project)
# v_0 = Constant((0.0, 0.0))
# v_0_project = project(v_0, W[0])
# assign(solution_h.sub(0), v_0_project)
c0 = c_sat_cal(1.e6, 20.)
c0_project = project(c0, C[0])
assign(solution_c.sub(0), c0_project)
###iterative parameters
phi_it = Function(PM)
assign(phi_it, phi_0)
print('c_sat', c_sat_cal(1.0e8, 20.))
c_sat = c_sat_cal(1.0e8, 20.)
c_sat = project(c_sat, PM)
c_inject = Constant(0.0)
c_inject = project(c_inject, PM)
mu_c1_1 = 1.e-4
mu_c2_1 = 5.e-0
mu_c1_2 = 1.e-4
mu_c2_2 = 5.e-0
mu_c1_values = [mu_c1_1, mu_c1_2]
mu_c2_values = [mu_c2_1, mu_c2_2]
mu_c1 = Function(PM)
mu_c2 = Function(PM)
mu_c1 = init_scalar_parameter(mu_c1, mu_c1_values[0], 500, subdomains)
mu_c2 = init_scalar_parameter(mu_c2, mu_c2_values[0], 500, subdomains)
mu_c1 = init_scalar_parameter(mu_c1, mu_c1_values[1], 501, subdomains)
mu_c2 = init_scalar_parameter(mu_c2, mu_c2_values[1], 501, subdomains)
coeff_for_perm_1 = 22.2
coeff_for_perm_2 = 22.2
coeff_for_perm_values = [coeff_for_perm_1, coeff_for_perm_2]
coeff_for_perm = Function(PM)
coeff_for_perm = init_scalar_parameter(coeff_for_perm,
coeff_for_perm_values[0], 500,
subdomains)
coeff_for_perm = init_scalar_parameter(coeff_for_perm,
coeff_for_perm_values[1], 501,
subdomains)
solutionIt_h = BlockFunction(W)
return solution0_m, solution0_h, solution0_c \
,solution1_m, solution1_h, solution1_c \
,solution2_m, solution2_h, solution2_c \
,solution_m, solution_h, solution_c \
,alpha_0, K_0, mu_l_0, lmbda_l_0, Ks_0 \
,alpha_1, K_1, mu_l_1, lmbda_l_1, Ks_1 \
,alpha, K, mu_l, lmbda_l, Ks \
,cf_0, phi_0, rho_0, mu_0, k_0 \
,cf_1, phi_1, rho_1, mu_1, k_1 \
,cf, phi, rho, mu, k \
,d_0, d_1, d, I \
,phi_it, solutionIt_h, mu_c1, mu_c2 \
,nu_0, nu_1, nu, coeff_for_perm \
,c_sat, c_inject
def STVK(U, alfa_mu, alfa_lam):
return alfa_lam * tr(eps(U)) * Identity(
len(U)) + 2.0 * alfa_mu * eps(U)
def Extrapolate_setup(d, phi, dx_f, d_, **semimp_namespace):
alfa = 1. / det(Identity(len(d_["n"])) + grad(d_["n"]))
F_extrapolate = alfa*inner(grad(d), grad(phi))*dx_f - inner(Constant((0, 0)), phi)*dx_f
return dict(F_extrapolate=F_extrapolate)
def S(U, lamda_s, mu_s):
I = Identity(len(U))
return 2 * mu_s * E(U) + lamda_s * tr(E(U)) * I
def sigma_f(p, u, mu_f):
return -p * Identity(len(u)) + mu_f * (grad(u) + grad(u).T)
def sigma(u, p, mu):
# Define stress tensor
return 2*mu*epsilon(u) - p*Identity(len(u))
def SecondOrderIdentity(F):
"""Return identity with same dimension as input
"""
dim = get_dimesion(F)
return Identity(dim)
def sigma(v):
return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(
grad(v))) * Identity(2)
def sigma_f_p(p, u):
return -p * Identity(len(u))
def S(self):
C1 = self.params['C1']
return C1 * (self.A() - Identity(3))
def F(self):
return Identity(3) + grad(self.u + self.ut)
def m_linear(integrator_type, mesh, subdomains, boundaries, t_start, dt, T, solution0, \
alpha_0, K_0, mu_l_0, lmbda_l_0, Ks_0, \
alpha_1, K_1, mu_l_1, lmbda_l_1, Ks_1, \
alpha, K, mu_l, lmbda_l, Ks, \
cf_0, phi_0, rho_0, mu_0, k_0,\
cf_1, phi_1, rho_1, mu_1, k_1,\
cf, phi, rho, mu, k, \
pressure_freeze):
# Create mesh and define function space
parameters["ghost_mode"] = "shared_facet" # required by dS
dx = Measure('dx', domain=mesh, subdomain_data=subdomains)
ds = Measure('ds', domain=mesh, subdomain_data=boundaries)
dS = Measure('dS', domain=mesh, subdomain_data=boundaries)
C = VectorFunctionSpace(mesh, "CG", 2)
C = BlockFunctionSpace([C])
TM = TensorFunctionSpace(mesh, 'DG', 0)
PM = FunctionSpace(mesh, 'DG', 0)
n = FacetNormal(mesh)
vc = CellVolume(mesh)
fc = FacetArea(mesh)
h = vc/fc
h_avg = (vc('+') + vc('-'))/(2*avg(fc))
monitor_dt = dt
f_stress_x = Constant(-1.e3)
f_stress_y = Constant(-20.0e6)
f = Constant((0.0, 0.0)) #sink/source for displacement
I = Identity(mesh.topology().dim())
# Define variational problem
psiu, = BlockTestFunction(C)
block_u = BlockTrialFunction(C)
u, = block_split(block_u)
w = BlockFunction(C)
theta = -1.0
a_time = inner(-alpha*pressure_freeze*I,sym(grad(psiu)))*dx #quasi static
a = inner(2*mu_l*strain(u)+lmbda_l*div(u)*I, sym(grad(psiu)))*dx
rhs_a = inner(f,psiu)*dx \
+ dot(f_stress_y*n,psiu)*ds(2)
r_u = [a]
#DirichletBC
bcd1 = DirichletBC(C.sub(0).sub(0), 0.0, boundaries, 1) # No normal displacement for solid on left side
bcd3 = DirichletBC(C.sub(0).sub(0), 0.0, boundaries, 3) # No normal displacement for solid on right side
bcd4 = DirichletBC(C.sub(0).sub(1), 0.0, boundaries, 4) # No normal displacement for solid on bottom side
bcs = BlockDirichletBC([bcd1,bcd3,bcd4])
AA = block_assemble([r_u])
FF = block_assemble([rhs_a - a_time])
bcs.apply(AA)
bcs.apply(FF)
block_solve(AA, w.block_vector(), FF, "mumps")
export_solution = w
return export_solution, T
def test_steady_stokes(k):
# Polynomial order and mesh resolution
nx_list = [4, 8, 16]
nu = Constant(1)
if comm.Get_rank() == 0:
print('{:=^72}'.format('Computing for polynomial order ' + str(k)))
# Error listst
error_u, error_p, error_div = [], [], []
for nx in nx_list:
if comm.Get_rank() == 0:
print('# Resolution ' + str(nx))
mesh = UnitSquareMesh(nx, nx)
# Get forcing from exact solutions
u_exact, p_exact = exact_solution(mesh)
f = div(p_exact * Identity(2) - 2 * nu * sym(grad(u_exact)))
# Define FunctionSpaces and functions
V = VectorElement("DG", mesh.ufl_cell(), k)
Q = FiniteElement("DG", mesh.ufl_cell(), k - 1)
Vbar = VectorElement("DGT", mesh.ufl_cell(), k)
Qbar = FiniteElement("DGT", mesh.ufl_cell(), k)
mixedL = FunctionSpace(mesh, MixedElement([V, Q]))
mixedG = FunctionSpace(mesh, MixedElement([Vbar, Qbar]))
Uh = Function(mixedL)
Uhbar = Function(mixedG)
# Set forms
alpha = Constant(6 * k * k)
forms_stokes = FormsStokes(mesh, mixedL, mixedG,
alpha).forms_steady(nu, f)
# No-slip boundary conditions, set pressure in one of the corners
bc0 = DirichletBC(mixedG.sub(0), Constant((0, 0)), Gamma)
bc1 = DirichletBC(mixedG.sub(1), Constant(0), Corner, "pointwise")
bcs = [bc0, bc1]
# Initialize static condensation class
ssc = StokesStaticCondensation(mesh, forms_stokes['A_S'],
forms_stokes['G_S'],
forms_stokes['B_S'],
forms_stokes['Q_S'],
forms_stokes['S_S'], bcs)
# Assemble global system and incorporates bcs
ssc.assemble_global_system(True)
# Solve using mumps
ssc.solve_problem(Uhbar, Uh, "mumps", "default")
# Compute velocity/pressure/local div error
uh, ph = Uh.split()
e_u = np.sqrt(np.abs(assemble(dot(uh - u_exact, uh - u_exact) * dx)))
e_p = np.sqrt(np.abs(assemble((ph - p_exact) * (ph - p_exact) * dx)))
e_d = np.sqrt(np.abs(assemble(div(uh) * div(uh) * dx)))
if comm.rank == 0:
error_u.append(e_u)
error_p.append(e_p)
error_div.append(e_d)
print('Error in velocity ' + str(error_u[-1]))
print('Error in pressure ' + str(error_p[-1]))
print('Local mass error ' + str(error_div[-1]))
if comm.rank == 0:
iterator_list = [1. / float(nx) for nx in nx_list]
conv_u = compute_convergence(iterator_list, error_u)
conv_p = compute_convergence(iterator_list, error_p)
assert any(conv > k + 0.75 for conv in conv_u)
assert any(conv > (k - 1) + 0.75 for conv in conv_p)
def transport_linear(integrator_type, mesh, subdomains, boundaries, t_start, dt, T, solution0, \
alpha_0, K_0, mu_l_0, lmbda_l_0, Ks_0, \
alpha_1, K_1, mu_l_1, lmbda_l_1, Ks_1, \
alpha, K, mu_l, lmbda_l, Ks, \
cf_0, phi_0, rho_0, mu_0, k_0,\
cf_1, phi_1, rho_1, mu_1, k_1,\
cf, phi, rho, mu, k, \
d_0, d_1, d_t,
vel_c, p_con, A_0, Temp, c_extrapolate):
# Create mesh and define function space
parameters["ghost_mode"] = "shared_facet" # required by dS
dx = Measure('dx', domain=mesh, subdomain_data=subdomains)
ds = Measure('ds', domain=mesh, subdomain_data=boundaries)
dS = Measure('dS', domain=mesh, subdomain_data=boundaries)
C_cg = FiniteElement("CG", mesh.ufl_cell(), 1)
C_dg = FiniteElement("DG", mesh.ufl_cell(), 0)
mini = C_cg + C_dg
C = FunctionSpace(mesh, mini)
C = BlockFunctionSpace([C])
TM = TensorFunctionSpace(mesh, 'DG', 0)
PM = FunctionSpace(mesh, 'DG', 0)
n = FacetNormal(mesh)
vc = CellVolume(mesh)
fc = FacetArea(mesh)
h = vc / fc
h_avg = (vc('+') + vc('-')) / (2 * avg(fc))
penalty1 = Constant(1.0)
tau = Function(PM)
tau = tau_cal(tau, phi, -0.5)
tuning_para = 0.25
vel_norm = (dot(vel_c, n) + abs(dot(vel_c, n))) / 2.0
cell_size = CellDiameter(mesh)
vnorm = sqrt(dot(vel_c, vel_c))
I = Identity(mesh.topology().dim())
d_eff = Function(TM)
d_eff = diff_coeff_cal_rev(d_eff, d_0, tau,
phi) + tuning_para * cell_size * vnorm * I
monitor_dt = dt
# Define variational problem
dc, = BlockTrialFunction(C)
dc_dot, = BlockTrialFunction(C)
psic, = BlockTestFunction(C)
block_c = BlockFunction(C)
c, = block_split(block_c)
block_c_dot = BlockFunction(C)
c_dot, = block_split(block_c_dot)
theta = -1.0
a_time = phi * rho * inner(c_dot, psic) * dx
a_dif = dot(rho*d_eff*grad(c),grad(psic))*dx \
- dot(avg_w(rho*d_eff*grad(c),weight_e(rho*d_eff,n)), jump(psic, n))*dS \
+ theta*dot(avg_w(rho*d_eff*grad(psic),weight_e(rho*d_eff,n)), jump(c, n))*dS \
+ penalty1/h_avg*k_e(rho*d_eff,n)*dot(jump(c, n), jump(psic, n))*dS
a_adv = -dot(rho*vel_c*c,grad(psic))*dx \
+ dot(jump(psic), rho('+')*vel_norm('+')*c('+') - rho('-')*vel_norm('-')*c('-') )*dS \
+ dot(psic, rho*vel_norm*c)*ds(3)
R_c = R_c_cal(c_extrapolate, p_con, Temp)
c_D1 = Constant(0.5)
rhs_c = R_c * A_s_cal(phi, phi_0, A_0) * psic * dx - dot(
rho * phi * vel_c, n) * c_D1 * psic * ds(1)
r_u = [a_dif + a_adv]
j_u = block_derivative(r_u, [c], [dc])
r_u_dot = [a_time]
j_u_dot = block_derivative(r_u_dot, [c_dot], [dc_dot])
r = [r_u_dot[0] + r_u[0] - rhs_c]
# this part is not applied.
exact_solution_expression1 = Expression("1.0",
t=0,
element=C[0].ufl_element())
def bc(t):
p5 = DirichletBC(C.sub(0),
exact_solution_expression1,
boundaries,
1,
method="geometric")
return BlockDirichletBC([p5])
# Define problem wrapper
class ProblemWrapper(object):
def set_time(self, t):
pass
# Residual and jacobian functions
def residual_eval(self, t, solution, solution_dot):
return r
def jacobian_eval(self, t, solution, solution_dot,
solution_dot_coefficient):
return [[
Constant(solution_dot_coefficient) * j_u_dot[0, 0] + j_u[0, 0]
]]
# Define boundary condition
def bc_eval(self, t):
pass
# Define initial condition
def ic_eval(self):
return solution0
# Define custom monitor to plot the solution
def monitor(self, t, solution, solution_dot):
pass
problem_wrapper = ProblemWrapper()
(solution, solution_dot) = (block_c, block_c_dot)
solver = TimeStepping(problem_wrapper, solution, solution_dot)
solver.set_parameters({
"initial_time": t_start,
"time_step_size": dt,
"monitor": {
"time_step_size": monitor_dt,
},
"final_time": T,
"exact_final_time": "stepover",
"integrator_type": integrator_type,
"problem_type": "linear",
"linear_solver": "mumps",
"report": True
})
export_solution = solver.solve()
return export_solution, T
def test_unsteady_stokes():
nx, ny = 15, 15
k = 1
nu = Constant(1.0e-0)
dt = Constant(2.5e-2)
num_steps = 20
theta0 = 1.0 # Initial theta value
theta1 = 0.5 # Theta after 1 step
theta = Constant(theta0)
mesh = UnitSquareMesh(nx, ny)
# The 'unsteady version' of the benchmark in the 2012 paper by Labeur&Wells
u_exact = Expression(
(
"sin(t) * x[0]*x[0]*(1.0 - x[0])*(1.0 - x[0])*(2.0*x[1] \
-6.0*x[1]*x[1] + 4.0*x[1]*x[1]*x[1])",
"-sin(t)* x[1]*x[1]*(1.0 - x[1])*(1.0 - x[1])*(2.0*x[0] \
- 6.0*x[0]*x[0] + 4.0*x[0]*x[0]*x[0])",
),
t=0,
degree=7,
domain=mesh,
)
p_exact = Expression("sin(t) * x[0]*(1.0 - x[0])",
t=0,
degree=7,
domain=mesh)
du_exact = Expression(
(
"cos(t) * x[0]*x[0]*(1.0 - x[0])*(1.0 - x[0])*(2.0*x[1] \
- 6.0*x[1]*x[1] + 4.0*x[1]*x[1]*x[1])",
"-cos(t)* x[1]*x[1]*(1.0 - x[1])*(1.0 - x[1])*(2.0*x[0] \
-6.0*x[0]*x[0] + 4.0*x[0]*x[0]*x[0])",
),
t=0,
degree=7,
domain=mesh,
)
ux_exact = Expression(
(
"x[0]*x[0]*(1.0 - x[0])*(1.0 - x[0])*(2.0*x[1] \
- 6.0*x[1]*x[1] + 4.0*x[1]*x[1]*x[1])",
"-x[1]*x[1]*(1.0 - x[1])*(1.0 - x[1])*(2.0*x[0] \
- 6.0*x[0]*x[0] + 4.0*x[0]*x[0]*x[0])",
),
degree=7,
domain=mesh,
)
px_exact = Expression("x[0]*(1.0 - x[0])", degree=7, domain=mesh)
sin_ext = Expression("sin(t)", t=0, degree=7, domain=mesh)
f = du_exact + sin_ext * div(px_exact * Identity(2) -
2 * sym(grad(ux_exact)))
Vhigh = VectorFunctionSpace(mesh, "DG", 7)
Phigh = FunctionSpace(mesh, "DG", 7)
# New syntax:
V = VectorElement("DG", mesh.ufl_cell(), k)
Q = FiniteElement("DG", mesh.ufl_cell(), k - 1)
Vbar = VectorElement("DGT", mesh.ufl_cell(), k)
Qbar = FiniteElement("DGT", mesh.ufl_cell(), k)
mixedL = FunctionSpace(mesh, MixedElement([V, Q]))
mixedG = FunctionSpace(mesh, MixedElement([Vbar, Qbar]))
V2 = FunctionSpace(mesh, V)
Uh = Function(mixedL)
Uhbar = Function(mixedG)
U0 = Function(mixedL)
Uhbar0 = Function(mixedG)
u0, p0 = split(U0)
ubar0, pbar0 = split(Uhbar0)
ustar = Function(V2)
# Then the boundary conditions
bc0 = DirichletBC(mixedG.sub(0), Constant((0, 0)), Gamma)
bc1 = DirichletBC(mixedG.sub(1), Constant(0), Corner, "pointwise")
bcs = [bc0, bc1]
alpha = Constant(6 * k * k)
forms_stokes = FormsStokes(mesh, mixedL, mixedG,
alpha).forms_unsteady(ustar, dt, nu, f)
ssc = StokesStaticCondensation(
mesh,
forms_stokes["A_S"],
forms_stokes["G_S"],
forms_stokes["G_ST"],
forms_stokes["B_S"],
forms_stokes["Q_S"],
forms_stokes["S_S"],
)
t = 0.0
step = 0
for step in range(num_steps):
step += 1
t += float(dt)
if comm.Get_rank() == 0:
print("Step " + str(step) + " Time " + str(t))
# Set time level in exact solution
u_exact.t = t
p_exact.t = t
du_exact.t = t - (1 - float(theta)) * float(dt)
sin_ext.t = t - (1 - float(theta)) * float(dt)
ssc.assemble_global_lhs()
ssc.assemble_global_rhs()
for bc in bcs:
ssc.apply_boundary(bc)
ssc.solve_problem(Uhbar, Uh, "none", "default")
assign(U0, Uh)
assign(ustar, U0.sub(0))
assign(Uhbar0, Uhbar)
if step == 1:
theta.assign(theta1)
udiv_e = sqrt(assemble(div(Uh.sub(0)) * div(Uh.sub(0)) * dx))
u_ex_h = interpolate(u_exact, Vhigh)
p_ex_h = interpolate(p_exact, Phigh)
u_error = sqrt(assemble(dot(Uh.sub(0) - u_ex_h, Uh.sub(0) - u_ex_h) * dx))
p_error = sqrt(assemble(dot(Uh.sub(1) - p_ex_h, Uh.sub(1) - p_ex_h) * dx))
assert udiv_e < 1e-12
assert u_error < 1.5e-4
assert p_error < 1e-2
def __ufl_forms(self, nu, f):
(w, q, wbar, qbar) = self.__test_functions()
(u, p, ubar, pbar) = self.__trial_functions()
# Infer geometric dimension
zero_vec = np.zeros(self.gdim)
ds = self.ds
n = self.n
he = self.he
alpha = self.alpha
h_d = self.h_d
beta_stab = self.beta_stab
facet_integral = self.facet_integral
pI = p * Identity(
self.mixedL.sub(1).ufl_cell().topological_dimension())
pbI = pbar * \
Identity(self.mixedL.sub(1).ufl_cell().topological_dimension())
# Upper left block
# Contribution comes from local momentum balance
AB = inner(2*nu*sym(grad(u)), grad(w))*dx \
+ facet_integral(dot(-2*nu*sym(grad(u))*n
+ (2*nu*alpha/he)*u, w)) \
+ facet_integral(dot(-2*nu*u, sym(grad(w))*n)) \
- inner(pI, grad(w))*dx
# Contribution comes from local mass balance
BtF = -dot(q, div(u))*dx - \
facet_integral(beta_stab*he/(nu+1)*dot(p, q))
A_S = AB + BtF
# Upper right block
# Contribution from local momentum
CD = facet_integral(-alpha/he*2*nu*inner(ubar, w)) \
+ facet_integral(2*nu*inner(ubar, sym(grad(w))*n)) \
+ facet_integral(dot(pbI*n, w))
H = facet_integral(beta_stab * he / (nu + 1) * dot(pbar, q))
G_S = CD + H
# Transpose block
CDT = facet_integral(- alpha/he*2*nu*inner(wbar, u)) \
+ facet_integral(2*nu*inner(wbar, sym(grad(u))*n)) \
+ facet_integral(qbar * dot(u, n))
HT = facet_integral(beta_stab * he / (nu + 1) * dot(p, qbar))
G_ST = CDT + HT
# Lower right block, penalty on ds(98) approximates free-slip
KL = facet_integral(alpha/he * 2 * nu*dot(ubar, wbar)) \
- facet_integral(dot(pbar*n, wbar)) \
+ Constant(1E12)/he * inner(outer(ubar, wbar), outer(n, n)) * ds(98)
LtP = - facet_integral(dot(ubar, n)*qbar) \
- facet_integral(beta_stab*he/(nu+1) * pbar * qbar)
B_S = KL + LtP
# Righthandside
Q_S = dot(f, w) * dx
S_S = facet_integral(dot(Constant(zero_vec), wbar))
S_S += dot(h_d[0], wbar) * ds(99) + dot(h_d[1], wbar) * ds(
100) #Neumann BC
return {
'A_S': A_S,
'G_S': G_S,
'G_ST': G_ST,
'B_S': B_S,
'Q_S': Q_S,
'S_S': S_S
}
def E(U):
return 0.5 * (F_(U).T * F_(U) - Identity(len(U)))
def sigma_f(p, u, d, mu_f):
return -p*Identity(len(u)) +\
mu_f*(grad(u)*inv(F_(d)) + inv(F_(d)).T*grad(u).T)
def F_(U):
return Identity(len(U)) + grad(U)
def sigma_f_new(u, p, d, mu_f):
return -p * Identity(
len(u)) + mu_f * (grad(u) * inv(F_(d)) + inv(F_(d)).T * grad(u).T)
