def monolithic_solve():
"""Monolithic (interleaved) solver"""
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = dolfinx.FunctionSpace(mesh, TH)
(u, p) = ufl.TrialFunctions(W)
(v, q) = ufl.TestFunctions(W)
a00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a = a00 + a01 + a10
p00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
p11 = ufl.inner(p, q) * dx
p_form = p00 + p11
f = dolfinx.Function(W.sub(0).collapse())
p_zero = dolfinx.Function(W.sub(1).collapse())
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
bdofsW0_P2_0 = dolfinx.fem.locate_dofs_topological(
(W.sub(0), P2), facetdim, bndry_facets0)
bdofsW0_P2_1 = dolfinx.fem.locate_dofs_topological(
(W.sub(0), P2), facetdim, bndry_facets1)
bc0 = dolfinx.DirichletBC(u0, bdofsW0_P2_0, W.sub(0))
bc1 = dolfinx.DirichletBC(u0, bdofsW0_P2_1, W.sub(0))
A = dolfinx.fem.assemble_matrix(a, [bc0, bc1])
A.assemble()
P = dolfinx.fem.assemble_matrix(p_form, [bc0, bc1])
P.assemble()
b = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b, [a], [[bc0, bc1]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b, [bc0, bc1])
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A, P)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x = A.createVecRight()
ksp.solve(b, x)
assert ksp.getConvergedReason() > 0
return b.norm(), x.norm(), A.norm(), P.norm()
def computeVelocityField(mesh):
Xh = dl.VectorFunctionSpace(mesh,'Lagrange', 2)
Wh = dl.FunctionSpace(mesh, 'Lagrange', 1)
mixed_element = dl.MixedElement([Xh.ufl_element(), Wh.ufl_element()])
XW = dl.FunctionSpace(mesh, mixed_element)
Re = 1e2
g = dl.Expression(('0.0','(x[0] < 1e-14) - (x[0] > 1 - 1e-14)'), element=Xh.ufl_element())
bc1 = dl.DirichletBC(XW.sub(0), g, v_boundary)
bc2 = dl.DirichletBC(XW.sub(1), dl.Constant(0), q_boundary, 'pointwise')
bcs = [bc1, bc2]
vq = dl.Function(XW)
(v,q) = ufl.split(vq)
(v_test, q_test) = dl.TestFunctions (XW)
def strain(v):
return ufl.sym(ufl.grad(v))
F = ( (2./Re)*ufl.inner(strain(v),strain(v_test))+ ufl.inner (ufl.nabla_grad(v)*v, v_test)
- (q * ufl.div(v_test)) + ( ufl.div(v) * q_test) ) * ufl.dx
dl.solve(F == 0, vq, bcs, solver_parameters={"newton_solver":
{"relative_tolerance":1e-4, "maximum_iterations":100,
"linear_solver":"default"}})
return v
def norm(v, norm_type="L2", degree=None):
"""Compute the norm of ``v``.
:arg v: a ufl expression (:class:`~.ufl.classes.Expr`) to compute the norm of
:arg norm_type: the type of norm to compute, see below for
options.
Available norm types are:
* L2
.. math::
||v||_{L^2}^2 = \int (v, v) \mathrm{d}x
* H1
.. math::
||v||_{H^1}^2 = \int (v, v) + (\\nabla v, \\nabla v) \mathrm{d}x
* Hdiv
.. math::
||v||_{H_\mathrm{div}}^2 = \int (v, v) + (\\nabla\cdot v, \\nabla \cdot v) \mathrm{d}x
* Hcurl
.. math::
||v||_{H_\mathrm{curl}}^2 = \int (v, v) + (\\nabla \wedge v, \\nabla \wedge v) \mathrm{d}x
"""
if not degree == None:
dxn = dx(2 * degree + 1)
else:
dxn = dx
typ = norm_type.lower()
if typ == 'l2':
form = inner(v, v) * dxn
elif typ == 'h1':
form = inner(v, v) * dxn + inner(grad(v), grad(v)) * dxn
elif typ == "hdiv":
form = inner(v, v) * dxn + div(v) * div(v) * dxn
elif typ == "hcurl":
form = inner(v, v) * dxn + inner(curl(v), curl(v)) * dxn
else:
raise RuntimeError("Unknown norm type '%s'" % norm_type)
normform = ZeroForm(form)
return sqrt(normform.assembleform())
def norm(v, norm_type="L2", mesh=None):
"""Compute the norm of ``v``.
:arg v: a :class:`.Function` to compute the norm of
:arg norm_type: the type of norm to compute, see below for
options.
:arg mesh: an optional mesh on which to compute the norm
(currently ignored).
Available norm types are:
* L2
.. math::
||v||_{L^2}^2 = \int (v, v) \mathrm{d}x
* H1
.. math::
||v||_{H^1}^2 = \int (v, v) + (\\nabla v, \\nabla v) \mathrm{d}x
* Hdiv
.. math::
||v||_{H_\mathrm{div}}^2 = \int (v, v) + (\\nabla\cdot v, \\nabla \cdot v) \mathrm{d}x
* Hcurl
.. math::
||v||_{H_\mathrm{curl}}^2 = \int (v, v) + (\\nabla \wedge v, \\nabla \wedge v) \mathrm{d}x
"""
assert isinstance(v, function.Function)
typ = norm_type.lower()
mesh = v.function_space().mesh()
dx = mesh._dx
if typ == 'l2':
form = inner(v, v)*dx
elif typ == 'h1':
form = inner(v, v)*dx + inner(grad(v), grad(v))*dx
elif typ == "hdiv":
form = inner(v, v)*dx + div(v)*div(v)*dx
elif typ == "hcurl":
form = inner(v, v)*dx + inner(curl(v), curl(v))*dx
else:
raise RuntimeError("Unknown norm type '%s'" % norm_type)
return sqrt(solving.assemble(form))
def norm(v, norm_type="L2", mesh=None):
"""Compute the norm of ``v``.
:arg v: a :class:`.Function` to compute the norm of
:arg norm_type: the type of norm to compute, see below for
options.
:arg mesh: an optional mesh on which to compute the norm
(currently ignored).
Available norm types are:
* L2
.. math::
||v||_{L^2}^2 = \int (v, v) \mathrm{d}x
* H1
.. math::
||v||_{H^1}^2 = \int (v, v) + (\\nabla v, \\nabla v) \mathrm{d}x
* Hdiv
.. math::
||v||_{H_\mathrm{div}}^2 = \int (v, v) + (\\nabla\cdot v, \\nabla \cdot v) \mathrm{d}x
* Hcurl
.. math::
||v||_{H_\mathrm{curl}}^2 = \int (v, v) + (\\nabla \wedge v, \\nabla \wedge v) \mathrm{d}x
"""
assert isinstance(v, function.Function)
typ = norm_type.lower()
mesh = v.function_space().mesh()
dx = mesh._dx
if typ == 'l2':
form = inner(v, v)*dx
elif typ == 'h1':
form = inner(v, v)*dx + inner(grad(v), grad(v))*dx
elif typ == "hdiv":
form = inner(v, v)*dx + div(v)*div(v)*dx
elif typ == "hcurl":
form = inner(v, v)*dx + inner(curl(v), curl(v))*dx
else:
raise RuntimeError("Unknown norm type '%s'" % norm_type)
return sqrt(assemble(form))
def computeVelocityField(self):
"""
The steady-state Navier-Stokes equation for velocity v:
-1/Re laplace v + nabla q + v dot nabla v = 0 in Omega
nabla dot v = 0 in Omega
v = g on partial Omega
"""
Xh = dl.VectorFunctionSpace(self.mesh, 'Lagrange', self.eldeg)
Wh = dl.FunctionSpace(self.mesh, 'Lagrange', 1)
mixed_element = dl.MixedElement([Xh.ufl_element(), Wh.ufl_element()])
XW = dl.FunctionSpace(self.mesh, mixed_element)
Re = dl.Constant(self.Re)
def v_boundary(x, on_boundary):
return on_boundary
def q_boundary(x, on_boundary):
return x[0] < dl.DOLFIN_EPS and x[1] < dl.DOLFIN_EPS
g = dl.Expression(('0.0', '(x[0] < 1e-14) - (x[0] > 1 - 1e-14)'),
element=Xh.ufl_element())
bc1 = dl.DirichletBC(XW.sub(0), g, v_boundary)
bc2 = dl.DirichletBC(XW.sub(1), dl.Constant(0), q_boundary,
'pointwise')
bcs = [bc1, bc2]
vq = dl.Function(XW)
(v, q) = ufl.split(vq)
(v_test, q_test) = dl.TestFunctions(XW)
def strain(v):
return ufl.sym(ufl.grad(v))
F = ((2. / Re) * ufl.inner(strain(v), strain(v_test)) +
ufl.inner(ufl.nabla_grad(v) * v, v_test) - (q * ufl.div(v_test)) +
(ufl.div(v) * q_test)) * ufl.dx
dl.solve(F == 0,
vq,
bcs,
solver_parameters={
"newton_solver": {
"relative_tolerance": 1e-4,
"maximum_iterations": 100,
"linear_solver": "default"
}
})
return v
def r2_norm(v, func_degree=None, norm_type="L2", mesh=None):
"""
This function is a modification of FEniCS's built-in norm function that adopts the :math:`r^2dr`
measure as opposed to the standard Cartesian :math:`dx` measure.
For documentation and usage, see the
original module <https://bitbucket.org/fenics-project/dolfin/src/master/python/dolfin/fem/norms.py>_.
.. note:: Note the extra argument func_degree: this is used to interpolate the :math:`r^2`
Expression to the same degree as used in the definition of the Trial and Test function
spaces.
"""
# Get mesh from function
if isinstance(v, cpp.function.Function) and mesh is None:
mesh = v.function_space().mesh()
# Define integration measure and domain
dx = ufl.dx(mesh)
# Select norm type
if isinstance(v, GenericVector):
return v.norm(norm_type.lower())
elif (isinstance(v, Coefficient) and isinstance(v, Function)):
# DS: HERE IS WHERE I MODIFY
r2 = Expression('pow(x[0],2)', degree=func_degree)
if norm_type.lower() == "l2":
M = v**2 * r2 * dx
elif norm_type.lower() == "h1":
M = (v**2 + grad(v)**2) * r2 * dx
elif norm_type.lower() == "h10":
M = grad(v)**2 * r2 * dx
elif norm_type.lower() == "hdiv":
M = (v**2 + div(v)**2) * r2 * dx
elif norm_type.lower() == "hdiv0":
M = div(v)**2 * r2 * dx
elif norm_type.lower() == "hcurl":
M = (v**2 + curl(v)**2) * r2 * dx
elif norm_type.lower() == "hcurl0":
M = curl(v)**2 * r2 * dx
else:
raise ValueError("Unknown norm type {}".format(str(norm_type)))
else:
raise TypeError("Do not know how to compute norm of {}".format(str(v)))
# Assemble value and return
return sqrt(assemble(M))
def norm(v, norm_type="L2", mesh=None):
"""Compute the norm of ``v``.
:arg v: a ufl expression (:class:`~.ufl.classes.Expr`) to compute the norm of
:arg norm_type: the type of norm to compute, see below for
options.
:arg mesh: an optional mesh on which to compute the norm
(currently ignored).
Available norm types are:
* L2
.. math::
||v||_{L^2}^2 = \int (v, v) \mathrm{d}x
* H1
.. math::
||v||_{H^1}^2 = \int (v, v) + (\\nabla v, \\nabla v) \mathrm{d}x
* Hdiv
.. math::
||v||_{H_\mathrm{div}}^2 = \int (v, v) + (\\nabla\cdot v, \\nabla \cdot v) \mathrm{d}x
* Hcurl
.. math::
||v||_{H_\mathrm{curl}}^2 = \int (v, v) + (\\nabla \wedge v, \\nabla \wedge v) \mathrm{d}x
"""
typ = norm_type.lower()
if typ == 'l2':
form = inner(v, v)*dx
elif typ == 'h1':
form = inner(v, v)*dx + inner(grad(v), grad(v))*dx
elif typ == "hdiv":
form = inner(v, v)*dx + div(v)*div(v)*dx
elif typ == "hcurl":
form = inner(v, v)*dx + inner(curl(v), curl(v))*dx
else:
raise RuntimeError("Unknown norm type '%s'" % norm_type)
return sqrt(assemble(form))
def nonlinearity(function):
if self.use_ema:
return 2*inner(dot(sym(grad(function)), u_ext), v1) * dx + inner(div(function)*u_ext, v1) * dx
# return 2*inner(dot(sym(grad(function)), u_ext), v) * dx + inner(div(u_ext)*function, v) * dx
# QQ implement this way?
else:
return inner(dot(grad(function), u_ext), v1) * dx
def assemble_div_vector(k, offset):
mesh = create_quad_mesh(offset)
V = FunctionSpace(mesh, ("RTCF", k + 1))
v = ufl.TestFunction(V)
form = ufl.inner(Constant(mesh, 1), ufl.div(v)) * ufl.dx
L = fem.assemble_vector(form)
return L[:]
def monolithic_assembly(clock, reps, mesh, use_cpp_forms):
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = dolfinx.FunctionSpace(mesh, TH)
num_dofs = W.dim
U = dolfinx.Function(W)
u, p = ufl.split(U)
v, q = ufl.TestFunctions(W)
g = ufl.as_vector([0.0, 0.0, -1.0])
F = (
ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
+ ufl.inner(p, ufl.div(v)) * ufl.dx
+ ufl.inner(ufl.div(u), q) * ufl.dx
- ufl.inner(g, v) * ufl.dx
)
J = ufl.derivative(F, U, ufl.TrialFunction(W))
bcs = []
# Get jitted forms for better performance
if use_cpp_forms:
F = dolfinx.fem.assemble._create_cpp_form(F)
J = dolfinx.fem.assemble._create_cpp_form(J)
b = dolfinx.fem.create_vector(F)
A = dolfinx.fem.create_matrix(J)
for i in range(reps):
A.zeroEntries()
with b.localForm() as b_local:
b_local.set(0.0)
with dolfinx.common.Timer("ZZZ Mat Monolithic") as tmr:
dolfinx.fem.assemble_matrix(A, J, bcs)
A.assemble()
clock["mat"] += tmr.elapsed()[0]
with dolfinx.common.Timer("ZZZ Vec Monolithic") as tmr:
dolfinx.fem.assemble_vector(b, F)
dolfinx.fem.apply_lifting(b, [J], bcs=[bcs], x0=[U.vector], scale=-1.0)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b, bcs, x0=U.vector, scale=-1.0)
b.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
clock["vec"] += tmr.elapsed()[0]
return num_dofs, A, b
def run_scalar_test(mesh, V, degree):
""" Manufactured Poisson problem, solving u = x[1]**p, where p is the
degree of the Lagrange function space.
"""
u, v = TrialFunction(V), TestFunction(V)
a = inner(grad(u), grad(v)) * dx
# Get quadrature degree for bilinear form integrand (ignores effect of non-affine map)
a = inner(grad(u), grad(v)) * dx(metadata={"quadrature_degree": -1})
a.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(a)
a = form(a)
# Source term
x = SpatialCoordinate(mesh)
u_exact = x[1]**degree
f = -div(grad(u_exact))
# Set quadrature degree for linear form integrand (ignores effect of non-affine map)
L = inner(f, v) * dx(metadata={"quadrature_degree": -1})
L.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(L)
L = form(L)
u_bc = Function(V)
u_bc.interpolate(lambda x: x[1]**degree)
# Create Dirichlet boundary condition
facetdim = mesh.topology.dim - 1
mesh.topology.create_connectivity(facetdim, mesh.topology.dim)
bndry_facets = np.where(
np.array(compute_boundary_facets(mesh.topology)) == 1)[0]
bdofs = locate_dofs_topological(V, facetdim, bndry_facets)
bc = dirichletbc(u_bc, bdofs)
b = assemble_vector(L)
apply_lifting(b, [a], bcs=[[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
a = form(a)
A = assemble_matrix(a, bcs=[bc])
A.assemble()
# Create LU linear solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
uh = Function(V)
solver.solve(b, uh.vector)
uh.x.scatter_forward()
M = (u_exact - uh)**2 * dx
M = form(M)
error = mesh.comm.allreduce(assemble_scalar(M), op=MPI.SUM)
assert np.absolute(error) < 1.0e-14
def __init__(self, mesh, Vh, prior, misfit, simulation_times,
wind_velocity, gls_stab):
self.mesh = mesh
self.Vh = Vh
self.prior = prior
self.misfit = misfit
# Assume constant timestepping
self.simulation_times = simulation_times
dt = simulation_times[1] - simulation_times[0]
u = dl.TrialFunction(Vh[STATE])
v = dl.TestFunction(Vh[STATE])
kappa = dl.Constant(.001)
dt_expr = dl.Constant(dt)
r_trial = u + dt_expr * (-ufl.div(kappa * ufl.grad(u)) +
ufl.inner(wind_velocity, ufl.grad(u)))
r_test = v + dt_expr * (-ufl.div(kappa * ufl.grad(v)) +
ufl.inner(wind_velocity, ufl.grad(v)))
h = dl.CellDiameter(mesh)
vnorm = ufl.sqrt(ufl.inner(wind_velocity, wind_velocity))
if gls_stab:
tau = ufl.min_value((h * h) / (dl.Constant(2.) * kappa), h / vnorm)
else:
tau = dl.Constant(0.)
self.M = dl.assemble(ufl.inner(u, v) * dl.dx)
self.M_stab = dl.assemble(ufl.inner(u, v + tau * r_test) * dl.dx)
self.Mt_stab = dl.assemble(ufl.inner(u + tau * r_trial, v) * dl.dx)
Nvarf = (ufl.inner(kappa * ufl.grad(u), ufl.grad(v)) +
ufl.inner(wind_velocity, ufl.grad(u)) * v) * dl.dx
Ntvarf = (ufl.inner(kappa * ufl.grad(v), ufl.grad(u)) +
ufl.inner(wind_velocity, ufl.grad(v)) * u) * dl.dx
self.N = dl.assemble(Nvarf)
self.Nt = dl.assemble(Ntvarf)
stab = dl.assemble(tau * ufl.inner(r_trial, r_test) * dl.dx)
self.L = self.M + dt * self.N + stab
self.Lt = self.M + dt * self.Nt + stab
self.solver = dl.PETScLUSolver(dl.as_backend_type(self.L))
self.solvert = dl.PETScLUSolver(dl.as_backend_type(self.Lt))
# Part of model public API
self.gauss_newton_approx = False
def assemble_div_vector(k, offset):
mesh = create_quad_mesh(offset)
V = FunctionSpace(mesh, ("RTCF", k + 1))
v = ufl.TestFunction(V)
L = form(
ufl.inner(Constant(mesh, PETSc.ScalarType(1)), ufl.div(v)) * ufl.dx)
b = assemble_vector(L)
return b[:]
def assemble_div_matrix(k, offset):
mesh = create_quad_mesh(offset)
V = FunctionSpace(mesh, ("DQ", k))
W = FunctionSpace(mesh, ("RTCF", k + 1))
u, w = ufl.TrialFunction(V), ufl.TestFunction(W)
form = ufl.inner(u, ufl.div(w)) * ufl.dx
A = fem.assemble_matrix(form)
A.assemble()
return A[:, :]
def set_forms(self):
"""
Set up week forms
"""
# Assume constant timestepping
dt = self.simulation_times[1] - self.simulation_times[0]
self.wind_velocity = self.computeVelocityField()
u = dl.TrialFunction(self.Vh[STATE])
v = dl.TestFunction(self.Vh[STATE])
kappa = dl.Constant(self.kappa)
dt_expr = dl.Constant(dt)
r_trial = u + dt_expr * (-ufl.div(kappa * ufl.grad(u)) +
ufl.inner(self.wind_velocity, ufl.grad(u)))
r_test = v + dt_expr * (-ufl.div(kappa * ufl.grad(v)) +
ufl.inner(self.wind_velocity, ufl.grad(v)))
h = dl.CellDiameter(self.mesh)
vnorm = ufl.sqrt(ufl.inner(self.wind_velocity, self.wind_velocity))
if self.gls_stab:
tau = ufl.min_value((h * h) / (dl.Constant(2.) * kappa), h / vnorm)
else:
tau = dl.Constant(0.)
self.M = dl.assemble(ufl.inner(u, v) * ufl.dx)
self.M_stab = dl.assemble(ufl.inner(u, v + tau * r_test) * ufl.dx)
self.Mt_stab = dl.assemble(ufl.inner(u + tau * r_trial, v) * ufl.dx)
Nvarf = (ufl.inner(kappa * ufl.grad(u), ufl.grad(v)) +
ufl.inner(self.wind_velocity, ufl.grad(u)) * v) * ufl.dx
Ntvarf = (ufl.inner(kappa * ufl.grad(v), ufl.grad(u)) +
ufl.inner(self.wind_velocity, ufl.grad(v)) * u) * ufl.dx
self.N = dl.assemble(Nvarf)
self.Nt = dl.assemble(Ntvarf)
stab = dl.assemble(tau * ufl.inner(r_trial, r_test) * ufl.dx)
self.L = self.M + dt * self.N + stab
self.Lt = self.M + dt * self.Nt + stab
self.solver = PETScLUSolver(self.mpi_comm)
self.solver.set_operator(dl.as_backend_type(self.L))
self.solvert = PETScLUSolver(self.mpi_comm)
self.solvert.set_operator(dl.as_backend_type(self.Lt))
def save_vel(self, is_tent, field, t):
self.vFunction.assign(field)
self.fileDict['u2' if is_tent else 'u']['file'] << self.vFunction
if self.doSaveDiff:
self.vFunction.assign((1.0 / self.vel_normalization_factor[0]) * (field - self.solution))
self.fileDict['u2D' if is_tent else 'uD']['file'] << self.vFunction
if self.args.ldsg:
# info(div(2.*sym(grad(field))-grad(field)).ufl_shape)
form = div(2.*sym(grad(field))-grad(field))
self.pFunction.assign(project(sqrt_ufl(inner(form, form)), self.pSpace))
self.fileDict['ldsg2' if is_tent else 'ldsg']['file'] << self.pFunction
def split_mixed_poisson(cell, degree):
m = Mesh(VectorElement('CG', cell, 1))
if cell.cellname() in ['interval * interval', 'quadrilateral']:
hdiv_element = FiniteElement('RTCF', cell, degree)
elif cell.cellname() == 'triangle * interval':
U0 = FiniteElement('RT', triangle, degree)
U1 = FiniteElement('DG', triangle, degree - 1)
V0 = FiniteElement('CG', interval, degree)
V1 = FiniteElement('DG', interval, degree - 1)
Wa = HDivElement(TensorProductElement(U0, V1))
Wb = HDivElement(TensorProductElement(U1, V0))
hdiv_element = EnrichedElement(Wa, Wb)
elif cell.cellname() == 'quadrilateral * interval':
hdiv_element = FiniteElement('NCF', cell, degree)
RT = FunctionSpace(m, hdiv_element)
DG = FunctionSpace(m, FiniteElement('DQ', cell, degree - 1))
sigma = TrialFunction(RT)
u = TrialFunction(DG)
tau = TestFunction(RT)
v = TestFunction(DG)
return [dot(sigma, tau) * dx, div(tau) * u * dx, div(sigma) * v * dx]
def test_expand_indices():
element = FiniteElement("Lagrange", triangle, 2)
v = TestFunction(element)
u = TrialFunction(element)
def evaluate(form):
return form.cell_integral()[0].integrand()((), {v: 3, u: 5}) # TODO: How to define values of derivatives?
a = div(grad(v)) * u * dx
# a1 = evaluate(a)
a = expand_derivatives(a)
# a2 = evaluate(a)
a = expand_indices(a)
def norm(v, norm_type="L2", mesh=None):
r"""Compute the norm of ``v``.
:arg v: a ufl expression (:class:`~.ufl.classes.Expr`) to compute the norm of
:arg norm_type: the type of norm to compute, see below for
options.
:arg mesh: an optional mesh on which to compute the norm
(currently ignored).
Available norm types are:
- Lp :math:`||v||_{L^p} = (\int |v|^p)^{\frac{1}{p}} \mathrm{d}x`
- H1 :math:`||v||_{H^1}^2 = \int (v, v) + (\nabla v, \nabla v) \mathrm{d}x`
- Hdiv :math:`||v||_{H_\mathrm{div}}^2 = \int (v, v) + (\nabla\cdot v, \nabla \cdot v) \mathrm{d}x`
- Hcurl :math:`||v||_{H_\mathrm{curl}}^2 = \int (v, v) + (\nabla \wedge v, \nabla \wedge v) \mathrm{d}x`
"""
typ = norm_type.lower()
p = 2
if typ == 'l2':
expr = inner(v, v)
elif typ.startswith('l'):
try:
p = int(typ[1:])
if p < 1:
raise ValueError
except ValueError:
raise ValueError("Don't know how to interpret %s-norm" % norm_type)
expr = inner(v, v)
elif typ == 'h1':
expr = inner(v, v) + inner(grad(v), grad(v))
elif typ == "hdiv":
expr = inner(v, v) + div(v)*div(v)
elif typ == "hcurl":
expr = inner(v, v) + inner(curl(v), curl(v))
else:
raise RuntimeError("Unknown norm type '%s'" % norm_type)
return assemble((expr**(p/2))*dx)**(1/p)
def test_expand_indices():
element = FiniteElement("Lagrange", triangle, 2)
v = TestFunction(element)
u = TrialFunction(element)
def evaluate(form):
return form.cell_integral()[0].integrand()((), {
v: 3,
u: 5
}) # TODO: How to define values of derivatives?
a = div(grad(v)) * u * dx
# a1 = evaluate(a)
a = expand_derivatives(a)
# a2 = evaluate(a)
a = expand_indices(a)
def test_manufactured_poisson(degree, filename, datadir):
""" Manufactured Poisson problem, solving u = x[1]**p, where p is the
degree of the Lagrange function space.
"""
with XDMFFile(MPI.comm_world, os.path.join(datadir, filename)) as xdmf:
mesh = xdmf.read_mesh(GhostMode.none)
V = FunctionSpace(mesh, ("Lagrange", degree))
u, v = TrialFunction(V), TestFunction(V)
a = inner(grad(u), grad(v)) * dx
# Get quadrature degree for bilinear form integrand (ignores effect
# of non-affine map)
a = inner(grad(u), grad(v)) * dx(metadata={"quadrature_degree": -1})
a.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(a)
# Source term
x = SpatialCoordinate(mesh)
u_exact = x[1]**degree
f = -div(grad(u_exact))
# Set quadrature degree for linear form integrand (ignores effect of
# non-affine map)
L = inner(f, v) * dx(metadata={"quadrature_degree": -1})
L.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(L)
t0 = time.time()
L = fem.Form(L)
t1 = time.time()
print("Linear form compile time:", t1 - t0)
u_bc = Function(V)
u_bc.interpolate(lambda x: x[1]**degree)
# Create Dirichlet boundary condition
mesh.create_connectivity_all()
facetdim = mesh.topology.dim - 1
bndry_facets = np.where(
np.array(mesh.topology.on_boundary(facetdim)) == 1)[0]
bdofs = locate_dofs_topological(V, facetdim, bndry_facets)
assert (len(bdofs) < V.dim())
bc = DirichletBC(u_bc, bdofs)
t0 = time.time()
b = assemble_vector(L)
apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
t1 = time.time()
print("Vector assembly time:", t1 - t0)
t0 = time.time()
a = fem.Form(a)
t1 = time.time()
print("Bilinear form compile time:", t1 - t0)
t0 = time.time()
A = assemble_matrix(a, [bc])
A.assemble()
t1 = time.time()
print("Matrix assembly time:", t1 - t0)
# Create LU linear solver
solver = PETSc.KSP().create(MPI.comm_world)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
# Solve
t0 = time.time()
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
t1 = time.time()
print("Linear solver time:", t1 - t0)
M = (u_exact - uh)**2 * dx
t0 = time.time()
M = fem.Form(M)
t1 = time.time()
print("Error functional compile time:", t1 - t0)
t0 = time.time()
error = assemble_scalar(M)
error = MPI.sum(mesh.mpi_comm(), error)
t1 = time.time()
print("Error assembly time:", t1 - t0)
assert np.absolute(error) < 1.0e-14
lid_velocity.interpolate(lid_velocity_expression)
facets = locate_entities_boundary(mesh, 1, lid)
bc1 = DirichletBC(lid_velocity, locate_dofs_topological(V, 1, facets))
# Collect Dirichlet boundary conditions
bcs = [bc0, bc1]
# We now define the bilinear and linear forms corresponding to the weak
# mixed formulation of the Stokes equations in a blocked structure::
# Define variational problem
(u, p) = ufl.TrialFunction(V), ufl.TrialFunction(Q)
(v, q) = ufl.TestFunction(V), ufl.TestFunction(Q)
f = dolfinx.Constant(mesh, (0, 0))
a = [[inner(grad(u), grad(v)) * dx, inner(p, div(v)) * dx],
[inner(div(u), q) * dx, None]]
L = [inner(f, v) * dx,
inner(dolfinx.Constant(mesh, 0), q) * dx]
# We will use a block-diagonal preconditioner to solve this problem::
a_p11 = inner(p, q) * dx
a_p = [[a[0][0], None],
[None, a_p11]]
# Nested matrix solver
# ^^^^^^^^^^^^^^^^^^^^
#
# We now assemble the bilinear form into a nested matrix `A`, and call
def pressure_rhs():
if self.useLaplace or self.bcv == 'LAP':
return inner(p0, div(v1)) * dx - inner(p0*n, v1) * problem.get_outflow_measure_form()
# NT term inner(inner(p, n), v) is 0 when p=0 on outflow
else:
return inner(p0, div(v1)) * dx
def nonlinearity(function):
if self.args.ema:
return 2 * inner(dot(sym(grad(function)), u_ext), v1) * dx + inner(div(function) * u_ext, v1) * dx
else:
return inner(dot(grad(function), u_ext), v1) * dx
def test_assembly_solve_taylor_hood_nl(mesh):
"""Assemble Stokes problem with Taylor-Hood elements and solve."""
gdim = mesh.geometry.dim
P2 = VectorFunctionSpace(mesh, ("Lagrange", 2))
P1 = FunctionSpace(mesh, ("Lagrange", 1))
def boundary0(x):
"""Define boundary x = 0"""
return np.isclose(x[0], 0.0)
def boundary1(x):
"""Define boundary x = 1"""
return np.isclose(x[0], 1.0)
def initial_guess_u(x):
u_init = np.row_stack(
(np.sin(x[0]) * np.sin(x[1]), np.cos(x[0]) * np.cos(x[1])))
if gdim == 3:
u_init = np.row_stack((u_init, np.cos(x[2])))
return u_init
def initial_guess_p(x):
return -x[0]**2 - x[1]**3
u_bc_0 = Function(P2)
u_bc_0.interpolate(
lambda x: np.row_stack(tuple(x[j] + float(j) for j in range(gdim))))
u_bc_1 = Function(P2)
u_bc_1.interpolate(
lambda x: np.row_stack(tuple(np.sin(x[j]) for j in range(gdim))))
facetdim = mesh.topology.dim - 1
bndry_facets0 = locate_entities_boundary(mesh, facetdim, boundary0)
bndry_facets1 = locate_entities_boundary(mesh, facetdim, boundary1)
bdofs0 = locate_dofs_topological(P2, facetdim, bndry_facets0)
bdofs1 = locate_dofs_topological(P2, facetdim, bndry_facets1)
bcs = [dirichletbc(u_bc_0, bdofs0), dirichletbc(u_bc_1, bdofs1)]
u, p = Function(P2), Function(P1)
du, dp = ufl.TrialFunction(P2), ufl.TrialFunction(P1)
v, q = ufl.TestFunction(P2), ufl.TestFunction(P1)
F = [
inner(ufl.grad(u), ufl.grad(v)) * dx + inner(p, ufl.div(v)) * dx,
inner(ufl.div(u), q) * dx
]
J = [[derivative(F[0], u, du),
derivative(F[0], p, dp)],
[derivative(F[1], u, du),
derivative(F[1], p, dp)]]
P = [[J[0][0], None], [None, inner(dp, q) * dx]]
F, J, P = form(F), form(J), form(P)
# -- Blocked and monolithic
Jmat0 = create_matrix_block(J)
Pmat0 = create_matrix_block(P)
Fvec0 = create_vector_block(F)
snes = PETSc.SNES().create(MPI.COMM_WORLD)
snes.setTolerances(rtol=1.0e-15, max_it=10)
snes.getKSP().setType("minres")
snes.getKSP().getPC().setType("lu")
problem = NonlinearPDE_SNESProblem(F, J, [u, p], bcs, P=P)
snes.setFunction(problem.F_block, Fvec0)
snes.setJacobian(problem.J_block, J=Jmat0, P=Pmat0)
u.interpolate(initial_guess_u)
p.interpolate(initial_guess_p)
x0 = create_vector_block(F)
with u.vector.localForm() as _u, p.vector.localForm() as _p:
scatter_local_vectors(x0, [_u.array_r, _p.array_r],
[(u.function_space.dofmap.index_map,
u.function_space.dofmap.index_map_bs),
(p.function_space.dofmap.index_map,
p.function_space.dofmap.index_map_bs)])
x0.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
snes.solve(None, x0)
assert snes.getConvergedReason() > 0
# -- Blocked and nested
Jmat1 = create_matrix_nest(J)
Pmat1 = create_matrix_nest(P)
Fvec1 = create_vector_nest(F)
snes = PETSc.SNES().create(MPI.COMM_WORLD)
snes.setTolerances(rtol=1.0e-15, max_it=10)
nested_IS = Jmat1.getNestISs()
snes.getKSP().setType("minres")
snes.getKSP().setTolerances(rtol=1e-12)
snes.getKSP().getPC().setType("fieldsplit")
snes.getKSP().getPC().setFieldSplitIS(["u", nested_IS[0][0]],
["p", nested_IS[1][1]])
ksp_u, ksp_p = snes.getKSP().getPC().getFieldSplitSubKSP()
ksp_u.setType("preonly")
ksp_u.getPC().setType('lu')
ksp_p.setType("preonly")
ksp_p.getPC().setType('lu')
problem = NonlinearPDE_SNESProblem(F, J, [u, p], bcs, P=P)
snes.setFunction(problem.F_nest, Fvec1)
snes.setJacobian(problem.J_nest, J=Jmat1, P=Pmat1)
u.interpolate(initial_guess_u)
p.interpolate(initial_guess_p)
x1 = create_vector_nest(F)
for x1_soln_pair in zip(x1.getNestSubVecs(), (u, p)):
x1_sub, soln_sub = x1_soln_pair
soln_sub.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
soln_sub.vector.copy(result=x1_sub)
x1_sub.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
x1.set(0.0)
snes.solve(None, x1)
assert snes.getConvergedReason() > 0
assert nest_matrix_norm(Jmat1) == pytest.approx(Jmat0.norm(), 1.0e-12)
assert Fvec1.norm() == pytest.approx(Fvec0.norm(), 1.0e-12)
assert x1.norm() == pytest.approx(x0.norm(), 1.0e-12)
# -- Monolithic
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = FunctionSpace(mesh, TH)
U = Function(W)
dU = ufl.TrialFunction(W)
u, p = ufl.split(U)
du, dp = ufl.split(dU)
v, q = ufl.TestFunctions(W)
F = inner(ufl.grad(u), ufl.grad(v)) * dx + inner(p, ufl.div(v)) * dx \
+ inner(ufl.div(u), q) * dx
J = derivative(F, U, dU)
P = inner(ufl.grad(du), ufl.grad(v)) * dx + inner(dp, q) * dx
F, J, P = form(F), form(J), form(P)
bdofsW0_P2_0 = locate_dofs_topological((W.sub(0), P2), facetdim,
bndry_facets0)
bdofsW0_P2_1 = locate_dofs_topological((W.sub(0), P2), facetdim,
bndry_facets1)
bcs = [
dirichletbc(u_bc_0, bdofsW0_P2_0, W.sub(0)),
dirichletbc(u_bc_1, bdofsW0_P2_1, W.sub(0))
]
Jmat2 = create_matrix(J)
Pmat2 = create_matrix(P)
Fvec2 = create_vector(F)
snes = PETSc.SNES().create(MPI.COMM_WORLD)
snes.setTolerances(rtol=1.0e-15, max_it=10)
snes.getKSP().setType("minres")
snes.getKSP().getPC().setType("lu")
problem = NonlinearPDE_SNESProblem(F, J, U, bcs, P=P)
snes.setFunction(problem.F_mono, Fvec2)
snes.setJacobian(problem.J_mono, J=Jmat2, P=Pmat2)
U.sub(0).interpolate(initial_guess_u)
U.sub(1).interpolate(initial_guess_p)
x2 = create_vector(F)
x2.array = U.vector.array_r
snes.solve(None, x2)
assert snes.getConvergedReason() > 0
assert Jmat2.norm() == pytest.approx(Jmat0.norm(), 1.0e-12)
assert Fvec2.norm() == pytest.approx(Fvec0.norm(), 1.0e-12)
assert x2.norm() == pytest.approx(x0.norm(), 1.0e-12)
def test_div_grad_then_integrate_over_cells_and_boundary():
# Define 2D geometry
n = 10
mesh = RectangleMesh(Point(0.0, 0.0), Point(2.0, 3.0), 2 * n, 3 * n)
x, y = SpatialCoordinate(mesh)
xs = 0.1 + 0.8 * x / 2 # scaled to be within [0.1,0.9]
# ys = 0.1 + 0.8 * y / 3 # scaled to be within [0.1,0.9]
n = FacetNormal(mesh)
# Define list of expressions to test, and configure accuracies
# these expressions are known to pass with. The reason some
# functions are less accurately integrated is likely that the
# default choice of quadrature rule is not perfect
F_list = []
def reg(exprs, acc=10):
for expr in exprs:
F_list.append((expr, acc))
# FIXME: 0*dx and 1*dx fails in the ufl-ffc-jit framework somewhere
# reg([Constant(0.0, cell=cell)])
# reg([Constant(1.0, cell=cell)])
monomial_list = [x**q for q in range(2, 6)]
reg(monomial_list)
reg([2.3 * p + 4.5 * q for p in monomial_list for q in monomial_list])
reg([xs**xs])
reg(
[xs**(xs**2)], 8
) # Note: Accuracies here are from 1D case, not checked against 2D results.
reg([xs**(xs**3)], 6)
reg([xs**(xs**4)], 2)
# Special functions:
reg([atan(xs)], 8)
reg([sin(x), cos(x), exp(x)], 5)
reg([ln(xs), pow(x, 2.7), pow(2.7, x)], 3)
reg([asin(xs), acos(xs)], 1)
reg([tan(xs)], 7)
# To handle tensor algebra, make an x dependent input tensor
# xx and square all expressions
def reg2(exprs, acc=10):
for expr in exprs:
F_list.append((inner(expr, expr), acc))
xx = as_matrix([[2 * x**2, 3 * x**3], [11 * x**5, 7 * x**4]])
xxs = as_matrix([[2 * xs**2, 3 * xs**3], [11 * xs**5, 7 * xs**4]])
x3v = as_vector([3 * x**2, 5 * x**3, 7 * x**4])
cc = as_matrix([[2, 3], [4, 5]])
reg2(
[xx]
) # TODO: Make unit test for UFL from this, results in listtensor with free indices
reg2([x3v])
reg2([cross(3 * x3v, as_vector([-x3v[1], x3v[0], x3v[2]]))])
reg2([xx.T])
reg2([tr(xx)])
reg2([det(xx)])
reg2([dot(xx, 0.1 * xx)])
reg2([outer(xx, xx.T)])
reg2([dev(xx)])
reg2([sym(xx)])
reg2([skew(xx)])
reg2([elem_mult(7 * xx, cc)])
reg2([elem_div(7 * xx, xx + cc)])
reg2([elem_pow(1e-3 * xxs, 1e-3 * cc)])
reg2([elem_pow(1e-3 * cc, 1e-3 * xx)])
reg2([elem_op(lambda z: sin(z) + 2, 0.03 * xx)], 2) # pretty inaccurate...
# FIXME: Add tests for all UFL operators:
# These cause discontinuities and may be harder to test in the
# above fashion:
# 'inv', 'cofac',
# 'eq', 'ne', 'le', 'ge', 'lt', 'gt', 'And', 'Or', 'Not',
# 'conditional', 'sign',
# 'jump', 'avg',
# 'LiftingFunction', 'LiftingOperator',
# FIXME: Test other derivatives: (but algorithms for operator
# derivatives are the same!):
# 'variable', 'diff',
# 'Dx', 'grad', 'div', 'curl', 'rot', 'Dn', 'exterior_derivative',
# Run through all operators defined above and compare integrals
debug = 0
if debug:
F_list = F_list[1:]
for F, acc in F_list:
if debug:
print('\n', "F:", str(F))
# Integrate over domain and its boundary
int_dx = assemble(div(grad(F)) * dx(mesh)) # noqa
int_ds = assemble(dot(grad(F), n) * ds(mesh)) # noqa
if debug:
print(int_dx, int_ds)
# Compare results. Using custom relative delta instead of
# decimal digits here because some numbers are >> 1.
delta = min(abs(int_dx), abs(int_ds)) * 10**-acc
assert int_dx - int_ds <= delta
def norm(v, norm_type="L2", mesh=None):
"""
Return the norm of a given vector or function.
*Arguments*
v
a :py:class:`Vector <dolfin.cpp.Vector>` or
a :py:class:`Function <dolfin.functions.function.Function>`.
norm_type
see below for alternatives.
mesh
optional :py:class:`Mesh <dolfin.cpp.Mesh>` on
which to compute the norm.
If the norm type is not specified, the standard :math:`L^2` -norm
is computed. Possible norm types include:
*Vectors*
================ ================= ================
Norm Usage
================ ================= ================
:math:`l^2` norm(x, 'l2') Default
:math:`l^1` norm(x, 'l1')
:math:`l^\infty` norm(x, 'linf')
================ ================= ================
*Functions*
================ ================= =================================
Norm Usage Includes the :math:`L^2` -term
================ ================= =================================
:math:`L^2` norm(v, 'L2') Yes
:math:`H^1` norm(v, 'H1') Yes
:math:`H^1_0` norm(v, 'H10') No
:math:`H` (div) norm(v, 'Hdiv') Yes
:math:`H` (div) norm(v, 'Hdiv0') No
:math:`H` (curl) norm(v, 'Hcurl') Yes
:math:`H` (curl) norm(v, 'Hcurl0') No
================ ================= =================================
*Examples of usage*
.. code-block:: python
v = Function(V)
x = v.vector()
print norm(x, 'linf') # print the infinity norm of vector x
n = norm(v) # compute L^2 norm of v
print norm(v, 'Hdiv') # print H(div) norm of v
n = norm(v, 'H1', mesh) # compute H^1 norm of v on given mesh
"""
if not isinstance(v, (GenericVector, GenericFunction)):
raise TypeError, "expected a GenericVector or GenericFunction"
# Check arguments
if not isinstance(norm_type, str):
cpp.dolfin_error("norms.py",
"compute norm",
"Norm type must be a string, not " + str(type(norm_type)))
if mesh is not None and not isinstance(mesh, Mesh):
cpp.dolfin_error("norms.py",
"compute norm",
"Expecting a Mesh, not " + str(type(mesh)))
# Select norm type
if isinstance(v, GenericVector):
return v.norm(norm_type.lower())
elif (isinstance(v, Coefficient) and isinstance(v, GenericFunction)):
if norm_type.lower() == "l2":
M = inner(v, v)*dx()
elif norm_type.lower() == "h1":
M = inner(v, v)*dx() + inner(grad(v), grad(v))*dx()
elif norm_type.lower() == "h10":
M = inner(grad(v), grad(v))*dx()
elif norm_type.lower() == "hdiv":
M = inner(v, v)*dx() + div(v)*div(v)*dx()
elif norm_type.lower() == "hdiv0":
M = div(v)*div(v)*dx()
elif norm_type.lower() == "hcurl":
M = inner(v, v)*dx() + inner(curl(v), curl(v))*dx()
elif norm_type.lower() == "hcurl0":
M = inner(curl(v), curl(v))*dx()
else:
cpp.dolfin_error("norms.py",
"compute norm",
"Unknown norm type (\"%s\") for functions" % str(norm_type))
else:
cpp.dolfin_error("norms.py",
"compute norm",
"Unknown object type. Must be a vector or a function")
# Get mesh
if isinstance(v, Function) and mesh is None:
mesh = v.function_space().mesh()
# Assemble value
r = assemble(M, mesh=mesh, form_compiler_parameters={"representation": "quadrature"})
# Check value
if r < 0.0:
cpp.dolfin_error("norms.py",
"compute norm",
"Square of norm is negative, might be a round-off error")
elif r == 0.0:
return 0.0
else:
return sqrt(r)
def solve(self, problem):
self.problem = problem
doSave = problem.doSave
save_this_step = False
onlyVel = problem.saveOnlyVel
dt = self.metadata['dt']
nu = Constant(self.problem.nu)
self.tc.init_watch('init', 'Initialization', True, count_to_percent=False)
self.tc.init_watch('rhs', 'Assembled right hand side', True, count_to_percent=True)
self.tc.init_watch('applybc1', 'Applied velocity BC 1st step', True, count_to_percent=True)
self.tc.init_watch('applybc3', 'Applied velocity BC 3rd step', True, count_to_percent=True)
self.tc.init_watch('applybcP', 'Applied pressure BC or othogonalized rhs', True, count_to_percent=True)
self.tc.init_watch('assembleMatrices', 'Initial matrix assembly', False, count_to_percent=True)
self.tc.init_watch('solve 1', 'Running solver on 1st step', True, count_to_percent=True)
self.tc.init_watch('solve 2', 'Running solver on 2nd step', True, count_to_percent=True)
self.tc.init_watch('solve 3', 'Running solver on 3rd step', True, count_to_percent=True)
self.tc.init_watch('solve 4', 'Running solver on 4th step', True, count_to_percent=True)
self.tc.init_watch('assembleA1', 'Assembled A1 matrix (without stabiliz.)', True, count_to_percent=True)
self.tc.init_watch('assembleA1stab', 'Assembled A1 stabilization', True, count_to_percent=True)
self.tc.init_watch('next', 'Next step assignments', True, count_to_percent=True)
self.tc.init_watch('saveVel', 'Saved velocity', True)
self.tc.start('init')
# Define function spaces (P2-P1)
mesh = self.problem.mesh
self.V = VectorFunctionSpace(mesh, "Lagrange", 2) # velocity
self.Q = FunctionSpace(mesh, "Lagrange", 1) # pressure
self.PS = FunctionSpace(mesh, "Lagrange", 2) # partial solution (must be same order as V)
self.D = FunctionSpace(mesh, "Lagrange", 1) # velocity divergence space
problem.initialize(self.V, self.Q, self.PS, self.D)
# Define trial and test functions
u = TrialFunction(self.V)
v = TestFunction(self.V)
p = TrialFunction(self.Q)
q = TestFunction(self.Q)
n = FacetNormal(mesh)
I = Identity(find_geometric_dimension(u))
# Initial conditions: u0 velocity at previous time step u1 velocity two time steps back p0 previous pressure
[u1, u0, p0] = self.problem.get_initial_conditions([{'type': 'v', 'time': -dt},
{'type': 'v', 'time': 0.0},
{'type': 'p', 'time': 0.0}])
u_ = Function(self.V) # current tentative velocity
u_cor = Function(self.V) # current corrected velocity
p_ = Function(self.Q) # current pressure or pressure help function from rotation scheme
p_mod = Function(self.Q) # current modified pressure from rotation scheme
# Define coefficients
k = Constant(self.metadata['dt'])
f = Constant((0, 0, 0))
# Define forms
# step 1: Tentative velocity, solve to u_
u_ext = 1.5 * u0 - 0.5 * u1 # extrapolation for convection term
# Stabilisation
h = CellSize(mesh)
if self.args.cbc_tau:
# used in Simula cbcflow project
tau = Constant(self.stabCoef) * h / (sqrt(inner(u_ext, u_ext)) + h)
else:
# proposed in R. Codina: On stabilized finite element methods for linear systems of
# convection-diffusion-reaction equations.
tau = Constant(self.stabCoef) * k * h ** 2 / (
2 * nu * k + k * h * sqrt(DOLFIN_EPS + inner(u_ext, u_ext)) + h ** 2)
# DOLFIN_EPS is added because of FEniCS bug that inner(u_ext, u_ext) can be negative when u_ext = 0
if self.use_full_SUPG:
v1 = v + tau * 0.5 * dot(grad(v), u_ext)
parameters['form_compiler']['quadrature_degree'] = 6
else:
v1 = v
def nonlinearity(function):
if self.args.ema:
return 2 * inner(dot(sym(grad(function)), u_ext), v1) * dx + inner(div(function) * u_ext, v1) * dx
else:
return inner(dot(grad(function), u_ext), v1) * dx
def diffusion(fce):
if self.useLaplace:
return nu * inner(grad(fce), grad(v1)) * dx
else:
form = inner(nu * 2 * sym(grad(fce)), sym(grad(v1))) * dx
if self.bcv == 'CDN':
return form
if self.bcv == 'LAP':
return form - inner(nu * dot(grad(fce).T, n), v1) * problem.get_outflow_measure_form()
if self.bcv == 'DDN':
return form # additional term must be added to non-constant part
def pressure_rhs():
if self.args.bc == 'outflow':
return inner(p0, div(v1)) * dx
else:
return inner(p0, div(v1)) * dx - inner(p0 * n, v1) * problem.get_outflow_measure_form()
a1_const = (1. / k) * inner(u, v1) * dx + diffusion(0.5 * u)
a1_change = nonlinearity(0.5 * u)
if self.bcv == 'DDN':
# does not penalize influx for current step, only for the next one
# this can lead to oscilation:
# DDN correct next step, but then u_ext is OK so in next step DDN is not used, leading to new influx...
# u and u_ext cannot be switched, min_value is nonlinear function
a1_change += -0.5 * min_value(Constant(0.), inner(u_ext, n)) * inner(u,
v1) * problem.get_outflow_measure_form()
# NT works only with uflacs compiler
L1 = (1. / k) * inner(u0, v1) * dx - nonlinearity(0.5 * u0) - diffusion(0.5 * u0) + pressure_rhs()
if self.bcv == 'DDN':
L1 += 0.5 * min_value(0., inner(u_ext, n)) * inner(u0, v1) * problem.get_outflow_measure_form()
# Non-consistent SUPG stabilisation
if self.stabilize and not self.use_full_SUPG:
# a1_stab = tau*inner(dot(grad(u), u_ext), dot(grad(v), u_ext))*dx
a1_stab = 0.5 * tau * inner(dot(grad(u), u_ext), dot(grad(v), u_ext)) * dx(None, {'quadrature_degree': 6})
# optional: to use Crank Nicolson in stabilisation term following change of RHS is needed:
# L1 += -0.5*tau*inner(dot(grad(u0), u_ext), dot(grad(v), u_ext))*dx(None, {'quadrature_degree': 6})
outflow_area = Constant(problem.outflow_area)
need_outflow = Constant(0.0)
if self.useRotationScheme:
# Rotation scheme
F2 = inner(grad(p), grad(q)) * dx + (1. / k) * q * div(u_) * dx
else:
# Projection, solve to p_
if self.forceOutflow and problem.can_force_outflow:
info('Forcing outflow.')
F2 = inner(grad(p - p0), grad(q)) * dx + (1. / k) * q * div(u_) * dx
for m in problem.get_outflow_measures():
F2 += (1. / k) * (1. / outflow_area) * need_outflow * q * m
else:
F2 = inner(grad(p - p0), grad(q)) * dx + (1. / k) * q * div(u_) * dx
a2, L2 = system(F2)
# step 3: Finalize, solve to u_
if self.useRotationScheme:
# Rotation scheme
F3 = (1. / k) * inner(u - u_, v) * dx + inner(grad(p_), v) * dx
else:
F3 = (1. / k) * inner(u - u_, v) * dx + inner(grad(p_ - p0), v) * dx
a3, L3 = system(F3)
if self.useRotationScheme:
# Rotation scheme: modify pressure
F4 = (p - p0 - p_ + nu * div(u_)) * q * dx
a4, L4 = system(F4)
# Assemble matrices
self.tc.start('assembleMatrices')
A1_const = assemble(a1_const) # must be here, so A1 stays one Python object during repeated assembly
A1_change = A1_const.copy() # copy to get matrix with same sparse structure (data will be overwritten)
if self.stabilize and not self.use_full_SUPG:
A1_stab = A1_const.copy() # copy to get matrix with same sparse structure (data will be overwritten)
A2 = assemble(a2)
A3 = assemble(a3)
if self.useRotationScheme:
A4 = assemble(a4)
self.tc.end('assembleMatrices')
if self.solvers == 'direct':
self.solver_vel_tent = LUSolver('mumps')
self.solver_vel_cor = LUSolver('mumps')
self.solver_p = LUSolver('mumps')
if self.useRotationScheme:
self.solver_rot = LUSolver('mumps')
else:
# NT 2016-1 KrylovSolver >> PETScKrylovSolver
# not needed, chosen not to use hypre_parasails:
# if self.prec_v == 'hypre_parasails': # in FEniCS 1.6.0 inaccessible using KrylovSolver class
# self.solver_vel_tent = PETScKrylovSolver('gmres') # PETSc4py object
# self.solver_vel_tent.ksp().getPC().setType('hypre')
# PETScOptions.set('pc_hypre_type', 'parasails')
# # this is global setting, but preconditioners for pressure solvers are set by their constructors
# else:
self.solver_vel_tent = PETScKrylovSolver('gmres', self.args.precV) # nonsymetric > gmres
# cannot use 'ilu' in parallel
self.solver_vel_cor = PETScKrylovSolver('cg', self.args.precVC)
self.solver_p = PETScKrylovSolver(self.args.solP, self.args.precP) # almost (up to BC) symmetric > CG
if self.useRotationScheme:
self.solver_rot = PETScKrylovSolver('cg', 'hypre_amg')
# setup Krylov solvers
if self.solvers == 'krylov':
# Get the nullspace if there are no pressure boundary conditions
foo = Function(self.Q) # auxiliary vector for setting pressure nullspace
if self.args.bc == 'nullspace':
null_vec = Vector(foo.vector())
self.Q.dofmap().set(null_vec, 1.0)
null_vec *= 1.0 / null_vec.norm('l2')
self.null_space = VectorSpaceBasis([null_vec])
as_backend_type(A2).set_nullspace(self.null_space)
# apply global options for Krylov solvers
solver_options = {'monitor_convergence': True, 'maximum_iterations': 10000, 'nonzero_initial_guess': True}
# 'nonzero_initial_guess': True with solver.solve(A, u, b) means that
# Solver will use anything stored in u as an initial guess
for solver in [self.solver_vel_tent, self.solver_vel_cor, self.solver_rot, self.solver_p] if \
self.useRotationScheme else [self.solver_vel_tent, self.solver_vel_cor, self.solver_p]:
for key, value in solver_options.items():
try:
solver.parameters[key] = value
except KeyError:
info('Invalid option %s for KrylovSolver' % key)
return 1
if self.args.solP == 'richardson':
self.solver_p.parameters['monitor_convergence'] = False
self.solver_vel_tent.parameters['relative_tolerance'] = 10 ** (-self.args.prv1)
self.solver_vel_tent.parameters['absolute_tolerance'] = 10 ** (-self.args.pav1)
self.solver_vel_cor.parameters['relative_tolerance'] = 10E-12
self.solver_vel_cor.parameters['absolute_tolerance'] = 10E-4
self.solver_p.parameters['relative_tolerance'] = 10 ** (-self.args.prp)
self.solver_p.parameters['absolute_tolerance'] = 10 ** (-self.args.pap)
if self.useRotationScheme:
self.solver_rot.parameters['relative_tolerance'] = 10E-10
self.solver_rot.parameters['absolute_tolerance'] = 10E-10
if self.args.Vrestart > 0:
self.solver_vel_tent.parameters['gmres']['restart'] = self.args.Vrestart
if self.args.solP == 'gmres' and self.args.Prestart > 0:
self.solver_p.parameters['gmres']['restart'] = self.args.Prestart
# boundary conditions
bcu, bcp = problem.get_boundary_conditions(self.args.bc == 'outflow', self.V, self.Q)
self.tc.end('init')
# Time-stepping
info("Running of Incremental pressure correction scheme n. 1")
ttime = self.metadata['time']
t = dt
step = 1
# debug function
if problem.args.debug_rot:
plot_cor_v = Function(self.V)
while t < (ttime + dt / 2.0):
self.problem.update_time(t, step)
if self.MPI_rank == 0:
problem.write_status_file(t)
if doSave:
save_this_step = problem.save_this_step
# assemble matrix (it depends on solution)
self.tc.start('assembleA1')
assemble(a1_change, tensor=A1_change) # assembling into existing matrix is faster than assembling new one
A1 = A1_const.copy() # we dont want to change A1_const
A1.axpy(1, A1_change, True)
self.tc.end('assembleA1')
self.tc.start('assembleA1stab')
if self.stabilize and not self.use_full_SUPG:
assemble(a1_stab, tensor=A1_stab) # assembling into existing matrix is faster than assembling new one
A1.axpy(1, A1_stab, True)
self.tc.end('assembleA1stab')
# Compute tentative velocity step
begin("Computing tentative velocity")
self.tc.start('rhs')
b = assemble(L1)
self.tc.end('rhs')
self.tc.start('applybc1')
[bc.apply(A1, b) for bc in bcu]
self.tc.end('applybc1')
try:
self.tc.start('solve 1')
self.solver_vel_tent.solve(A1, u_.vector(), b)
self.tc.end('solve 1')
if save_this_step:
self.tc.start('saveVel')
problem.save_vel(True, u_)
self.tc.end('saveVel')
if save_this_step and not onlyVel:
problem.save_div(True, u_)
problem.compute_err(True, u_, t)
problem.compute_div(True, u_)
except RuntimeError as inst:
problem.report_fail(t)
return 1
end()
if self.useRotationScheme:
begin("Computing tentative pressure")
else:
begin("Computing pressure")
if self.forceOutflow and problem.can_force_outflow:
out = problem.compute_outflow(u_)
info('Tentative outflow: %f' % out)
n_o = -problem.last_inflow - out
info('Needed outflow: %f' % n_o)
need_outflow.assign(n_o)
self.tc.start('rhs')
b = assemble(L2)
self.tc.end('rhs')
self.tc.start('applybcP')
[bc.apply(A2, b) for bc in bcp]
if self.args.bc == 'nullspace':
self.null_space.orthogonalize(b)
self.tc.end('applybcP')
try:
self.tc.start('solve 2')
self.solver_p.solve(A2, p_.vector(), b)
self.tc.end('solve 2')
except RuntimeError as inst:
problem.report_fail(t)
return 1
if self.useRotationScheme:
foo = Function(self.Q)
foo.assign(p_ + p0)
if save_this_step and not onlyVel:
problem.averaging_pressure(foo)
problem.save_pressure(True, foo)
else:
foo = Function(self.Q)
foo.assign(p_) # we do not want to change p_ by averaging
if save_this_step and not onlyVel:
problem.averaging_pressure(foo)
problem.save_pressure(False, foo)
end()
begin("Computing corrected velocity")
self.tc.start('rhs')
b = assemble(L3)
self.tc.end('rhs')
if not self.args.B:
self.tc.start('applybc3')
[bc.apply(A3, b) for bc in bcu]
self.tc.end('applybc3')
try:
self.tc.start('solve 3')
self.solver_vel_cor.solve(A3, u_cor.vector(), b)
self.tc.end('solve 3')
problem.compute_err(False, u_cor, t)
problem.compute_div(False, u_cor)
except RuntimeError as inst:
problem.report_fail(t)
return 1
if save_this_step:
self.tc.start('saveVel')
problem.save_vel(False, u_cor)
self.tc.end('saveVel')
if save_this_step and not onlyVel:
problem.save_div(False, u_cor)
end()
if self.useRotationScheme:
begin("Rotation scheme pressure correction")
self.tc.start('rhs')
b = assemble(L4)
self.tc.end('rhs')
try:
self.tc.start('solve 4')
self.solver_rot.solve(A4, p_mod.vector(), b)
self.tc.end('solve 4')
except RuntimeError as inst:
problem.report_fail(t)
return 1
if save_this_step and not onlyVel:
problem.averaging_pressure(p_mod)
problem.save_pressure(False, p_mod)
end()
if problem.args.debug_rot:
# save applied pressure correction (expressed as a term added to RHS of next tentative vel. step)
# see comment next to argument definition
plot_cor_v.assign(project(k * grad(nu * div(u_)), self.V))
problem.fileDict['grad_cor']['file'].write(plot_cor_v, t)
# compute functionals (e. g. forces)
problem.compute_functionals(u_cor, p_mod if self.useRotationScheme else p_, t, step)
# Move to next time step
self.tc.start('next')
u1.assign(u0)
u0.assign(u_cor)
u_.assign(u_cor) # use corrected velocity as initial guess in first step
if self.useRotationScheme:
p0.assign(p_mod)
else:
p0.assign(p_)
t = round(t + dt, 6) # round time step to 0.000001
step += 1
self.tc.end('next')
info("Finished: Incremental pressure correction scheme n. 1")
problem.report()
return 0
def compute(space, epsilon, weakBnd, skeleton, mol=None):
u = TrialFunction(space)
v = TestFunction(space)
n = FacetNormal(space)
he = avg(CellVolume(space)) / FacetArea(space)
hbnd = CellVolume(space) / FacetArea(space)
x = SpatialCoordinate(space)
exact = uflFunction(space.gridView,
name="exact",
order=3,
ufl=sin(x[0] * x[1]))
uh = space.interpolate(exact, name="solution")
# diffusion factor
eps = Constant(epsilon, "eps")
# transport direction and upwind flux
b = as_vector([1, 0])
hatb = (dot(b, n) + abs(dot(b, n))) / 2.0
# characteristic function for left/right boundary
dD = conditional((1 + x[0]) * (1 - x[0]) < 1e-10, 1, 0)
# penalty parameter
beta = Constant(20 * space.order**2, "beta")
rhs = -(div(eps * grad(exact) - b * exact)) * v * dx
aInternal = dot(eps * grad(u) - b * u, grad(v)) * dx
aInternal -= eps * dot(grad(exact), n) * v * (1 - dD) * ds
diffSkeleton = eps*beta/he*jump(u)*jump(v)*dS -\
eps*dot(avg(grad(u)),n('+'))*jump(v)*dS -\
eps*jump(u)*dot(avg(grad(v)),n('+'))*dS
if weakBnd:
diffSkeleton += eps*beta/hbnd*(u-exact)*v*dD*ds -\
eps*dot(grad(exact),n)*v*dD*ds
advSkeleton = jump(hatb * u) * jump(v) * dS
if weakBnd:
advSkeleton += (hatb * u + (dot(b, n) - hatb) * exact) * v * dD * ds
if skeleton:
form = aInternal + diffSkeleton + advSkeleton
else:
form = aInternal
if weakBnd and skeleton:
strongBC = None
else:
strongBC = DirichletBC(space, exact, dD)
if space.storage[0] == "numpy":
solver = {
"solver": ("suitesparse", "umfpack"),
"parameters": {
"newton.verbose": True,
"newton.linear.verbose": False,
"newton.linear.tolerance": 1e-5,
}
}
else:
solver = {
"solver": "bicgstab",
"parameters": {
"newton.linear.preconditioning.method": "ilu",
"newton.linear.tolerance": 1e-13,
"newton.verbose": True,
"newton.linear.verbose": False
}
}
if mol == 'mol':
scheme = molSolutionScheme([form == rhs, strongBC], **solver)
else:
scheme = solutionScheme([form == rhs, strongBC], **solver)
eoc = []
info = scheme.solve(target=uh)
error = dot(uh - exact, uh - exact)
error0 = math.sqrt(integrate(gridView, error, order=5))
print(error0, " # output", flush=True)
for i in range(3):
gridView.hierarchicalGrid.globalRefine(1)
uh.interpolate(exact)
scheme.solve(target=uh)
error = dot(uh - exact, uh - exact)
error1 = math.sqrt(integrate(gridView, error, order=5))
eoc += [math.log(error1 / error0) / math.log(0.5)]
print(i, error0, error1, eoc, " # output", flush=True)
error0 = error1
# print(space.order,epsilon,eoc)
if (eoc[-1] - (space.order + 1)) < -0.1:
print("ERROR:", space.order, epsilon, eoc)
return eoc
def norm(v, norm_type="L2", mesh=None):
"""
Return the norm of a given vector or function.
*Arguments*
v
a :py:class:`Vector <dolfin.cpp.Vector>` or
a :py:class:`Function <dolfin.functions.function.Function>`.
norm_type
see below for alternatives.
mesh
optional :py:class:`Mesh <dolfin.cpp.Mesh>` on
which to compute the norm.
If the norm type is not specified, the standard :math:`L^2` -norm
is computed. Possible norm types include:
*Vectors*
================ ================= ================
Norm Usage
================ ================= ================
:math:`l^2` norm(x, 'l2') Default
:math:`l^1` norm(x, 'l1')
:math:`l^\infty` norm(x, 'linf')
================ ================= ================
*Functions*
================ ================= =================================
Norm Usage Includes the :math:`L^2` -term
================ ================= =================================
:math:`L^2` norm(v, 'L2') Yes
:math:`H^1` norm(v, 'H1') Yes
:math:`H^1_0` norm(v, 'H10') No
:math:`H` (div) norm(v, 'Hdiv') Yes
:math:`H` (div) norm(v, 'Hdiv0') No
:math:`H` (curl) norm(v, 'Hcurl') Yes
:math:`H` (curl) norm(v, 'Hcurl0') No
================ ================= =================================
*Examples of usage*
.. code-block:: python
v = Function(V)
x = v.vector()
print norm(x, 'linf') # print the infinity norm of vector x
n = norm(v) # compute L^2 norm of v
print norm(v, 'Hdiv') # print H(div) norm of v
n = norm(v, 'H1', mesh) # compute H^1 norm of v on given mesh
"""
# if not isinstance(v, (GenericVector, GenericFunction)):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "expected a GenericVector or GenericFunction")
# Check arguments
# if not isinstance(norm_type, string_types):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Norm type must be a string, not " +
# str(type(norm_type)))
# if mesh is not None and not isinstance(mesh, cpp.Mesh):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Expecting a Mesh, not " + str(type(mesh)))
# Get mesh from function
if isinstance(v, cpp.function.Function) and mesh is None:
mesh = v.function_space().mesh()
elif isinstance(v, MultiMeshFunction) and mesh is None:
mesh = v.function_space().multimesh()
# Define integration measure and domain
if isinstance(v, MultiMeshFunction):
dc = ufl.dx(mesh) + ufl.dC(mesh)
assemble_func = functools.partial(assemble_multimesh, form_compiler_parameters={"representation": "quadrature"})
else:
dc = ufl.dx(mesh)
assemble_func = assemble
# Select norm type
if isinstance(v, cpp.la.GenericVector):
return v.norm(norm_type.lower())
elif isinstance(v, ufl.Coefficient):
if norm_type.lower() == "l2":
M = v**2 * dc
elif norm_type.lower() == "h1":
M = (v**2 + grad(v)**2) * dc
elif norm_type.lower() == "h10":
M = grad(v)**2 * dc
elif norm_type.lower() == "hdiv":
M = (v**2 + div(v)**2) * dc
elif norm_type.lower() == "hdiv0":
M = div(v)**2 * dc
elif norm_type.lower() == "hcurl":
M = (v**2 + curl(v)**2) * dc
elif norm_type.lower() == "hcurl0":
M = curl(v)**2 * dc
else:
raise ValueError("Unknown norm type {}".format(str(norm_type)))
else:
raise TypeError("Do not know how to compute norm of {}".format(str(v)))
# Assemble value and return
return sqrt(assemble_func(M))
def norm(v, norm_type="L2", mesh=None):
r"""
Return the norm of a given vector or function.
*Arguments*
v
a :py:class:`Vector <dolfin.cpp.Vector>` or
a :py:class:`Function <dolfin.functions.function.Function>`.
norm_type
see below for alternatives.
mesh
optional :py:class:`Mesh <dolfin.cpp.Mesh>` on
which to compute the norm.
If the norm type is not specified, the standard :math:`L^2` -norm
is computed. Possible norm types include:
*Vectors*
================ ================= ================
Norm Usage
================ ================= ================
:math:`l^2` norm(x, 'l2') Default
:math:`l^1` norm(x, 'l1')
:math:`l^\infty` norm(x, 'linf')
================ ================= ================
*Functions*
================ ================= =================================
Norm Usage Includes the :math:`L^2` -term
================ ================= =================================
:math:`L^2` norm(v, 'L2') Yes
:math:`H^1` norm(v, 'H1') Yes
:math:`H^1_0` norm(v, 'H10') No
:math:`H` (div) norm(v, 'Hdiv') Yes
:math:`H` (div) norm(v, 'Hdiv0') No
:math:`H` (curl) norm(v, 'Hcurl') Yes
:math:`H` (curl) norm(v, 'Hcurl0') No
================ ================= =================================
*Examples of usage*
.. code-block:: python
v = Function(V)
x = v.vector()
print norm(x, 'linf') # print the infinity norm of vector x
n = norm(v) # compute L^2 norm of v
print norm(v, 'Hdiv') # print H(div) norm of v
n = norm(v, 'H1', mesh) # compute H^1 norm of v on given mesh
"""
# if not isinstance(v, (GenericVector, GenericFunction)):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "expected a GenericVector or GenericFunction")
# Check arguments
# if not isinstance(norm_type, string_types):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Norm type must be a string, not " +
# str(type(norm_type)))
# if mesh is not None and not isinstance(mesh, cpp.Mesh):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Expecting a Mesh, not " + str(type(mesh)))
# Get mesh from function
if isinstance(v, cpp.function.Function) and mesh is None:
mesh = v.function_space().mesh()
elif isinstance(v, MultiMeshFunction) and mesh is None:
mesh = v.function_space().multimesh()
# Define integration measure and domain
if isinstance(v, MultiMeshFunction):
dc = ufl.dx(mesh) + ufl.dC(mesh)
assemble_func = functools.partial(assemble_multimesh, form_compiler_parameters={"representation": "quadrature"})
else:
dc = ufl.dx(mesh)
assemble_func = assemble
# Select norm type
if isinstance(v, cpp.la.GenericVector):
return v.norm(norm_type.lower())
elif isinstance(v, ufl.Coefficient):
if norm_type.lower() == "l2":
M = v**2 * dc
elif norm_type.lower() == "h1":
M = (v**2 + grad(v)**2) * dc
elif norm_type.lower() == "h10":
M = grad(v)**2 * dc
elif norm_type.lower() == "hdiv":
M = (v**2 + div(v)**2) * dc
elif norm_type.lower() == "hdiv0":
M = div(v)**2 * dc
elif norm_type.lower() == "hcurl":
M = (v**2 + curl(v)**2) * dc
elif norm_type.lower() == "hcurl0":
M = curl(v)**2 * dc
else:
raise ValueError("Unknown norm type {}".format(str(norm_type)))
else:
raise TypeError("Do not know how to compute norm of {}".format(str(v)))
# Assemble value and return
return sqrt(assemble_func(M))
def solve(self, problem):
self.problem = problem
doSave = problem.doSave
save_this_step = False
onlyVel = problem.saveOnlyVel
dt = self.metadata['dt']
nu = Constant(self.problem.nu)
# TODO check proper use of watches
self.tc.init_watch('init', 'Initialization', True, count_to_percent=False)
self.tc.init_watch('rhs', 'Assembled right hand side', True, count_to_percent=True)
self.tc.init_watch('updateBC', 'Updated velocity BC', True, count_to_percent=True)
self.tc.init_watch('applybc1', 'Applied velocity BC 1st step', True, count_to_percent=True)
self.tc.init_watch('applybc3', 'Applied velocity BC 3rd step', True, count_to_percent=True)
self.tc.init_watch('applybcP', 'Applied pressure BC or othogonalized rhs', True, count_to_percent=True)
self.tc.init_watch('assembleMatrices', 'Initial matrix assembly', False, count_to_percent=True)
self.tc.init_watch('solve 1', 'Running solver on 1st step', True, count_to_percent=True)
self.tc.init_watch('solve 2', 'Running solver on 2nd step', True, count_to_percent=True)
self.tc.init_watch('solve 3', 'Running solver on 3rd step', True, count_to_percent=True)
self.tc.init_watch('solve 4', 'Running solver on 4th step', True, count_to_percent=True)
self.tc.init_watch('assembleA1', 'Assembled A1 matrix (without stabiliz.)', True, count_to_percent=True)
self.tc.init_watch('assembleA1stab', 'Assembled A1 stabilization', True, count_to_percent=True)
self.tc.init_watch('next', 'Next step assignments', True, count_to_percent=True)
self.tc.init_watch('saveVel', 'Saved velocity', True)
self.tc.start('init')
# Define function spaces (P2-P1)
mesh = self.problem.mesh
self.V = VectorFunctionSpace(mesh, "Lagrange", 2) # velocity
self.Q = FunctionSpace(mesh, "Lagrange", 1) # pressure
self.PS = FunctionSpace(mesh, "Lagrange", 2) # partial solution (must be same order as V)
self.D = FunctionSpace(mesh, "Lagrange", 1) # velocity divergence space
if self.bc == 'lagrange':
L = FunctionSpace(mesh, "R", 0)
QL = self.Q*L
problem.initialize(self.V, self.Q, self.PS, self.D)
# Define trial and test functions
u = TrialFunction(self.V)
v = TestFunction(self.V)
if self.bc == 'lagrange':
(pQL, rQL) = TrialFunction(QL)
(qQL, lQL) = TestFunction(QL)
else:
p = TrialFunction(self.Q)
q = TestFunction(self.Q)
n = FacetNormal(mesh)
I = Identity(u.geometric_dimension())
# Initial conditions: u0 velocity at previous time step u1 velocity two time steps back p0 previous pressure
[u1, u0, p0] = self.problem.get_initial_conditions([{'type': 'v', 'time': -dt},
{'type': 'v', 'time': 0.0},
{'type': 'p', 'time': 0.0}])
if doSave:
problem.save_vel(False, u0, 0.0)
problem.save_vel(True, u0, 0.0)
u_ = Function(self.V) # current tentative velocity
u_cor = Function(self.V) # current corrected velocity
if self.bc == 'lagrange':
p_QL = Function(QL) # current pressure or pressure help function from rotation scheme
pQ = Function(self.Q) # auxiliary function for conversion between QL.sub(0) and Q
else:
p_ = Function(self.Q) # current pressure or pressure help function from rotation scheme
p_mod = Function(self.Q) # current modified pressure from rotation scheme
# Define coefficients
k = Constant(self.metadata['dt'])
f = Constant((0, 0, 0))
# Define forms
# step 1: Tentative velocity, solve to u_
u_ext = 1.5*u0 - 0.5*u1 # extrapolation for convection term
# Stabilisation
h = CellSize(mesh)
# CBC delta:
if self.cbcDelta:
delta = Constant(self.stabCoef)*h/(sqrt(inner(u_ext, u_ext))+h)
else:
delta = Constant(self.stabCoef)*h**2/(2*nu*k + k*h*inner(u_ext, u_ext)+h**2)
if self.use_full_SUPG:
v1 = v + delta*0.5*k*dot(grad(v), u_ext)
parameters['form_compiler']['quadrature_degree'] = 6
else:
v1 = v
def nonlinearity(function):
if self.use_ema:
return 2*inner(dot(sym(grad(function)), u_ext), v1) * dx + inner(div(function)*u_ext, v1) * dx
# return 2*inner(dot(sym(grad(function)), u_ext), v) * dx + inner(div(u_ext)*function, v) * dx
# QQ implement this way?
else:
return inner(dot(grad(function), u_ext), v1) * dx
def diffusion(fce):
if self.useLaplace:
return nu*inner(grad(fce), grad(v1)) * dx
else:
form = inner(nu * 2 * sym(grad(fce)), sym(grad(v1))) * dx
if self.bcv == 'CDN':
# IMP will work only if p=0 on output, or we must add term
# inner(p0*n, v)*problem.get_outflow_measure_form() to avoid boundary layer
return form
if self.bcv == 'LAP':
return form - inner(nu*dot(grad(fce).T, n), v1) * problem.get_outflow_measure_form()
if self.bcv == 'DDN':
# IMP will work only if p=0 on output, or we must add term
# inner(p0*n, v)*problem.get_outflow_measure_form() to avoid boundary layer
return form # additional term must be added to non-constant part
def pressure_rhs():
if self.useLaplace or self.bcv == 'LAP':
return inner(p0, div(v1)) * dx - inner(p0*n, v1) * problem.get_outflow_measure_form()
# NT term inner(inner(p, n), v) is 0 when p=0 on outflow
else:
return inner(p0, div(v1)) * dx
a1_const = (1./k)*inner(u, v1)*dx + diffusion(0.5*u)
a1_change = nonlinearity(0.5*u)
if self.bcv == 'DDN':
# IMP Problem: Does not penalize influx for current step, only for the next one
# IMP this can lead to oscilation: DDN correct next step, but then u_ext is OK so in next step DDN is not used, leading to new influx...
# u and u_ext cannot be switched, min_value is nonlinear function
a1_change += -0.5*min_value(Constant(0.), inner(u_ext, n))*inner(u, v1)*problem.get_outflow_measure_form()
# IMP works only with uflacs compiler
L1 = (1./k)*inner(u0, v1)*dx - nonlinearity(0.5*u0) - diffusion(0.5*u0) + pressure_rhs()
if self.bcv == 'DDN':
L1 += 0.5*min_value(0., inner(u_ext, n))*inner(u0, v1)*problem.get_outflow_measure_form()
# Non-consistent SUPG stabilisation
if self.stabilize and not self.use_full_SUPG:
# a1_stab = delta*inner(dot(grad(u), u_ext), dot(grad(v), u_ext))*dx
a1_stab = 0.5*delta*inner(dot(grad(u), u_ext), dot(grad(v), u_ext))*dx(None, {'quadrature_degree': 6})
# NT optional: use Crank Nicolson in stabilisation term: change RHS
# L1 += -0.5*delta*inner(dot(grad(u0), u_ext), dot(grad(v), u_ext))*dx(None, {'quadrature_degree': 6})
outflow_area = Constant(problem.outflow_area)
need_outflow = Constant(0.0)
if self.useRotationScheme:
# Rotation scheme
if self.bc == 'lagrange':
F2 = inner(grad(pQL), grad(qQL))*dx + (1./k)*qQL*div(u_)*dx + pQL*lQL*dx + qQL*rQL*dx
else:
F2 = inner(grad(p), grad(q))*dx + (1./k)*q*div(u_)*dx
else:
# Projection, solve to p_
if self.bc == 'lagrange':
F2 = inner(grad(pQL - p0), grad(qQL))*dx + (1./k)*qQL*div(u_)*dx + pQL*lQL*dx + qQL*rQL*dx
else:
if self.forceOutflow and problem.can_force_outflow:
info('Forcing outflow.')
F2 = inner(grad(p - p0), grad(q))*dx + (1./k)*q*div(u_)*dx
for m in problem.get_outflow_measures():
F2 += (1./k)*(1./outflow_area)*need_outflow*q*m
else:
F2 = inner(grad(p - p0), grad(q))*dx + (1./k)*q*div(u_)*dx
a2, L2 = system(F2)
# step 3: Finalize, solve to u_
if self.useRotationScheme:
# Rotation scheme
if self.bc == 'lagrange':
F3 = (1./k)*inner(u - u_, v)*dx + inner(grad(p_QL.sub(0)), v)*dx
else:
F3 = (1./k)*inner(u - u_, v)*dx + inner(grad(p_), v)*dx
else:
if self.bc == 'lagrange':
F3 = (1./k)*inner(u - u_, v)*dx + inner(grad(p_QL.sub(0) - p0), v)*dx
else:
F3 = (1./k)*inner(u - u_, v)*dx + inner(grad(p_ - p0), v)*dx
a3, L3 = system(F3)
if self.useRotationScheme:
# Rotation scheme: modify pressure
if self.bc == 'lagrange':
pr = TrialFunction(self.Q)
qr = TestFunction(self.Q)
F4 = (pr - p0 - p_QL.sub(0) + nu*div(u_))*qr*dx
else:
F4 = (p - p0 - p_ + nu*div(u_))*q*dx
# TODO zkusit, jestli to nebude rychlejsi? nepocitat soustavu, ale p.assign(...), nutno project(div(u),Q) coz je pocitani podobne soustavy
# TODO zkusit v project zadat solver_type='lu' >> primy resic by mel byt efektivnejsi
a4, L4 = system(F4)
# Assemble matrices
self.tc.start('assembleMatrices')
A1_const = assemble(a1_const) # need to be here, so A1 stays one Python object during repeated assembly
A1_change = A1_const.copy() # copy to get matrix with same sparse structure (data will be overwriten)
if self.stabilize and not self.use_full_SUPG:
A1_stab = A1_const.copy() # copy to get matrix with same sparse structure (data will be overwriten)
A2 = assemble(a2)
A3 = assemble(a3)
if self.useRotationScheme:
A4 = assemble(a4)
self.tc.end('assembleMatrices')
if self.solvers == 'direct':
self.solver_vel_tent = LUSolver('mumps')
self.solver_vel_cor = LUSolver('mumps')
self.solver_p = LUSolver('umfpack')
if self.useRotationScheme:
self.solver_rot = LUSolver('umfpack')
else:
# NT not needed, chosen not to use hypre_parasails
# if self.prec_v == 'hypre_parasails': # in FEniCS 1.6.0 inaccessible using KrylovSolver class
# self.solver_vel_tent = PETScKrylovSolver('gmres') # PETSc4py object
# self.solver_vel_tent.ksp().getPC().setType('hypre')
# PETScOptions.set('pc_hypre_type', 'parasails')
# # this is global setting, but preconditioners for pressure solvers are set by their constructors
# else:
self.solver_vel_tent = KrylovSolver('gmres', self.prec_v) # nonsymetric > gmres
# IMP cannot use 'ilu' in parallel (choose different default option)
self.solver_vel_cor = KrylovSolver('cg', 'hypre_amg') # nonsymetric > gmres
self.solver_p = KrylovSolver('cg', self.prec_p) # symmetric > CG
if self.useRotationScheme:
self.solver_rot = KrylovSolver('cg', self.prec_p)
solver_options = {'monitor_convergence': True, 'maximum_iterations': 1000, 'nonzero_initial_guess': True}
# 'nonzero_initial_guess': True with solver.solbe(A, u, b) means that
# Solver will use anything stored in u as an initial guess
# Get the nullspace if there are no pressure boundary conditions
foo = Function(self.Q) # auxiliary vector for setting pressure nullspace
if self.bc in ['nullspace', 'nullspace_s']:
null_vec = Vector(foo.vector())
self.Q.dofmap().set(null_vec, 1.0)
null_vec *= 1.0/null_vec.norm('l2')
self.null_space = VectorSpaceBasis([null_vec])
if self.bc == 'nullspace':
as_backend_type(A2).set_nullspace(self.null_space)
# apply global options for Krylov solvers
self.solver_vel_tent.parameters['relative_tolerance'] = 10 ** (-self.precision_rel_v_tent)
self.solver_vel_tent.parameters['absolute_tolerance'] = 10 ** (-self.precision_abs_v_tent)
self.solver_vel_cor.parameters['relative_tolerance'] = 10E-12
self.solver_vel_cor.parameters['absolute_tolerance'] = 10E-4
self.solver_p.parameters['relative_tolerance'] = 10**(-self.precision_p)
self.solver_p.parameters['absolute_tolerance'] = 10E-10
if self.useRotationScheme:
self.solver_rot.parameters['relative_tolerance'] = 10**(-self.precision_p)
self.solver_rot.parameters['absolute_tolerance'] = 10E-10
if self.solvers == 'krylov':
for solver in [self.solver_vel_tent, self.solver_vel_cor, self.solver_p, self.solver_rot] if \
self.useRotationScheme else [self.solver_vel_tent, self.solver_vel_cor, self.solver_p]:
for key, value in solver_options.items():
try:
solver.parameters[key] = value
except KeyError:
info('Invalid option %s for KrylovSolver' % key)
return 1
solver.parameters['preconditioner']['structure'] = 'same'
# matrices A2-A4 do not change, so we can reuse preconditioners
self.solver_vel_tent.parameters['preconditioner']['structure'] = 'same_nonzero_pattern'
# matrix A1 changes every time step, so change of preconditioner must be allowed
if self.bc == 'lagrange':
fa = FunctionAssigner(self.Q, QL.sub(0))
# boundary conditions
bcu, bcp = problem.get_boundary_conditions(self.bc == 'outflow', self.V, self.Q)
self.tc.end('init')
# Time-stepping
info("Running of Incremental pressure correction scheme n. 1")
ttime = self.metadata['time']
t = dt
step = 1
while t < (ttime + dt/2.0):
info("t = %f" % t)
self.problem.update_time(t, step)
if self.MPI_rank == 0:
problem.write_status_file(t)
if doSave:
save_this_step = problem.save_this_step
# DDN debug
# u_ext_in = assemble(inner(u_ext, n)*problem.get_outflow_measure_form())
# DDN_triggered = assemble(min_value(Constant(0.), inner(u_ext, n))*problem.get_outflow_measure_form())
# print('DDN: u_ext*n dSout = ', u_ext_in)
# print('DDN: negative part of u_ext*n dSout = ', DDN_triggered)
# assemble matrix (it depends on solution)
self.tc.start('assembleA1')
assemble(a1_change, tensor=A1_change) # assembling into existing matrix is faster than assembling new one
A1 = A1_const.copy() # we dont want to change A1_const
A1.axpy(1, A1_change, True)
self.tc.end('assembleA1')
self.tc.start('assembleA1stab')
if self.stabilize and not self.use_full_SUPG:
assemble(a1_stab, tensor=A1_stab) # assembling into existing matrix is faster than assembling new one
A1.axpy(1, A1_stab, True)
self.tc.end('assembleA1stab')
# Compute tentative velocity step
begin("Computing tentative velocity")
self.tc.start('rhs')
b = assemble(L1)
self.tc.end('rhs')
self.tc.start('applybc1')
[bc.apply(A1, b) for bc in bcu]
self.tc.end('applybc1')
try:
self.tc.start('solve 1')
self.solver_vel_tent.solve(A1, u_.vector(), b)
self.tc.end('solve 1')
if save_this_step:
self.tc.start('saveVel')
problem.save_vel(True, u_, t)
self.tc.end('saveVel')
if save_this_step and not onlyVel:
problem.save_div(True, u_)
problem.compute_err(True, u_, t)
problem.compute_div(True, u_)
except RuntimeError as inst:
problem.report_fail(t)
return 1
end()
# DDN debug
# u_ext_in = assemble(inner(u_, n)*problem.get_outflow_measure_form())
# DDN_triggered = assemble(min_value(Constant(0.), inner(u_, n))*problem.get_outflow_measure_form())
# print('DDN: u_tent*n dSout = ', u_ext_in)
# print('DDN: negative part of u_tent*n dSout = ', DDN_triggered)
if self.useRotationScheme:
begin("Computing tentative pressure")
else:
begin("Computing pressure")
if self.forceOutflow and problem.can_force_outflow:
out = problem.compute_outflow(u_)
info('Tentative outflow: %f' % out)
n_o = -problem.last_inflow-out
info('Needed outflow: %f' % n_o)
need_outflow.assign(n_o)
self.tc.start('rhs')
b = assemble(L2)
self.tc.end('rhs')
self.tc.start('applybcP')
[bc.apply(A2, b) for bc in bcp]
if self.bc in ['nullspace', 'nullspace_s']:
self.null_space.orthogonalize(b)
self.tc.end('applybcP')
try:
self.tc.start('solve 2')
if self.bc == 'lagrange':
self.solver_p.solve(A2, p_QL.vector(), b)
else:
self.solver_p.solve(A2, p_.vector(), b)
self.tc.end('solve 2')
except RuntimeError as inst:
problem.report_fail(t)
return 1
if self.useRotationScheme:
foo = Function(self.Q)
if self.bc == 'lagrange':
fa.assign(pQ, p_QL.sub(0))
foo.assign(pQ + p0)
else:
foo.assign(p_+p0)
problem.averaging_pressure(foo)
if save_this_step and not onlyVel:
problem.save_pressure(True, foo)
else:
if self.bc == 'lagrange':
fa.assign(pQ, p_QL.sub(0))
problem.averaging_pressure(pQ)
if save_this_step and not onlyVel:
problem.save_pressure(False, pQ)
else:
# we do not want to change p=0 on outflow, it conflicts with do-nothing conditions
foo = Function(self.Q)
foo.assign(p_)
problem.averaging_pressure(foo)
if save_this_step and not onlyVel:
problem.save_pressure(False, foo)
end()
begin("Computing corrected velocity")
self.tc.start('rhs')
b = assemble(L3)
self.tc.end('rhs')
if not self.B:
self.tc.start('applybc3')
[bc.apply(A3, b) for bc in bcu]
self.tc.end('applybc3')
try:
self.tc.start('solve 3')
self.solver_vel_cor.solve(A3, u_cor.vector(), b)
self.tc.end('solve 3')
problem.compute_err(False, u_cor, t)
problem.compute_div(False, u_cor)
except RuntimeError as inst:
problem.report_fail(t)
return 1
if save_this_step:
self.tc.start('saveVel')
problem.save_vel(False, u_cor, t)
self.tc.end('saveVel')
if save_this_step and not onlyVel:
problem.save_div(False, u_cor)
end()
# DDN debug
# u_ext_in = assemble(inner(u_cor, n)*problem.get_outflow_measure_form())
# DDN_triggered = assemble(min_value(Constant(0.), inner(u_cor, n))*problem.get_outflow_measure_form())
# print('DDN: u_cor*n dSout = ', u_ext_in)
# print('DDN: negative part of u_cor*n dSout = ', DDN_triggered)
if self.useRotationScheme:
begin("Rotation scheme pressure correction")
self.tc.start('rhs')
b = assemble(L4)
self.tc.end('rhs')
try:
self.tc.start('solve 4')
self.solver_rot.solve(A4, p_mod.vector(), b)
self.tc.end('solve 4')
except RuntimeError as inst:
problem.report_fail(t)
return 1
problem.averaging_pressure(p_mod)
if save_this_step and not onlyVel:
problem.save_pressure(False, p_mod)
end()
# compute functionals (e. g. forces)
problem.compute_functionals(u_cor,
p_mod if self.useRotationScheme else (pQ if self.bc == 'lagrange' else p_), t)
# Move to next time step
self.tc.start('next')
u1.assign(u0)
u0.assign(u_cor)
u_.assign(u_cor) # use corretced velocity as initial guess in first step
if self.useRotationScheme:
p0.assign(p_mod)
else:
if self.bc == 'lagrange':
p0.assign(pQ)
else:
p0.assign(p_)
t = round(t + dt, 6) # round time step to 0.000001
step += 1
self.tc.end('next')
info("Finished: Incremental pressure correction scheme n. 1")
problem.report()
return 0
def solve_navier_stokes_equation(interior_circle=True, num_mesh_refinements=0):
"""
Solve the Navier-Stokes equation on a hard-coded mesh with hard-coded initial and boundary conditions
"""
mesh, om, im, nm, ymax, sub_domains = setup_geometry(
interior_circle, num_mesh_refinements)
dsi = Measure("ds", domain=mesh, subdomain_data=sub_domains)
# Setup FEM function spaces
# Function space for the velocity
V = VectorFunctionSpace(mesh, "CG", 1)
# Function space for the pressure
Q = FunctionSpace(mesh, "CG", 1)
# Mixed function space for velocity and pressure
W = V * Q
# Setup FEM functions
v, q = TestFunctions(W)
w = Function(W)
(u, p) = (as_vector((w[0], w[1])), w[2])
u0 = Function(V)
# Inlet velocity
uin = Expression(("4*(x[1]*(YMAX-x[1]))/(YMAX*YMAX)", "0."),
YMAX=ymax,
degree=1)
# Viscosity and stabilization parameters
nu = 1e-6
h = CellSize(mesh)
d = 0.2 * h**(3.0 / 2.0)
# Time parameters
time_step = 0.1
t_start, t_end = 0.0, 10.0
# Penalty parameter
gamma = 10 / h
# Time stepping
t = t_start
step = 0
while t < t_end:
# Time discretization (Crank–Nicolson method)
um = 0.5 * u + 0.5 * u0
# Navier-Stokes equations in weak residual form (stabilized FEM)
# Basic residual
r = (inner((u - u0) / time_step + grad(p) + grad(um) * um, v) +
nu * inner(grad(um), grad(v)) + div(um) * q) * dx
# Weak boundary conditions
r += gamma * (om * p * q + im * inner(u - uin, v) +
nm * inner(u, v)) * ds
# Stabilization
r += d * (inner(grad(p) + grad(um) * um,
grad(q) + grad(um) * v) + inner(div(um), div(v))) * dx
# Solve the Navier-Stokes equation (one time step)
solve(r == 0, w)
if step % 5 == 0:
# Plot norm of velocity at current time step
nov = project(sqrt(inner(u, u)), Q)
fig = plt.figure()
plot(nov, fig=fig)
plt.show()
# Compute drag force on circle
n = FacetNormal(mesh)
drag_force_measure = p * n[0] * dsi(1) # Drag (only pressure)
drag_force = assemble(drag_force_measure)
print("Drag force = " + str(drag_force))
# Shift to next time step
t += time_step
step += 1
u0 = project(u, V)
def norm(v, norm_type="L2", mesh=None):
"""
Return the norm of a given vector or function.
*Arguments*
v
a :py:class:`Vector <dolfin.cpp.Vector>` or
a :py:class:`Function <dolfin.functions.function.Function>`.
norm_type
see below for alternatives.
mesh
optional :py:class:`Mesh <dolfin.cpp.Mesh>` on
which to compute the norm.
If the norm type is not specified, the standard :math:`L^2` -norm
is computed. Possible norm types include:
*Vectors*
================ ================= ================
Norm Usage
================ ================= ================
:math:`l^2` norm(x, 'l2') Default
:math:`l^1` norm(x, 'l1')
:math:`l^\infty` norm(x, 'linf')
================ ================= ================
*Functions*
================ ================= =================================
Norm Usage Includes the :math:`L^2` -term
================ ================= =================================
:math:`L^2` norm(v, 'L2') Yes
:math:`H^1` norm(v, 'H1') Yes
:math:`H^1_0` norm(v, 'H10') No
:math:`H` (div) norm(v, 'Hdiv') Yes
:math:`H` (div) norm(v, 'Hdiv0') No
:math:`H` (curl) norm(v, 'Hcurl') Yes
:math:`H` (curl) norm(v, 'Hcurl0') No
================ ================= =================================
*Examples of usage*
.. code-block:: python
v = Function(V)
x = v.vector()
print norm(x, 'linf') # print the infinity norm of vector x
n = norm(v) # compute L^2 norm of v
print norm(v, 'Hdiv') # print H(div) norm of v
n = norm(v, 'H1', mesh) # compute H^1 norm of v on given mesh
"""
# if not isinstance(v, (GenericVector, GenericFunction)):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "expected a GenericVector or GenericFunction")
# Check arguments
# if not isinstance(norm_type, string_types):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Norm type must be a string, not " +
# str(type(norm_type)))
# if mesh is not None and not isinstance(mesh, cpp.Mesh):
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Expecting a Mesh, not " + str(type(mesh)))
# Get mesh from function
if isinstance(v, cpp.function.Function) and mesh is None:
mesh = v.function_space().mesh()
# Define integration measure and domain
dx = ufl.dx(mesh)
# Select norm type
if isinstance(v, cpp.la.GenericVector):
return v.norm(norm_type.lower())
elif isinstance(v, ufl.Coefficient):
if norm_type.lower() == "l2":
M = v**2*dx
elif norm_type.lower() == "h1":
M = (v**2 + grad(v)**2)*dx
elif norm_type.lower() == "h10":
M = grad(v)**2*dx
elif norm_type.lower() == "hdiv":
M = (v**2 + div(v)**2)*dx
elif norm_type.lower() == "hdiv0":
M = div(v)**2*dx
elif norm_type.lower() == "hcurl":
M = (v**2 + curl(v)**2)*dx
elif norm_type.lower() == "hcurl0":
M = curl(v)**2*dx
# else:
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Unknown norm type (\"%s\") for functions"
# % str(norm_type))
# else:
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Unknown object type. Must be a vector or a function")
# Assemble value
r = assemble(M)
# Check value
if r < 0.0:
pass
# cpp.dolfin_error("norms.py",
# "compute norm",
# "Square of norm is negative, might be a round-off error")
elif r == 0.0:
return 0.0
else:
return sqrt(r)
def pressure_rhs():
if self.args.bc == 'outflow':
return inner(p0, div(v1)) * dx
else:
return inner(p0, div(v1)) * dx - inner(p0 * n, v1) * problem.get_outflow_measure_form()
def test_assembly_solve_taylor_hood(mesh):
"""Assemble Stokes problem with Taylor-Hood elements and solve."""
P2 = dolfin.VectorFunctionSpace(mesh, ("Lagrange", 2))
P1 = dolfin.FunctionSpace(mesh, ("Lagrange", 1))
def boundary0(x, only_boundary):
"""Define boundary x = 0"""
return x[:, 0] < 10 * numpy.finfo(float).eps
def boundary1(x, only_boundary):
"""Define boundary x = 1"""
return x[:, 0] > (1.0 - 10 * numpy.finfo(float).eps)
u0 = dolfin.Function(P2)
u0.vector().set(1.0)
u0.vector().ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
bc0 = dolfin.DirichletBC(P2, u0, boundary0)
bc1 = dolfin.DirichletBC(P2, u0, boundary1)
u, p = dolfin.TrialFunction(P2), dolfin.TrialFunction(P1)
v, q = dolfin.TestFunction(P2), dolfin.TestFunction(P1)
a00 = inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a11 = None
p00 = a00
p01, p10 = None, None
p11 = inner(p, q) * dx
# FIXME
# We need zero function for the 'zero' part of L
p_zero = dolfin.Function(P1)
f = dolfin.Function(P2)
L0 = ufl.inner(f, v) * dx
L1 = ufl.inner(p_zero, q) * dx
# -- Blocked and nested
A0 = dolfin.fem.assemble_matrix_nest([[a00, a01], [a10, a11]], [bc0, bc1])
A0norm = nest_matrix_norm(A0)
P0 = dolfin.fem.assemble_matrix_nest([[p00, p01], [p10, p11]], [bc0, bc1])
P0norm = nest_matrix_norm(P0)
b0 = dolfin.fem.assemble_vector_nest([L0, L1], [[a00, a01], [a10, a11]],
[bc0, bc1])
b0norm = b0.norm()
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A0, P0)
nested_IS = P0.getNestISs()
ksp.setType("minres")
pc = ksp.getPC()
pc.setType("fieldsplit")
pc.setFieldSplitIS(["u", nested_IS[0][0]], ["p", nested_IS[1][1]])
ksp_u, ksp_p = pc.getFieldSplitSubKSP()
ksp_u.setType("preonly")
ksp_u.getPC().setType('lu')
ksp_u.getPC().setFactorSolverType('mumps')
ksp_p.setType("preonly")
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x0 = b0.copy()
ksp.solve(b0, x0)
assert ksp.getConvergedReason() > 0
# -- Blocked and monolithic
A1 = dolfin.fem.assemble_matrix_block([[a00, a01], [a10, a11]], [bc0, bc1])
assert A1.norm() == pytest.approx(A0norm, 1.0e-12)
P1 = dolfin.fem.assemble_matrix_block([[p00, p01], [p10, p11]], [bc0, bc1])
assert P1.norm() == pytest.approx(P0norm, 1.0e-12)
b1 = dolfin.fem.assemble_vector_block([L0, L1], [[a00, a01], [a10, a11]],
[bc0, bc1])
assert b1.norm() == pytest.approx(b0norm, 1.0e-12)
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A1, P1)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
pc.setFactorSolverType('mumps')
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setFromOptions()
x1 = A1.createVecRight()
ksp.solve(b1, x1)
assert ksp.getConvergedReason() > 0
assert x1.norm() == pytest.approx(x0.norm(), 1e-8)
# -- Monolithic
P2 = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1 = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2 * P1
W = dolfin.FunctionSpace(mesh, TH)
(u, p) = dolfin.TrialFunctions(W)
(v, q) = dolfin.TestFunctions(W)
a00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a = a00 + a01 + a10
p00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
p11 = ufl.inner(p, q) * dx
p_form = p00 + p11
f = dolfin.Function(W.sub(0).collapse())
p_zero = dolfin.Function(W.sub(1).collapse())
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
bc0 = dolfin.DirichletBC(W.sub(0), u0, boundary0)
bc1 = dolfin.DirichletBC(W.sub(0), u0, boundary1)
A2 = dolfin.fem.assemble_matrix(a, [bc0, bc1])
A2.assemble()
assert A2.norm() == pytest.approx(A0norm, 1.0e-12)
P2 = dolfin.fem.assemble_matrix(p_form, [bc0, bc1])
P2.assemble()
assert P2.norm() == pytest.approx(P0norm, 1.0e-12)
b2 = dolfin.fem.assemble_vector(L)
dolfin.fem.apply_lifting(b2, [a], [[bc0, bc1]])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
dolfin.fem.set_bc(b2, [bc0, bc1])
b2norm = b2.norm()
assert b2norm == pytest.approx(b0norm, 1.0e-12)
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A2, P2)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
pc.setFactorSolverType('mumps')
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x2 = A2.createVecRight()
ksp.solve(b2, x2)
assert ksp.getConvergedReason() > 0
assert x0.norm() == pytest.approx(x2.norm(), 1e-8)
def test_manufactured_poisson_dg(degree, filename, datadir):
""" Manufactured Poisson problem, solving u = x[component]**n, where n is the
degree of the Lagrange function space.
"""
with XDMFFile(MPI.COMM_WORLD,
os.path.join(datadir, filename),
"r",
encoding=XDMFFile.Encoding.ASCII) as xdmf:
mesh = xdmf.read_mesh(name="Grid")
V = FunctionSpace(mesh, ("DG", degree))
u, v = TrialFunction(V), TestFunction(V)
# Exact solution
x = SpatialCoordinate(mesh)
u_exact = x[1]**degree
# Coefficient
k = Function(V)
k.vector.set(2.0)
k.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
# Source term
f = -div(k * grad(u_exact))
# Mesh normals and element size
n = FacetNormal(mesh)
h = CellDiameter(mesh)
h_avg = (h("+") + h("-")) / 2.0
# Penalty parameter
alpha = 32
dx_ = dx(metadata={"quadrature_degree": -1})
ds_ = ds(metadata={"quadrature_degree": -1})
dS_ = dS(metadata={"quadrature_degree": -1})
a = inner(k * grad(u), grad(v)) * dx_ \
- k("+") * inner(avg(grad(u)), jump(v, n)) * dS_ \
- k("+") * inner(jump(u, n), avg(grad(v))) * dS_ \
+ k("+") * (alpha / h_avg) * inner(jump(u, n), jump(v, n)) * dS_ \
- inner(k * grad(u), v * n) * ds_ \
- inner(u * n, k * grad(v)) * ds_ \
+ (alpha / h) * inner(k * u, v) * ds_
L = inner(f, v) * dx_ - inner(k * u_exact * n, grad(v)) * ds_ \
+ (alpha / h) * inner(k * u_exact, v) * ds_
for integral in a.integrals():
integral.metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(
a)
for integral in L.integrals():
integral.metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(
L)
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
A = assemble_matrix(a, [])
A.assemble()
# Create LU linear solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
# Solve
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
error = mesh.mpi_comm().allreduce(assemble_scalar((u_exact - uh)**2 * dx),
op=MPI.SUM)
assert np.absolute(error) < 1.0e-14
# <dolfin.cpp.function.FunctionSpace>`. Since we have a # mixed function space, we write # ``W.sub(0)`` for the velocity component of the space, and # ``W.sub(1)`` for the pressure component of the space. # The second argument specifies the value on the Dirichlet # boundary. The last two arguments specify the marking of the subdomains: # ``sub_domains`` contains the subdomain markers, and the final argument is the subdomain index. # # The bilinear and linear forms corresponding to the weak mixed # formulation of the Stokes equations are defined as follows:: # Define variational problem (u, p) = TrialFunctions(W) (v, q) = TestFunctions(W) f = Function(W.sub(0).collapse()) a = (inner(grad(u), grad(v)) - inner(p, div(v)) + inner(div(u), q)) * dx L = inner(f, v) * dx # We also need to create a :py:class:`Function # <dolfin.cpp.function.Function>` to store the solution(s). The (full) # solution will be stored in ``w``, which we initialize using the mixed # function space ``W``. The actual # computation is performed by calling solve with the arguments ``a``, # ``L``, ``w`` and ``bcs``. The separate components ``u`` and ``p`` of # the solution can be extracted by calling the :py:meth:`split # <dolfin.functions.function.Function.split>` function. Here we use an # optional argument True in the split function to specify that we want a # deep copy. If no argument is given we will get a shallow copy. We want # a deep copy for further computations on the coefficient vectors:: # Compute solution
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with UFL. If not, see <http://www.gnu.org/licenses/>.
#
# Modified by Martin Sandve Alnes, 2009
#
# Last changed: 2009-01-12
#
# The bilinear form a(v, u) and linear form L(v) for
# a mixed formulation of Poisson's equation with BDM
# (Brezzi-Douglas-Marini) elements.
#
from ufl import (Coefficient, FiniteElement, TestFunctions, TrialFunctions,
div, dot, dx, triangle)
cell = triangle
BDM1 = FiniteElement("Brezzi-Douglas-Marini", cell, 1)
DG0 = FiniteElement("Discontinuous Lagrange", cell, 0)
element = BDM1 * DG0
(tau, w) = TestFunctions(element)
(sigma, u) = TrialFunctions(element)
f = Coefficient(DG0)
a = (dot(tau, sigma) - div(tau) * u + w * div(sigma)) * dx
L = w * f * dx
def test_assembly_solve_taylor_hood(mesh):
"""Assemble Stokes problem with Taylor-Hood elements and solve."""
P2 = fem.VectorFunctionSpace(mesh, ("Lagrange", 2))
P1 = fem.FunctionSpace(mesh, ("Lagrange", 1))
def boundary0(x):
"""Define boundary x = 0"""
return x[0] < 10 * numpy.finfo(float).eps
def boundary1(x):
"""Define boundary x = 1"""
return x[0] > (1.0 - 10 * numpy.finfo(float).eps)
# Locate facets on boundaries
facetdim = mesh.topology.dim - 1
bndry_facets0 = dolfinx.mesh.locate_entities_boundary(
mesh, facetdim, boundary0)
bndry_facets1 = dolfinx.mesh.locate_entities_boundary(
mesh, facetdim, boundary1)
bdofs0 = dolfinx.fem.locate_dofs_topological(P2, facetdim, bndry_facets0)
bdofs1 = dolfinx.fem.locate_dofs_topological(P2, facetdim, bndry_facets1)
u0 = dolfinx.Function(P2)
u0.vector.set(1.0)
u0.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
bc0 = dolfinx.DirichletBC(u0, bdofs0)
bc1 = dolfinx.DirichletBC(u0, bdofs1)
u, p = ufl.TrialFunction(P2), ufl.TrialFunction(P1)
v, q = ufl.TestFunction(P2), ufl.TestFunction(P1)
a00 = inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a11 = None
p00 = a00
p01, p10 = None, None
p11 = inner(p, q) * dx
# FIXME
# We need zero function for the 'zero' part of L
p_zero = dolfinx.Function(P1)
f = dolfinx.Function(P2)
L0 = ufl.inner(f, v) * dx
L1 = ufl.inner(p_zero, q) * dx
def nested_solve():
"""Nested solver"""
A = dolfinx.fem.assemble_matrix_nest([[a00, a01], [a10, a11]],
[bc0, bc1],
[["baij", "aij"], ["aij", ""]])
A.assemble()
P = dolfinx.fem.assemble_matrix_nest([[p00, p01], [p10, p11]],
[bc0, bc1],
[["aij", "aij"], ["aij", ""]])
P.assemble()
b = dolfinx.fem.assemble_vector_nest([L0, L1])
dolfinx.fem.apply_lifting_nest(b, [[a00, a01], [a10, a11]], [bc0, bc1])
for b_sub in b.getNestSubVecs():
b_sub.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
bcs = dolfinx.cpp.fem.bcs_rows(
dolfinx.fem.assemble._create_cpp_form([L0, L1]), [bc0, bc1])
dolfinx.fem.set_bc_nest(b, bcs)
b.assemble()
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A, P)
nested_IS = P.getNestISs()
ksp.setType("minres")
pc = ksp.getPC()
pc.setType("fieldsplit")
pc.setFieldSplitIS(["u", nested_IS[0][0]], ["p", nested_IS[1][1]])
ksp_u, ksp_p = pc.getFieldSplitSubKSP()
ksp_u.setType("preonly")
ksp_u.getPC().setType('lu')
ksp_p.setType("preonly")
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x = b.copy()
ksp.solve(b, x)
assert ksp.getConvergedReason() > 0
return b.norm(), x.norm(), nest_matrix_norm(A), nest_matrix_norm(P)
def blocked_solve():
"""Blocked (monolithic) solver"""
A = dolfinx.fem.assemble_matrix_block([[a00, a01], [a10, a11]],
[bc0, bc1])
A.assemble()
P = dolfinx.fem.assemble_matrix_block([[p00, p01], [p10, p11]],
[bc0, bc1])
P.assemble()
b = dolfinx.fem.assemble_vector_block([L0, L1],
[[a00, a01], [a10, a11]],
[bc0, bc1])
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A, P)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setFromOptions()
x = A.createVecRight()
ksp.solve(b, x)
assert ksp.getConvergedReason() > 0
return b.norm(), x.norm(), A.norm(), P.norm()
def monolithic_solve():
"""Monolithic (interleaved) solver"""
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = dolfinx.FunctionSpace(mesh, TH)
(u, p) = ufl.TrialFunctions(W)
(v, q) = ufl.TestFunctions(W)
a00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a = a00 + a01 + a10
p00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
p11 = ufl.inner(p, q) * dx
p_form = p00 + p11
f = dolfinx.Function(W.sub(0).collapse())
p_zero = dolfinx.Function(W.sub(1).collapse())
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
bdofsW0_P2_0 = dolfinx.fem.locate_dofs_topological(
(W.sub(0), P2), facetdim, bndry_facets0)
bdofsW0_P2_1 = dolfinx.fem.locate_dofs_topological(
(W.sub(0), P2), facetdim, bndry_facets1)
bc0 = dolfinx.DirichletBC(u0, bdofsW0_P2_0, W.sub(0))
bc1 = dolfinx.DirichletBC(u0, bdofsW0_P2_1, W.sub(0))
A = dolfinx.fem.assemble_matrix(a, [bc0, bc1])
A.assemble()
P = dolfinx.fem.assemble_matrix(p_form, [bc0, bc1])
P.assemble()
b = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b, [a], [[bc0, bc1]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b, [bc0, bc1])
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A, P)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x = A.createVecRight()
ksp.solve(b, x)
assert ksp.getConvergedReason() > 0
return b.norm(), x.norm(), A.norm(), P.norm()
bnorm0, xnorm0, Anorm0, Pnorm0 = nested_solve()
bnorm1, xnorm1, Anorm1, Pnorm1 = blocked_solve()
bnorm2, xnorm2, Anorm2, Pnorm2 = monolithic_solve()
assert bnorm1 == pytest.approx(bnorm0, 1.0e-12)
assert xnorm1 == pytest.approx(xnorm0, 1.0e-8)
assert Anorm1 == pytest.approx(Anorm0, 1.0e-12)
assert Pnorm1 == pytest.approx(Pnorm0, 1.0e-12)
assert bnorm2 == pytest.approx(bnorm0, 1.0e-12)
assert xnorm2 == pytest.approx(xnorm0, 1.0e-8)
assert Anorm2 == pytest.approx(Anorm0, 1.0e-12)
assert Pnorm2 == pytest.approx(Pnorm0, 1.0e-12)
def test_assembly_solve_taylor_hood(mesh):
"""Assemble Stokes problem with Taylor-Hood elements and solve."""
P2 = function.VectorFunctionSpace(mesh, ("Lagrange", 2))
P1 = function.FunctionSpace(mesh, ("Lagrange", 1))
def boundary0(x):
"""Define boundary x = 0"""
return x[0] < 10 * numpy.finfo(float).eps
def boundary1(x):
"""Define boundary x = 1"""
return x[0] > (1.0 - 10 * numpy.finfo(float).eps)
facetdim = mesh.topology.dim - 1
mf = dolfinx.MeshFunction("size_t", mesh, facetdim, 0)
mf.mark(boundary0, 1)
mf.mark(boundary1, 2)
bndry_facets0 = numpy.where(mf.values == 1)[0]
bndry_facets1 = numpy.where(mf.values == 2)[0]
bdofs0 = dolfinx.fem.locate_dofs_topological(P2, facetdim, bndry_facets0)
bdofs1 = dolfinx.fem.locate_dofs_topological(P2, facetdim, bndry_facets1)
u0 = dolfinx.Function(P2)
u0.vector.set(1.0)
u0.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
bc0 = dolfinx.DirichletBC(u0, bdofs0)
bc1 = dolfinx.DirichletBC(u0, bdofs1)
u, p = ufl.TrialFunction(P2), ufl.TrialFunction(P1)
v, q = ufl.TestFunction(P2), ufl.TestFunction(P1)
a00 = inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a11 = None
p00 = a00
p01, p10 = None, None
p11 = inner(p, q) * dx
# FIXME
# We need zero function for the 'zero' part of L
p_zero = dolfinx.Function(P1)
f = dolfinx.Function(P2)
L0 = ufl.inner(f, v) * dx
L1 = ufl.inner(p_zero, q) * dx
# -- Blocked (nested)
A0 = dolfinx.fem.assemble_matrix_nest([[a00, a01], [a10, a11]], [bc0, bc1])
A0.assemble()
A0norm = nest_matrix_norm(A0)
P0 = dolfinx.fem.assemble_matrix_nest([[p00, p01], [p10, p11]], [bc0, bc1])
P0.assemble()
P0norm = nest_matrix_norm(P0)
b0 = dolfinx.fem.assemble_vector_nest([L0, L1])
dolfinx.fem.apply_lifting_nest(b0, [[a00, a01], [a10, a11]], [bc0, bc1])
for b_sub in b0.getNestSubVecs():
b_sub.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
bcs0 = dolfinx.cpp.fem.bcs_rows(
dolfinx.fem.assemble._create_cpp_form([L0, L1]), [bc0, bc1])
dolfinx.fem.set_bc_nest(b0, bcs0)
b0.assemble()
b0norm = b0.norm()
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A0, P0)
nested_IS = P0.getNestISs()
ksp.setType("minres")
pc = ksp.getPC()
pc.setType("fieldsplit")
pc.setFieldSplitIS(["u", nested_IS[0][0]], ["p", nested_IS[1][1]])
ksp_u, ksp_p = pc.getFieldSplitSubKSP()
ksp_u.setType("preonly")
ksp_u.getPC().setType('lu')
ksp_u.getPC().setFactorSolverType('mumps')
ksp_p.setType("preonly")
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x0 = b0.copy()
ksp.solve(b0, x0)
assert ksp.getConvergedReason() > 0
# -- Blocked (monolithic)
A1 = dolfinx.fem.assemble_matrix_block([[a00, a01], [a10, a11]],
[bc0, bc1])
A1.assemble()
assert A1.norm() == pytest.approx(A0norm, 1.0e-12)
P1 = dolfinx.fem.assemble_matrix_block([[p00, p01], [p10, p11]],
[bc0, bc1])
P1.assemble()
assert P1.norm() == pytest.approx(P0norm, 1.0e-12)
b1 = dolfinx.fem.assemble_vector_block([L0, L1], [[a00, a01], [a10, a11]],
[bc0, bc1])
assert b1.norm() == pytest.approx(b0norm, 1.0e-12)
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A1, P1)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
pc.setFactorSolverType('mumps')
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setFromOptions()
x1 = A1.createVecRight()
ksp.solve(b1, x1)
assert ksp.getConvergedReason() > 0
assert x1.norm() == pytest.approx(x0.norm(), 1e-8)
# -- Monolithic
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = dolfinx.FunctionSpace(mesh, TH)
(u, p) = ufl.TrialFunctions(W)
(v, q) = ufl.TestFunctions(W)
a00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a = a00 + a01 + a10
p00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
p11 = ufl.inner(p, q) * dx
p_form = p00 + p11
f = dolfinx.Function(W.sub(0).collapse())
p_zero = dolfinx.Function(W.sub(1).collapse())
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
bdofsW0_P2_0 = dolfinx.fem.locate_dofs_topological((W.sub(0), P2),
facetdim, bndry_facets0)
bdofsW0_P2_1 = dolfinx.fem.locate_dofs_topological((W.sub(0), P2),
facetdim, bndry_facets1)
bc0 = dolfinx.DirichletBC(u0, bdofsW0_P2_0, W.sub(0))
bc1 = dolfinx.DirichletBC(u0, bdofsW0_P2_1, W.sub(0))
A2 = dolfinx.fem.assemble_matrix(a, [bc0, bc1])
A2.assemble()
assert A2.norm() == pytest.approx(A0norm, 1.0e-12)
P2 = dolfinx.fem.assemble_matrix(p_form, [bc0, bc1])
P2.assemble()
assert P2.norm() == pytest.approx(P0norm, 1.0e-12)
b2 = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b2, [a], [[bc0, bc1]])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b2, [bc0, bc1])
b2norm = b2.norm()
assert b2norm == pytest.approx(b0norm, 1.0e-12)
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A2, P2)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
pc.setFactorSolverType('mumps')
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x2 = A2.createVecRight()
ksp.solve(b2, x2)
assert ksp.getConvergedReason() > 0
assert x0.norm() == pytest.approx(x2.norm(), 1e-8)
def save_div(self, is_tent, field):
self.tc.start('div')
self.divFunction.assign(project(div(field), self.divSpace))
self.fileDict['d2' if is_tent else 'd']['file'].write(self.divFunction, self.actual_time)
self.tc.end('div')
def F(u, v, q):
return (inner(T(u), grad(v)) - q * div(u)) * dx + inner(grad(u) * u, v) * dx
