def test(path, type='mf'):
'''Evolve the tile in (n, n) pattern checking volume/surface properties'''
comm = mpi_comm_world()
h5 = HDF5File(comm, path, 'r')
tile = Mesh()
h5.read(tile, 'mesh', False)
init_container = lambda type, dim: (
MeshFunction('size_t', tile, dim, 0)
if type == 'mf' else MeshValueCollection('size_t', tile, dim))
for n in (2, 4):
data = {}
checks = {}
for dim, name in zip((2, 3), ('surfaces', 'volumes')):
# Get the collection
collection = init_container(type, dim)
h5.read(collection, name)
if type == 'mvc': collection = as_meshf(collection)
# Data to evolve
tile.init(dim, 0)
e2v = tile.topology()(dim, 0)
# Only want to evolve tag 1 (interfaces) for the facets.
data[(dim, 1)] = np.array(
[e2v(e.index()) for e in SubsetIterator(collection, 1)],
dtype='uintp')
if dim == 2:
check = lambda m, f: assemble(
FacetArea(m) * ds(domain=m,
subdomain_data=f,
subdomain_id=1) + avg(FacetArea(m)) *
dS(domain=m, subdomain_data=f, subdomain_id=1))
else:
check = lambda m, f: assemble(
CellVolume(m) * dx(
domain=m, subdomain_data=f, subdomain_id=1))
checks[
dim] = lambda m, f, t=tile, c=collection, n=n, check=check: abs(
check(m, f) - n**2 * check(t, c)) / (n**2 * check(t, c))
t = Timer('x')
mesh, mesh_data = TileMesh(tile, (n, n), mesh_data=data)
info('\tTiling took %g s. Ncells %d, nvertices %d, \n' %
(t.stop(), mesh.num_vertices(), mesh.num_cells()))
foos = mf_from_data(mesh, mesh_data)
# Mesh Functions
from_mf = np.array([checks[dim](mesh, foos[dim]) for dim in (2, 3)])
mvcs = mvc_from_data(mesh, mesh_data)
foos = as_meshf(mvcs)
# Mesh ValueCollections
from_mvc = np.array([checks[dim](mesh, foos[dim]) for dim in (2, 3)])
assert np.linalg.norm(from_mf - from_mvc) < 1E-13
# I ignore shared facets so there is bound to be some error in facets
# Volume should match well
print from_mf
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 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
# We have to use at least quadratic polynomials here
Vx = FunctionSpace(mx, 'CG', 2)
Vy = FunctionSpace(my, 'CG', 1)
phi = TrialFunction(Vx)
psi = TestFunction(Vx)
v = Function(Vx)
gamma = 1.0
# Jump penalty term
stab1 = 2.
nE = FacetNormal(mx)
hE = FacetArea(mx)
test = div(grad(psi))
S_ = gamma * inner(ax, grad(grad(phi))) * test * dx(mx) \
+ stab1 * avg(hE)**(-1) * inner(jump(grad(phi), nE), jump(grad(psi), nE)) * dS(mx) \
+ gamma * inner(bx, grad(phi)) * test * dx(mx) \
+ gamma * c * phi * test * dx(mx)
# This matrix also changes since we are testing the whole equation
# with div(grad(psi)) instead of psi
M_ = gamma * phi * test * dx(mx)
bc_Vx = DirichletBC(Vx, g, 'on_boundary')
S = assemble(S_)
M = assemble(M_)
ds = Measure("ds", domain=mesh, subdomain_data=boundaries)
dS = Measure("dS", domain=mesh, subdomain_data=boundaries)
# Test and trial functions
vq = BlockTestFunction(W)
(v, q) = block_split(vq)
up = BlockTrialFunction(W)
(u, p) = block_split(up)
w = BlockFunction(W)
w0 = BlockFunction(W)
(u0, p0) = block_split(w0)
n = FacetNormal(mesh)
vc = CellVolume(mesh)
fc = FacetArea(mesh)
h = vc / fc
h_avg = (vc("+") + vc("-")) / (2 * avg(fc))
penalty1 = 1.0
penalty2 = 10.0
theta = 1.0
# Constitutive parameters
K = 1000.e3
nu = 0.25
E = K_nu_to_E(K, nu) # Pa 14
(mu_l, lmbda_l) = E_nu_to_mu_lmbda(E, nu)
mesh.smooth_boundary()
mesh.snap_boundary(star)
print "Smoothing ..."
mesh.smooth_boundary()
mesh.smooth()
except:
print "Error"
print "New mesh size: ", mesh.size(2)
pl.plot(mesh)
# sizes of mesh triangles
V = FunctionSpace(mesh, "DG", 0)
W = FunctionSpace(mesh, "CG", 3)
v = TestFunction(V)
density = Function(V)
sides = FacetArea(mesh)
v = assemble(avg(v) * avg(sides) * dS + v * sides * ds)
density.vector()[:] = np.sqrt(v / np.median(v))
density = interpolate(density, W)
# perimeter
V = FunctionSpace(mesh, "R", 0)
u = Function(V)
u.interpolate(Constant(1.0))
L = assemble(u * ds)
print "Perimeter: ", L
# g0 and g1
n = FacetNormal(mesh)
xy = Expression(('x[0]', 'x[1]'))
g1 = assemble(inner(xy, xy) / inner(xy, n) * ds) * 2 * pi / L**2
def h_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, \
sigma_v_freeze, dphi_c_dt):
# 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)
BDM = FiniteElement("BDM", mesh.ufl_cell(), 1)
PDG = FiniteElement("DG", mesh.ufl_cell(), 0)
BDM_F = FunctionSpace(mesh, BDM)
PDG_F = FunctionSpace(mesh, PDG)
W = BlockFunctionSpace([BDM_F, PDG_F], restrict=[None, None])
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))
I = Identity(mesh.topology().dim())
monitor_dt = dt
p_outlet = 0.1e6
p_inlet = 1000.0
M_inv = phi_0 * cf + (alpha - phi_0) / Ks
# Define variational problem
trial = BlockTrialFunction(W)
dv, dp = block_split(trial)
trial_dot = BlockTrialFunction(W)
dv_dot, dp_dot = block_split(trial_dot)
test = BlockTestFunction(W)
psiv, psip = block_split(test)
block_w = BlockFunction(W)
v, p = block_split(block_w)
block_w_dot = BlockFunction(W)
v_dot, p_dot = block_split(block_w_dot)
a_time = Constant(0.0) * inner(v_dot, psiv) * dx #quasi static
# k is a function of phi
#k = perm_update_rutqvist_newton(p,p0,phi0,phi,coeff)
lhs_a = inner(dot(v, mu * inv(k)), psiv) * dx - p * div(
psiv
) * dx #+ 6.0*inner(psiv,n)*ds(2) # - inner(gravity*(rho-rho0), psiv)*dx
b_time = (M_inv + pow(alpha, 2.) / K) * p_dot * psip * dx
lhs_b = div(v) * psip * dx #div(rho*v)*psip*dx #TODO rho
rhs_v = -p_outlet * inner(psiv, n) * ds(3)
rhs_p = -alpha / K * sigma_v_freeze * psip * dx - dphi_c_dt * psip * dx
r_u = [lhs_a, lhs_b]
j_u = block_derivative(r_u, block_w, trial)
r_u_dot = [a_time, b_time]
j_u_dot = block_derivative(r_u_dot, block_w_dot, trial_dot)
r = [r_u_dot[0] + r_u[0] - rhs_v, \
r_u_dot[1] + r_u[1] - rhs_p]
def bc(t):
#bc_v = [DirichletBC(W.sub(0), (.0, .0), boundaries, 4)]
v1 = DirichletBC(W.sub(0), (1.e-4 * 2.0, 0.0), boundaries, 1)
v2 = DirichletBC(W.sub(0), (0.0, 0.0), boundaries, 2)
v4 = DirichletBC(W.sub(0), (0.0, 0.0), boundaries, 4)
bc_v = [v1, v2, v4]
return BlockDirichletBC([bc_v, None])
# Define problem wrapper
class ProblemWrapper(object):
def set_time(self, t):
pass
#g.t = t
# Residual and jacobian functions
def residual_eval(self, t, solution, solution_dot):
#print(as_backend_type(assemble(p_time - p_time_error)).vec().norm())
#print("gravity effect", as_backend_type(assemble(inner(gravity*(rho-rho0), psiv)*dx)).vec().norm())
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], \
Constant(solution_dot_coefficient)*j_u_dot[0, 1] + j_u[0, 1]], \
[Constant(solution_dot_coefficient)*j_u_dot[1, 0] + j_u[1, 0], \
Constant(solution_dot_coefficient)*j_u_dot[1, 1] + j_u[1, 1]]]
# Define boundary condition
def bc_eval(self, t):
return bc(t)
# Define initial condition
def ic_eval(self):
return solution0
# Define custom monitor to plot the solution
def monitor(self, t, solution, solution_dot):
pass
# Solve the time dependent problem
problem_wrapper = ProblemWrapper()
(solution, solution_dot) = (block_w, block_w_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