def project_gradient_neumann(
f0,
degree=None,
mesh=None,
solver_type='gmres',
preconditioner_type='default'
):
"""Find an approximation to f0 that has the same gradient
The resulting function also satisfies homogeneous Neumann boundary
conditions.
Parameters:
f0: the function to approximate
mesh=None: the mesh on which to approximate it If not provided, the
mesh is extracted from f0.
degree=None: degree of the polynomial approximation. extracted
from f0 if not provided.
solver_type='gmres': The linear solver type to use.
preconditioner_type='default': Preconditioner type to use
"""
if not mesh: mesh = f0.function_space().mesh()
element = f0.ufl_element()
if not degree:
degree = element.degree()
CE = FiniteElement('CG', mesh.ufl_cell(), degree)
CS = FunctionSpace(mesh, CE)
DE = FiniteElement('DG', mesh.ufl_cell(), degree)
DS = FunctionSpace(mesh, DE)
CVE = VectorElement('CG', mesh.ufl_cell(), degree - 1)
CV = FunctionSpace(mesh, CVE)
RE = FiniteElement('R', mesh.ufl_cell(), 0)
R = FunctionSpace(mesh, RE)
CRE = MixedElement([CE, RE])
CR = FunctionSpace(mesh, CRE)
f = fe.project(f0, CS,
solver_type=solver_type,
preconditioner_type=preconditioner_type)
g = fe.project(fe.grad(f), CV,
solver_type=solver_type,
preconditioner_type=preconditioner_type)
lf = fe.project(fe.nabla_div(g), CS,
solver_type=solver_type,
preconditioner_type=preconditioner_type)
tf, tc = TrialFunction(CR)
wf, wc = TestFunctions(CR)
dx = Measure('dx', domain=mesh,
metadata={'quadrature_degree': min(degree, 10)})
a = (fe.dot(fe.grad(tf), fe.grad(wf)) + tc * wf + tf * wc) * dx
L = (f * wc - lf * wf) * dx
igc = Function(CR)
fe.solve(a == L, igc,
solver_parameters={'linear_solver': solver_type,
'preconditioner': preconditioner_type}
)
ig, c = igc.sub(0), igc.sub(1)
igd = fe.project(ig, DS,
solver_type=solver_type,
preconditioner_type=preconditioner_type)
return igd
def CGelement(fs):
"""Make a CG element corresponding to a DG FunctionSpace."""
elements = []
for ss in (fs.split()):
CE = FiniteElement('CG', ss.ufl_cell(), ss.ufl_element().degree())
elements.append(CE)
return MixedElement(elements)
def make_function_space(self, mesh=None, dim=None, degree=None):
if not mesh: mesh = self.mesh
if not dim: dim = self.dim
if not degree: degree = self.degree
SE = FiniteElement('DG', cellShapes[dim - 1], degree)
SS = FunctionSpace(mesh, SE) # scalar space
VE = MixedElement(SE, SE)
VS = FunctionSpace(mesh, VE) # vector space
return dict(SE=SE, SS=SS, VE=VE, VS=VS)
def make_function_space(self, mesh=None, dim=None, degree=None):
if not mesh: mesh = self.mesh
if not dim: dim = self.dim
if not degree: degree = self.degree
SE = FiniteElement('DG', cellShapes[dim - 1], degree)
SS = FunctionSpace(mesh, SE) # scalar space
elements = [SE] * ((self.nligands + 1) * 2**self.dim)
VE = MixedElement(elements)
VS = FunctionSpace(mesh, VE) # vector space
logPERIODIC('VS', VS)
return dict(SE=SE, SS=SS, VE=VE, VS=VS)
def restart(self):
logVARIABLE('restart')
self.set_time(self.t0)
CE = FiniteElement('CG', cellShapes[self.dim - 1], self.degree)
CS = FunctionSpace(self.mesh, CE) # scalar space
coords = gather_dof_coords(CS)
fe.assign(self.sol.sub(0),
function_interpolate(self.rho0, self.SS, coords=coords))
for i, U0i in enumerate(self.U0s):
fe.assign(self.sol.sub(i + 1),
function_interpolate(U0i, self.SS, coords=coords))
def restart(self):
logSOLVER('restart')
self.t = self.t0
CE = FiniteElement('CG', cellShapes[self.dim - 1], self.degree)
CS = FunctionSpace(self.mesh, CE) # scalar space
coords = gather_dof_coords(CS)
logSOLVER('function_interpolate(self.U0, self.SS, coords=coords)',
function_interpolate(self.U0, self.SS, coords=coords))
fe.assign(self.sol.sub(1),
function_interpolate(self.U0, self.SS, coords=coords))
logSOLVER('U0 assign returned')
fe.assign(self.sol.sub(0),
function_interpolate(self.rho0, self.SS, coords=coords))
def compute_steady_state(self):
names = {'Cl', 'Na', 'K'}
P1 = FiniteElement('P', fe.triangle, 1)
element = MixedElement([P1, P1, P1])
V = FunctionSpace(self.mesh, element)
self.V_conc = V
(u_cl, u_na, u_k) = TrialFunction(V)
(v_cl, v_na, v_k) = TestFunction(V)
assert (self.flow is not None)
n = fe.FacetNormal(self.mesh)
# F = ( self.F_diff_conv(u_cl, v_cl, n, grad(self.phi), 1. ,1., 0.)
# + self.F_diff_conv(u_na, v_na, n, grad(self.phi), 1. ,1., 0.)
# + self.F_diff_conv(u_k , v_k , n, grad(self.phi), 1. ,1., 0.) )
dx, ds = self.dx, self.ds
flow = self.flow
F = inner(grad(u_cl), grad(v_cl)) * dx \
+ inner(flow, grad(u_cl)) * v_cl * dx \
+ inner(grad(u_na), grad(v_na)) * dx \
+ inner(flow, grad(u_na)) * v_na * dx \
+ inner(grad(u_k), grad(v_k)) * dx \
+ inner(flow, grad(u_k)) * v_k * dx
a, L = fe.lhs(F), fe.rhs(F)
a_mat = fe.assemble(a)
L_vec = fe.assemble(L)
# solve
u = Function(V)
fe.solve(a_mat, u.vector(), L_vec)
u_cl, u_na, u_k = u.split()
output1 = fe.File('/tmp/steady_state_cl.pvd')
output1 << u_cl
output2 = fe.File('/tmp/steady_state_na.pvd')
output2 << u_na
output3 = fe.File('/tmp/steady_state_k.pvd')
output3 << u_k
self.u_cl = u_cl
self.u_na = u_na
self.u_k = u_k
def __init__(self, mesh, N=0):
# Define mesh parameters
self.mesh = mesh
self.cell_size = CellDiameter(mesh)
self.normal_vector = FacetNormal(mesh)
# Define measures
inner_boundary = Inner_boundary()
sub_domains = MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
sub_domains.set_all(0)
inner_boundary.mark(sub_domains, 1)
self.dx = Measure("dx", domain=mesh)
self.ds = Measure("ds", domain=mesh, subdomain_data=sub_domains)
# Define function spaces
finite_element = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
self.function_space = FunctionSpace(mesh,
finite_element * finite_element)
self.function_space_split = [
self.function_space.sub(0).collapse(),
self.function_space.sub(1).collapse(),
]
def compute_conv_diff_reac_video(self, initial_condition=None, video_ref=None, video_size=None):
names = {'Cl', 'K'}
P1 = FiniteElement('P', fe.triangle, 1)
element = fe.MixedElement([P1, P1])
V_single = FunctionSpace(self.mesh, P1)
V = FunctionSpace(self.mesh, element)
self.V_conc = V
# load video
video = VideoData(element=P1)
video.load_video(self.video_filename)
if( video_ref is not None and video_size is not None):
video.set_reference_frame(video_ref, video_size)
print(video)
dt = 0.05
t = 0.
t_end = 20.
u_init = Function(V)
(u_cl, u_k) = TrialFunction(V)
(v_cl, v_k) = TestFunction(V)
#u_na = video
if initial_condition is None:
#initial_condition = Expression(("f*exp(-0.5*((x[0]-a)*(x[0]-a)+(x[1]-b)*(x[1]-b))/var)/(sqrt(2*pi)*var)",
# "0."), a = 80, b= 55, var=10, f=10, pi=fe.pi, element=element)
initial_condition = Expression(("f",
"0."), a=80, b=55, var=0.1, f=0.1, pi=fe.pi, element=element)
u_init = fe.interpolate(initial_condition, V)
u_init_cl = u_init[0]
u_init_k = u_init[1]
u_init_na : VideoData= video
assert (self.flow is not None)
n = fe.FacetNormal(self.mesh)
dx, ds = self.dx, self.ds
flow = 5. * self.flow
f_in = fe.Constant(0.00)
f_in_cl = fe.Constant(-0.05)
D = fe.Constant(0.1)
C_na = fe.Constant(0.1)
k1 = fe.Constant(0.2)
k_1 = fe.Constant(0.00001)
# explicit
F = (
(u_cl - u_init_cl) * v_cl * dx
+ dt * D * inner(grad(u_cl), grad(v_cl)) * dx
+ dt * inner(flow, grad(u_cl)) * v_cl * dx
#+ (u_na - u_init_na) * v_na * dx
#+ dt * D * inner(grad(u_na), grad(v_na)) * dx
#+ dt * inner(flow, grad(u_na)) * v_na * dx
+ (u_k - u_init_k) * v_k * dx
+ dt * D * inner(grad(u_k), grad(v_k)) * dx
+ dt * inner(flow, grad(u_k)) * v_k * dx
+ f_in_cl * v_cl * dx
#+ f_in * v_na * dx
+ f_in * v_k * dx
+ dt * k1 * u_init_cl * C_na * u_init_na * v_cl * dx
#+ dt * k1 * u_init_cl * u_init_na * v_na * dx
- dt * k1 * u_init_cl * C_na * u_init_na * v_k * dx
- dt * k_1 * u_init_k * v_cl * dx
#- dt * k_1 * u_init_k * v_na * dx
+ dt * k_1 * u_init_k * v_k * dx
)
# implicit
F = (
(u_cl - u_init_cl) * v_cl * dx
+ dt * D * inner(grad(u_cl), grad(v_cl)) * dx
+ dt * inner(flow, grad(u_cl)) * v_cl * dx
# + (u_na - u_init_na) * v_na * dx
# + dt * D * inner(grad(u_na), grad(v_na)) * dx
# + dt * inner(flow, grad(u_na)) * v_na * dx
+ (u_k - u_init_k) * v_k * dx
+ dt * D * inner(grad(u_k), grad(v_k)) * dx
+ dt * inner(flow, grad(u_k)) * v_k * dx
+ f_in_cl * v_cl * dx
# + f_in * v_na * dx
+ f_in * v_k * dx
+ dt * k1 * u_cl * C_na * u_init_na * v_cl * dx
# + dt * k1 * u_init_cl * u_init_na * v_na * dx
- dt * k1 * u_cl * C_na * u_init_na * v_k * dx
- dt * k_1 * u_k * v_cl * dx
# - dt * k_1 * u_init_k * v_na * dx
+ dt * k_1 * u_k * v_k * dx
)
self.F = F
a, L = fe.lhs(F), fe.rhs(F)
a_mat = fe.assemble(a)
L_vec = fe.assemble(L)
output1 = fe.File('/tmp/cl_dyn.pvd')
output2 = fe.File('/tmp/na_dyn.pvd')
output3 = fe.File('/tmp/k_dyn.pvd')
output4 = fe.File('/tmp/all_dyn.pvd')
# solve
self.sol = []
u_na = Function(V_single)
u_na = fe.interpolate(u_init_na,V_single)
na_inflow = 0
t_plot = 0.5
t_last_plot = 0
while t < t_end:
t = t + dt
t_last_plot += dt
print(t)
u = Function(V)
u_init_na.set_time(5*t)
a_mat = fe.assemble(a)
L_vec = fe.assemble(L)
fe.solve(a_mat, u.vector(), L_vec)
# NonlinearVariationalProblem(F,u)
u_init.assign(u)
u_cl, u_k = u.split()
# u_init_cl.assign(u_cl)
# u_init_na.assign(u_na)
# u_init_k.assign(u_k)
u_na = fe.interpolate(u_init_na, V_single)
u_cl.rename("cl", "cl")
u_na.rename("na", "na")
u_k.rename("k", "k")
output1 << u_cl, t
output2 << u_na, t
output3 << u_k, t
self.sol.append((u_cl, u_na, u_k))
print( fe.assemble(u_cl*self.dx))
if t_last_plot > t_plot:
t_last_plot = 0
plt.figure(figsize=(8,16))
plt.subplot(211)
fe.plot(u_cl)
plt.subplot(212)
fe.plot(u_k)
plt.show()
self.u_cl = u_cl
#self.u_na = u_na
self.u_k = u_k
def compute_conv_diff_reac(self, initial_condition=None):
names = {'Cl', 'Na', 'K'}
dt = 0.1
t = 0.
t_end = 1.
P1 = FiniteElement('P', fe.triangle, 3)
element = MixedElement([P1, P1, P1])
V = FunctionSpace(self.mesh, element)
self.V_conc = V
u_init = Function(V)
(u_cl, u_na, u_k) = TrialFunction(V)
(v_cl, v_na, v_k) = TestFunction(V)
if initial_condition is None:
initial_condition = Expression(("exp(-((x[0]-0.1)*(x[0]-0.1)+x[1]*x[1])/0.01)",
"exp(-((x[0]-0.12)*(x[0]-0.12)+x[1]*x[1])/0.01)",
"0."), element=element)
u_init = fe.interpolate(initial_condition, V)
u_init_cl = u_init[0]
u_init_na = u_init[1]
u_init_k = u_init[2]
assert (self.flow is not None)
n = fe.FacetNormal(self.mesh)
dx, ds = self.dx, self.ds
flow = 10 * self.flow
f_in = fe.Constant(0.00)
D = fe.Constant(0.01)
k1 = fe.Constant(0.1)
k_1 = fe.Constant(0.001)
F = (
(u_cl - u_init_cl) * v_cl * dx
+ dt * D * inner(grad(u_cl), grad(v_cl)) * dx
+ dt * inner(flow, grad(u_cl)) * v_cl * dx
+ (u_na - u_init_na) * v_na * dx
+ dt * D * inner(grad(u_na), grad(v_na)) * dx
+ dt * inner(flow, grad(u_na)) * v_na * dx
+ (u_k - u_init_k) * v_k * dx
+ dt * D * inner(grad(u_k), grad(v_k)) * dx
+ dt * inner(flow, grad(u_k)) * v_k * dx
+ f_in * v_cl * dx
+ f_in * v_na * dx
+ f_in * v_k * dx
+ dt * k1 * u_init_cl * u_init_na * v_cl * dx
+ dt * k1 * u_init_cl * u_init_na * v_na * dx
- dt * k1 * u_init_cl * u_init_na * v_k * dx
- dt * k_1 * u_init_k * v_cl * dx
- dt * k_1 * u_init_k * v_na * dx
+ dt * k_1 * u_init_k * v_k * dx
)
self.F = F
a, L = fe.lhs(F), fe.rhs(F)
a_mat = fe.assemble(a)
L_vec = fe.assemble(L)
output1 = fe.File('/tmp/cl_dyn.pvd')
output2 = fe.File('/tmp/na_dyn.pvd')
output3 = fe.File('/tmp/k_dyn.pvd')
output4 = fe.File('/tmp/all_dyn.pvd')
# solve
self.sol = []
while t < t_end:
t = t + dt
print(t)
u = Function(V)
a_mat = fe.assemble(a)
L_vec = fe.assemble(L)
fe.solve(a_mat, u.vector(), L_vec)
# NonlinearVariationalProblem(F,u)
u_init.assign(u)
u_cl, u_na, u_k = u.split()
# u_init_cl.assign(u_cl)
# u_init_na.assign(u_na)
# u_init_k.assign(u_k)
u_cl.rename("cl", "cl")
u_na.rename("na", "na")
u_k.rename("k", "k")
output1 << u_cl, t
output2 << u_na, t
output3 << u_k, t
self.sol.append((u_cl, u_na, u_k))
self.u_cl = u_cl
self.u_na = u_na
self.u_k = u_k
def project_gradient(
f0,
mesh=None,
degree=None,
debug=False,
solver_type='gmres',
preconditioner_type='default'
):
"""Find an approximation to f0 that has the same gradient
Parameters:
f0: the function to approximate
mesh=None: the mesh on which to approximate it. If not provided, the
mesh is extracted from f0.
degree=None: degree of the polynomial approximation. extracted
from f0 if not provided.
solver_type='gmres': The linear solver type to use.
preconditioner_type='default': Preconditioner type to use
"""
if not mesh: mesh = f0.function_space().mesh()
element = f0.ufl_element()
if not degree:
degree = element.degree()
CE = FiniteElement('CG', mesh.ufl_cell(), degree)
CS = FunctionSpace(mesh, CE)
DE = FiniteElement('DG', mesh.ufl_cell(), degree)
DS = FunctionSpace(mesh, DE)
CVE = VectorElement('CG', mesh.ufl_cell(), degree - 1)
CV = FunctionSpace(mesh, CVE)
RE = FiniteElement('R', mesh.ufl_cell(), 0)
R = FunctionSpace(mesh, RE)
CRE = MixedElement([CE, RE])
CR = FunctionSpace(mesh, CRE)
f = fe.project(f0, CS,
solver_type=solver_type,
preconditioner_type= preconditioner_type)
g = fe.project(fe.grad(f), CV,
solver_type=solver_type,
preconditioner_type= preconditioner_type)
tf, tc = TrialFunction(CR)
wf, wc = TestFunctions(CR)
dx = Measure('dx', domain=mesh,
metadata={'quadrature_degree': min(degree, 10)})
a = (fe.dot(fe.grad(tf), fe.grad(wf)) + tc * wf + tf * wc) * fe.dx
L = (f * wc + fe.dot(g, fe.grad(wf))) * fe.dx
igc = Function(CR)
fe.solve(a == L, igc,
solver_parameters={'linear_solver': solver_type,
'preconditioner': preconditioner_type}
)
if debug:
print('igc', igc.vector()[:])
assigner = FunctionAssigner(CS, CR.sub(0))
# ig = Function(CS)
# assigner.assign(ig, igc.sub(0))
# fe.assign(ig, igc.sub(0))
# if debug:
# print('ig', igc.sub(0).vector()[:])
igd = fe.project(igc.sub(0), DS,
solver_type=solver_type,
preconditioner_type=preconditioner_type)
if debug:
print('igd', igd.vector()[:])
return igd