def set_options(self,slepc_options):
print("---- setting additional slepc options -----")
for (opt, value) in slepc_options.items():
print(" ",opt,":",value)
PETScOptions.set(opt,value)
print("-------------------------------------------")
self.E.setFromOptions()
def set_options(self, slepc_options, verbose=True):
if verbose == True:
print("---- setting additional slepc options -----")
for (opt, value) in slepc_options.items():
if verbose == True:
print(" ", opt, ":", value)
PETScOptions.set(opt, value)
self.E.setFromOptions()
def set_solver_alpha_tao(self):
self.problem_alpha = DamageProblemTAO(self.energy,
self.alpha,
self.bcs_alpha,
lb=self.alpha_init)
solver = PETScTAOSolver()
for option, value in self.parameters["solver_alpha_tao"].items():
PETScOptions.set(option, value)
# PETScOptions.set('help', 1)
print('setting {} {}'.format(option, value))
self.solver_alpha = solver
def __init__(self, problem, parameters={}, lb=None):
super(DamageSolverSNES, self).__init__()
self.problem = problem
self.energy = problem.energy
self.state = problem.state
self.alpha = problem.state['alpha']
self.alpha_dvec = as_backend_type(self.alpha.vector())
self.alpha_pvec = self.alpha_dvec.vec()
self.bcs = problem.bcs
self.parameters = parameters
comm = self.alpha.function_space().mesh().mpi_comm()
self.comm = comm
V = self.alpha.function_space()
self.V = V
self.Ealpha = derivative(
self.energy, self.alpha,
dolfin.TestFunction(self.alpha.ufl_function_space()))
self.dm = self.alpha.function_space().dofmap()
solver = PETScSNESSolver()
snes = solver.snes()
if lb == None:
lb = interpolate(Constant(0.), V)
ub = interpolate(Constant(1.), V)
prefix = "damage_"
snes.setOptionsPrefix(prefix)
for option, value in self.parameters["snes"].items():
PETScOptions.set(prefix + option, value)
log(LogLevel.DEBUG,
"DEBUG: Set: {} = {}".format(prefix + option, value))
snes.setFromOptions()
(J, F, bcs_alpha) = (problem.J, problem.F, problem.bcs)
self.ass = SystemAssembler(J, F, bcs_alpha)
self.b = self.init_residual()
snes.setFunction(self.residual, self.b.vec())
self.A = self.init_jacobian()
snes.setJacobian(self.jacobian, self.A.mat())
snes.ksp.setOperators(self.A.mat())
snes.setVariableBounds(self.problem.lb.vec(), self.problem.ub.vec()) #
# snes.solve(None, Function(V).vector().vec())
self.solver = snes
def __init__(self, energy, state, bcs, parameters={}):
super(ElasticitySolver, self).__init__()
solver_name = 'elasticity'
self.problem = ElasticityProblem(energy, state, bcs)
# Set the solver
self.solver = PETScSNESSolver()
snes = self.solver.snes()
prefix = "elasticity_"
snes.setOptionsPrefix(prefix)
print(parameters)
for parameter, value in parameters.items():
log(LogLevel.DEBUG,
"DEBUG: Set: {} = {}".format(prefix + parameter, value))
PETScOptions.set(prefix + parameter, value)
snes.setFromOptions()
def set_solver_u(self):
for option, value in self.parameters["solver_u"].items():
print("setting ", option, value)
PETScOptions.set(option, value)
solver = PETScSNESSolver()
snes = solver.snes()
snes.setOptionsPrefix("u_")
snes.setType(self.parameters["solver_u"]["u_snes_type"])
ksp = snes.getKSP()
ksp.setType("preonly")
pc = ksp.getPC()
pc.setType("lu")
# Namespace mismatch between petsc4py 3.7 and 3.9.
if hasattr(pc, 'setFactorSolverType'):
pc.setFactorSolverType("mumps")
elif hasattr(pc, 'setFactorSolverPackage'):
pc.setFactorSolverPackage('mumps')
else:
ColorPrint.print_warn('Could not configure preconditioner')
solver.set_from_options()
snes.setFromOptions()
self.solver_u = solver
def stokes_solve(
up_out,
mu,
u_bcs, p_bcs,
f,
dx=dx,
verbose=True,
tol=1.0e-10,
maxiter=1000
):
# Some initial sanity checks.
assert mu > 0.0
WP = up_out.function_space()
# Translate the boundary conditions into the product space.
new_bcs = []
for k, bcs in enumerate([u_bcs, p_bcs]):
for bc in bcs:
space = bc.function_space()
C = space.component()
if len(C) == 0:
new_bcs.append(DirichletBC(WP.sub(k),
bc.value(),
bc.domain_args[0]))
elif len(C) == 1:
new_bcs.append(DirichletBC(WP.sub(k).sub(int(C[0])),
bc.value(),
bc.domain_args[0]))
else:
raise RuntimeError('Illegal number of subspace components.')
# TODO define p*=-1 and reverse sign in the end to get symmetric system?
# Define variational problem
(u, p) = TrialFunctions(WP)
(v, q) = TestFunctions(WP)
r = Expression('x[0]', degree=1, domain=WP.mesh())
print("mu = %e" % mu)
# build system
a = mu * inner(r * grad(u), grad(v)) * 2 * pi * dx \
- ((r * v[0]).dx(0) + (r * v[1]).dx(1)) * p * 2 * pi * dx \
+ ((r * u[0]).dx(0) + (r * u[1]).dx(1)) * q * 2 * pi * dx
#- div(r*v)*p* 2*pi*dx \
#+ q*div(r*u)* 2*pi*dx
L = inner(f, v) * 2 * pi * r * dx
A, b = assemble_system(a, L, new_bcs)
mode = 'lu'
if mode == 'lu':
solve(A, up_out.vector(), b, 'lu')
elif mode == 'gmres':
# For preconditioners for the Stokes system, see
#
# Fast iterative solvers for discrete Stokes equations;
# J. Peters, V. Reichelt, A. Reusken.
#
prec = mu * inner(r * grad(u), grad(v)) * 2 * pi * dx \
- p * q * 2 * pi * r * dx
P, btmp = assemble_system(prec, L, new_bcs)
solver = KrylovSolver('tfqmr', 'amg')
#solver = KrylovSolver('gmres', 'amg')
solver.set_operators(A, P)
solver.parameters['monitor_convergence'] = verbose
solver.parameters['report'] = verbose
solver.parameters['absolute_tolerance'] = 0.0
solver.parameters['relative_tolerance'] = tol
solver.parameters['maximum_iterations'] = maxiter
# Solve
solver.solve(up_out.vector(), b)
elif mode == 'fieldsplit':
raise NotImplementedError('Fieldsplit solver not yet implemented.')
# For an assortment of preconditioners, see
#
# Performance and analysis of saddle point preconditioners
# for the discrete steady-state Navier-Stokes equations;
# H.C. Elman, D.J. Silvester, A.J. Wathen;
# Numer. Math. (2002) 90: 665-688;
# <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.145.3554>.
#
# Set up field split.
W = SubSpace(WP, 0)
P = SubSpace(WP, 1)
u_dofs = W.dofmap().dofs()
p_dofs = P.dofmap().dofs()
prec = PETScPreconditioner()
prec.set_fieldsplit([u_dofs, p_dofs], ['u', 'p'])
PETScOptions.set('pc_type', 'fieldsplit')
PETScOptions.set('pc_fieldsplit_type', 'additive')
PETScOptions.set('fieldsplit_u_pc_type', 'lu')
PETScOptions.set('fieldsplit_p_pc_type', 'jacobi')
# Create Krylov solver with custom preconditioner.
solver = PETScKrylovSolver('gmres', prec)
solver.set_operator(A)
return
# along with RBniCS. If not, see <http://www.gnu.org/licenses/>.
#
import pytest
from numpy import dot, isclose
from numpy.linalg import norm as monitor_norm
from dolfin import assemble, Constant, derivative, DirichletBC, DOLFIN_EPS, dx, Expression, Function, FunctionSpace, grad, inner, IntervalMesh, PETScOptions, pi, plot, project, sin, TestFunction, TrialFunction
import matplotlib
import matplotlib.pyplot as plt
from rbnics.backends.abstract import TimeDependentProblem1Wrapper
from rbnics.backends.dolfin import TimeStepping as SparseTimeStepping
from rbnics.backends.online.numpy import Function as DenseFunction, Matrix as DenseMatrix, TimeStepping as DenseTimeStepping, Vector as DenseVector
from rbnics.backends.online.numpy.time_stepping import has_IDA
# Additional command line options for PETSc TS
PETScOptions.set("ts_bdf_order", "3")
PETScOptions.set("ts_bdf_adapt", "true")
"""
Solve
u_t - u_xx = g, (t, x) in [0, 1] x [0, 2*pi]
u = sin(t), (t, x) in [0, 1] x {0, 2*pi}
u = sin(x), (t, x) in {0} x [0, 2*pi]
for g such that u = u_ex = sin(x+t)
"""
# ~~~ Sparse case ~~~ #
def _test_time_stepping_1_sparse(callback_type, integrator_type):
# Create mesh and define function space
mesh = IntervalMesh(132, 0, 2*pi)
V = FunctionSpace(mesh, "Lagrange", 1)
def setSnesMonitor(prefix):
PETScOptions.set(prefix + "snes_monitor_cancel")
PETScOptions.set(prefix + "snes_monitor")
def test_poisson(k):
# Polynomial order and mesh resolution
nx_list = [4, 8, 16]
# Error list
error_u_l2, error_u_h1 = [], []
for nx in nx_list:
mesh = UnitSquareMesh(nx, nx)
# Define FunctionSpaces and functions
V = FunctionSpace(mesh, "DG", k)
Vbar = FunctionSpace(mesh,
FiniteElement("CG", mesh.ufl_cell(), k)["facet"])
u_soln = Expression("sin(pi*x[0])*sin(pi*x[1])",
degree=k + 1,
domain=mesh)
f = Expression("2*pi*pi*sin(pi*x[0])*sin(pi*x[1])", degree=k + 1)
u, v = Function(V), TestFunction(V)
ubar, vbar = Function(Vbar), TestFunction(Vbar)
n = FacetNormal(mesh)
h = CellDiameter(mesh)
alpha = Constant(6 * k * k)
penalty = alpha / h
def facet_integral(integrand):
return integrand('-') * dS + integrand('+') * dS + integrand * ds
u_flux = ubar
F_v_flux = grad(u) + penalty * outer(u_flux - u, n)
residual_local = inner(grad(u), grad(v)) * dx
residual_local += facet_integral(inner(outer(u_flux - u, n), grad(v)))
residual_local -= facet_integral(inner(F_v_flux, outer(v, n)))
residual_local -= f * v * dx
residual_global = facet_integral(inner(F_v_flux, outer(vbar, n)))
a_ll = derivative(residual_local, u)
a_lg = derivative(residual_local, ubar)
a_gl = derivative(residual_global, u)
a_gg = derivative(residual_global, ubar)
l_l = -residual_local
l_g = -residual_global
bcs = [DirichletBC(Vbar, u_soln, "on_boundary")]
# Initialize static condensation assembler
assembler = AssemblerStaticCondensation(a_ll, a_lg, a_gl, a_gg, l_l,
l_g, bcs)
A_g, b_g = PETScMatrix(), PETScVector()
assembler.assemble_global_lhs(A_g)
assembler.assemble_global_rhs(b_g)
for bc in bcs:
bc.apply(A_g, b_g)
solver = PETScKrylovSolver()
solver.set_operator(A_g)
PETScOptions.set("ksp_type", "preonly")
PETScOptions.set("pc_type", "lu")
PETScOptions.set("pc_factor_mat_solver_type", "mumps")
solver.set_from_options()
solver.solve(ubar.vector(), b_g)
assembler.backsubstitute(ubar._cpp_object, u._cpp_object)
# Compute L2 and H1 norms
e_u_l2 = assemble((u - u_soln)**2 * dx)**0.5
e_u_h1 = assemble(grad(u - u_soln)**2 * dx)**0.5
if mesh.mpi_comm().rank == 0:
error_u_l2.append(e_u_l2)
error_u_h1.append(e_u_h1)
if mesh.mpi_comm().rank == 0:
iterator_list = [1.0 / float(nx) for nx in nx_list]
conv_u_l2 = compute_convergence(iterator_list, error_u_l2)
conv_u_h1 = compute_convergence(iterator_list, error_u_h1)
# Optimal rate of k + 1 - tolerance
assert np.all(conv_u_l2 >= (k + 1.0 - 0.15))
# Optimal rate of k - tolerance
assert np.all(conv_u_h1 >= (k - 0.1))
from dolfin import set_log_level
from dolfin.cpp.log import log, LogLevel
from dolfin import PETScOptions
from slepc4py import SLEPc
from solver_stability import StabilitySolver
set_log_level(LogLevel.ERROR)
form_compiler_parameters = {
"representation": "uflacs",
"quadrature_degree": 2,
"optimize": True,
"cpp_optimize": True,
}
PETScOptions.set('tao_converged_reason', True)
petsc_options_alpha_tao = {"tao_type": "gpcg",
"tao_ls_type": "gpcg",
"tao_gpcg_maxpgits": 50,
"tao_max_it": 300,
"tao_steptol": 1e-7,
"tao_gatol": 1e-8,
"tao_grtol": 0.,
"tao_gttol": 0.,
"tao_catol": 0.,
"tao_crtol": 0.,
"tao_ls_ftol": 1e-6,
"tao_ls_gtol": 1e-6,
"tao_ls_rtol": 1e-6,
"ksp_rtol": 1e-6,
def compute_pressure(
P,
p0,
mu,
ui,
u,
my_dx,
p_bcs=None,
rotational_form=False,
tol=1.0e-10,
verbose=True,
):
"""Solve the pressure Poisson equation
.. math::
\\begin{align}
-\\frac{1}{r} \\div(r \\nabla (p_1-p_0)) =
-\\frac{1}{r} \\div(r u),\\\\
\\text{(with boundary conditions)},
\\end{align}
for :math:`\\nabla p = u`.
The pressure correction is based on the update formula
.. math::
\\frac{\\rho}{dt} (u_{n+1}-u^*)
+ \\begin{pmatrix}
\\text{d}\\phi/\\text{d}r\\\\
\\text{d}\\phi/\\text{d}z\\\\
\\frac{1}{r} \\text{d}\\phi/\\text{d}\\theta
\\end{pmatrix}
= 0
with :math:`\\phi = p_{n+1} - p^*` and
.. math::
\\frac{1}{r} \\frac{\\text{d}}{\\text{d}r} (r u_r^{(n+1)})
+ \\frac{\\text{d}}{\\text{d}z} (u_z^{(n+1)})
+ \\frac{1}{r} \\frac{\\text{d}}{\\text{d}\\theta} (u_{\\theta}^{(n+1)})
= 0
With the assumption that u does not change in the direction
:math:`\\theta`, one derives
.. math::
- \\frac{1}{r} \\div(r \\nabla \\phi) =
\\frac{1}{r} \\frac{\\rho}{dt} \\div(r (u_{n+1} - u^*))\\\\
- \\frac{1}{r} \\langle n, r \\nabla \\phi\\rangle =
\\frac{1}{r} \\frac{\\rho}{dt} \\langle n, r (u_{n+1} - u^*)\\rangle
In its weak form, this is
.. math::
\\int r \\langle\\nabla\\phi, \\nabla q\\rangle \\,2 \\pi =
- \\frac{\\rho}{dt} \\int \\div(r u^*) q \\, 2 \\pi
- \\frac{\\rho}{dt} \\int_{\\Gamma}
\\langle n, r (u_{n+1}-u^*)\\rangle q \\, 2\\pi.
(The terms :math:`1/r` cancel with the volume elements :math:`2\\pi r`.)
If the Dirichlet boundary conditions are applied to both :math:`u^*` and
:math:`u_n` (the latter in the velocity correction step), the boundary
integral vanishes.
If no Dirichlet conditions are given (which is the default case), the
system has no unique solution; one eigenvalue is 0. This however, does not
hurt CG convergence if the system is consistent, cf. :cite:`vdV03`. And
indeed it is consistent if and only if
.. math::
\\int_\\Gamma r \\langle n, u\\rangle = 0.
This condition makes clear that for incompressible Navier-Stokes, one
either needs to make sure that inflow and outflow always add up to 0, or
one has to specify pressure boundary conditions.
Note that, when using a multigrid preconditioner as is done here, the
coarse solver must be chosen such that it preserves the nullspace of the
problem.
"""
W = ui.function_space()
r = SpatialCoordinate(W.mesh())[0]
p = TrialFunction(P)
q = TestFunction(P)
a2 = dot(r * grad(p), grad(q)) * 2 * pi * my_dx
# The boundary conditions
# n.(p1-p0) = 0
# are implicitly included.
#
# L2 = -div(r*u) * q * 2*pi*my_dx
div_u = 1 / r * (r * u[0]).dx(0) + u[1].dx(1)
L2 = -div_u * q * 2 * pi * r * my_dx
if p0:
L2 += r * dot(grad(p0), grad(q)) * 2 * pi * my_dx
# In the Cartesian variant of the rotational form, one makes use of the
# fact that
#
# curl(curl(u)) = grad(div(u)) - div(grad(u)).
#
# The same equation holds true in cylindrical form. Hence, to get the
# rotational form of the splitting scheme, we need to
#
# rotational form
if rotational_form:
# If there is no dependence of the angular coordinate, what is
# div(grad(div(u))) in Cartesian coordinates becomes
#
# 1/r div(r * grad(1/r div(r*u)))
#
# in cylindrical coordinates (div and grad are in cylindrical
# coordinates). Unfortunately, we cannot write it down that
# compactly since u_phi is in the game.
# When using P2 elements, this value will be 0 anyways.
div_ui = 1 / r * (r * ui[0]).dx(0) + ui[1].dx(1)
grad_div_ui = as_vector((div_ui.dx(0), div_ui.dx(1)))
L2 -= r * mu * dot(grad_div_ui, grad(q)) * 2 * pi * my_dx
# div_grad_div_ui = 1/r * (r * grad_div_ui[0]).dx(0) \
# + (grad_div_ui[1]).dx(1)
# L2 += mu * div_grad_div_ui * q * 2*pi*r*dx
# n = FacetNormal(Q.mesh())
# L2 -= mu * (n[0] * grad_div_ui[0] + n[1] * grad_div_ui[1]) \
# * q * 2*pi*r*ds
p1 = Function(P)
if p_bcs:
solve(
a2 == L2,
p1,
bcs=p_bcs,
solver_parameters={
"linear_solver": "iterative",
"symmetric": True,
"preconditioner": "hypre_amg",
"krylov_solver": {
"relative_tolerance": tol,
"absolute_tolerance": 0.0,
"maximum_iterations": 100,
"monitor_convergence": verbose,
},
},
)
else:
# If we're dealing with a pure Neumann problem here (which is the
# default case), this doesn't hurt CG if the system is consistent,
# cf. :cite:`vdV03`. And indeed it is consistent if and only if
#
# \int_\Gamma r n.u = 0.
#
# This makes clear that for incompressible Navier-Stokes, one
# either needs to make sure that inflow and outflow always add up
# to 0, or one has to specify pressure boundary conditions.
#
# If the right-hand side is very small, round-off errors may impair
# the consistency of the system. Make sure the system we are
# solving remains consistent.
A = assemble(a2)
b = assemble(L2)
# Assert that the system is indeed consistent.
e = Function(P)
e.interpolate(Constant(1.0))
evec = e.vector()
evec /= norm(evec)
alpha = b.inner(evec)
normB = norm(b)
# Assume that in every component of the vector, a round-off error
# of the magnitude DOLFIN_EPS is present. This leads to the
# criterion
# |<b,e>| / (||b||*||e||) < DOLFIN_EPS
# as a check whether to consider the system consistent up to
# round-off error.
#
# TODO think about condition here
# if abs(alpha) > normB * DOLFIN_EPS:
if abs(alpha) > normB * 1.0e-12:
# divu = 1 / r * (r * u[0]).dx(0) + u[1].dx(1)
adivu = assemble(((r * u[0]).dx(0) + u[1].dx(1)) * 2 * pi * my_dx)
info("\\int 1/r * div(r*u) * 2*pi*r = {:e}".format(adivu))
n = FacetNormal(P.mesh())
boundary_integral = assemble((n[0] * u[0] + n[1] * u[1]) * 2 * pi * r * ds)
info("\\int_Gamma n.u * 2*pi*r = {:e}".format(boundary_integral))
message = (
"System not consistent! "
"<b,e> = {:g}, ||b|| = {:g}, <b,e>/||b|| = {:e}.".format(
alpha, normB, alpha / normB
)
)
info(message)
# # Plot the stuff, and project it to a finer mesh with linear
# # elements for the purpose.
# plot(divu, title='div(u_tentative)')
# # Vp = FunctionSpace(Q.mesh(), 'CG', 2)
# # Wp = MixedFunctionSpace([Vp, Vp])
# # up = project(u, Wp)
# fine_mesh = Q.mesh()
# for k in range(1):
# fine_mesh = refine(fine_mesh)
# V = FunctionSpace(fine_mesh, 'CG', 1)
# W = V * V
# # uplot = Function(W)
# # uplot.interpolate(u)
# uplot = project(u, W)
# plot(uplot[0], title='u_tentative[0]')
# plot(uplot[1], title='u_tentative[1]')
# # plot(u, title='u_tentative')
# interactive()
# exit()
raise RuntimeError(message)
# Project out the roundoff error.
b -= alpha * evec
#
# In principle, the ILU preconditioner isn't advised here since it
# might destroy the semidefiniteness needed for CG.
#
# The system is consistent, but the matrix has an eigenvalue 0.
# This does not harm the convergence of CG, but when
# preconditioning one has to make sure that the preconditioner
# preserves the kernel. ILU might destroy this (and the
# semidefiniteness). With AMG, the coarse grid solves cannot be LU
# then, so try Jacobi here.
# <http://lists.mcs.anl.gov/pipermail/petsc-users/2012-February/012139.html>
#
prec = PETScPreconditioner("hypre_amg")
from dolfin import PETScOptions
PETScOptions.set("pc_hypre_boomeramg_relax_type_coarse", "jacobi")
solver = PETScKrylovSolver("cg", prec)
solver.parameters["absolute_tolerance"] = 0.0
solver.parameters["relative_tolerance"] = tol
solver.parameters["maximum_iterations"] = 100
solver.parameters["monitor_convergence"] = verbose
# Create solver and solve system
A_petsc = as_backend_type(A)
b_petsc = as_backend_type(b)
p1_petsc = as_backend_type(p1.vector())
solver.set_operator(A_petsc)
solver.solve(p1_petsc, b_petsc)
return p1
def solve(W, P,
mu,
u_bcs, p_bcs,
f,
verbose=True,
tol=1.0e-10
):
# Some initial sanity checks.
assert mu > 0.0
WP = MixedFunctionSpace([W, P])
# Translate the boundary conditions into the product space.
# This conditional loop is able to deal with conditions of the kind
#
# DirichletBC(W.sub(1), 0.0, right_boundary)
#
new_bcs = []
for k, bcs in enumerate([u_bcs, p_bcs]):
for bc in bcs:
space = bc.function_space()
C = space.component()
if len(C) == 0:
new_bcs.append(DirichletBC(WP.sub(k),
bc.value(),
bc.domain_args[0]))
elif len(C) == 1:
new_bcs.append(DirichletBC(WP.sub(k).sub(int(C[0])),
bc.value(),
bc.domain_args[0]))
else:
raise RuntimeError('Illegal number of subspace components.')
# Define variational problem
(u, p) = TrialFunctions(WP)
(v, q) = TestFunctions(WP)
# Build system.
# The sign of the div(u)-term is somewhat arbitrary since the right-hand
# side is 0 here. We can either make the system symmetric or positive-
# definite.
# On a second note, we have
#
# \int grad(p).v = - \int p * div(v) + \int_\Gamma p n.v.
#
# Since, we have either p=0 or n.v=0 on the boundary, we could as well
# replace the term dot(grad(p), v) by -p*div(v).
#
a = mu * inner(grad(u), grad(v))*dx \
- p * div(v) * dx \
- q * div(u) * dx
#a = mu * inner(grad(u), grad(v))*dx + dot(grad(p), v) * dx \
# - div(u) * q * dx
L = dot(f, v)*dx
A, b = assemble_system(a, L, new_bcs)
if has_petsc():
# For an assortment of preconditioners, see
#
# Performance and analysis of saddle point preconditioners
# for the discrete steady-state Navier-Stokes equations;
# H.C. Elman, D.J. Silvester, A.J. Wathen;
# Numer. Math. (2002) 90: 665-688;
# <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.145.3554>.
#
# Set up field split.
W = SubSpace(WP, 0)
P = SubSpace(WP, 1)
u_dofs = W.dofmap().dofs()
p_dofs = P.dofmap().dofs()
prec = PETScPreconditioner()
prec.set_fieldsplit([u_dofs, p_dofs], ['u', 'p'])
PETScOptions.set('pc_type', 'fieldsplit')
PETScOptions.set('pc_fieldsplit_type', 'additive')
PETScOptions.set('fieldsplit_u_pc_type', 'lu')
PETScOptions.set('fieldsplit_p_pc_type', 'jacobi')
## <http://scicomp.stackexchange.com/questions/7288/which-preconditioners-and-solver-in-petsc-for-indefinite-symmetric-systems-sho>
#PETScOptions.set('pc_type', 'fieldsplit')
##PETScOptions.set('pc_fieldsplit_type', 'schur')
##PETScOptions.set('pc_fieldsplit_schur_fact_type', 'upper')
#PETScOptions.set('pc_fieldsplit_detect_saddle_point')
##PETScOptions.set('fieldsplit_u_pc_type', 'lsc')
##PETScOptions.set('fieldsplit_u_ksp_type', 'preonly')
#PETScOptions.set('pc_type', 'fieldsplit')
#PETScOptions.set('fieldsplit_u_pc_type', 'hypre')
#PETScOptions.set('fieldsplit_u_ksp_type', 'preonly')
#PETScOptions.set('fieldsplit_p_pc_type', 'jacobi')
#PETScOptions.set('fieldsplit_p_ksp_type', 'preonly')
## From PETSc/src/ksp/ksp/examples/tutorials/ex42-fsschur.opts:
#PETScOptions.set('pc_type', 'fieldsplit')
#PETScOptions.set('pc_fieldsplit_type', 'SCHUR')
#PETScOptions.set('pc_fieldsplit_schur_fact_type', 'UPPER')
#PETScOptions.set('fieldsplit_p_ksp_type', 'preonly')
#PETScOptions.set('fieldsplit_u_pc_type', 'bjacobi')
## From
##
## Composable Linear Solvers for Multiphysics;
## J. Brown, M. Knepley, D.A. May, L.C. McInnes, B. Smith;
## <http://www.computer.org/csdl/proceedings/ispdc/2012/4805/00/4805a055-abs.html>;
## <http://www.mcs.anl.gov/uploads/cels/papers/P2017-0112.pdf>.
##
#PETScOptions.set('pc_type', 'fieldsplit')
#PETScOptions.set('pc_fieldsplit_type', 'schur')
#PETScOptions.set('pc_fieldsplit_schur_factorization_type', 'upper')
##
#PETScOptions.set('fieldsplit_u_ksp_type', 'cg')
#PETScOptions.set('fieldsplit_u_ksp_rtol', 1.0e-6)
#PETScOptions.set('fieldsplit_u_pc_type', 'bjacobi')
#PETScOptions.set('fieldsplit_u_sub_pc_type', 'cholesky')
##
#PETScOptions.set('fieldsplit_p_ksp_type', 'fgmres')
#PETScOptions.set('fieldsplit_p_ksp_constant_null_space')
#PETScOptions.set('fieldsplit_p_pc_type', 'lsc')
##
#PETScOptions.set('fieldsplit_p_lsc_ksp_type', 'cg')
#PETScOptions.set('fieldsplit_p_lsc_ksp_rtol', 1.0e-2)
#PETScOptions.set('fieldsplit_p_lsc_ksp_constant_null_space')
##PETScOptions.set('fieldsplit_p_lsc_ksp_converged_reason')
#PETScOptions.set('fieldsplit_p_lsc_pc_type', 'bjacobi')
#PETScOptions.set('fieldsplit_p_lsc_sub_pc_type', 'icc')
# Create Krylov solver with custom preconditioner.
solver = PETScKrylovSolver('gmres', prec)
solver.set_operator(A)
else:
# Use the preconditioner as recommended in
# <http://fenicsproject.org/documentation/dolfin/dev/python/demo/pde/stokes-iterative/python/documentation.html>,
#
# prec = inner(grad(u), grad(v))*dx - p*q*dx
#
# although it doesn't seem to be too efficient.
# The sign on the last term doesn't matter.
prec = mu * inner(grad(u), grad(v))*dx \
- p*q*dx
M, _ = assemble_system(prec, L, new_bcs)
#solver = KrylovSolver('tfqmr', 'amg')
solver = KrylovSolver('gmres', 'amg')
solver.set_operators(A, M)
solver.parameters['monitor_convergence'] = verbose
solver.parameters['report'] = verbose
solver.parameters['absolute_tolerance'] = 0.0
solver.parameters['relative_tolerance'] = tol
solver.parameters['maximum_iterations'] = 500
# Solve
up = Function(WP)
solver.solve(up.vector(), b)
# Get sub-functions
u, p = up.split()
return u, p
def _pressure_poisson(self, p1, p0,
mu, ui,
u,
p_bcs=None,
rotational_form=False,
tol=1.0e-10,
verbose=True
):
'''Solve the pressure Poisson equation
-1/r \div(r \nabla (p1-p0)) = -1/r div(r*u),
boundary conditions,
for
\nabla p = u.
'''
r = Expression('x[0]', degree=1, domain=self.W.mesh())
Q = p1.function_space()
p = TrialFunction(Q)
q = TestFunction(Q)
a2 = dot(r * grad(p), grad(q)) * 2 * pi * dx
# The boundary conditions
# n.(p1-p0) = 0
# are implicitly included.
#
# L2 = -div(r*u) * q * 2*pi*dx
div_u = 1/r * (r * u[0]).dx(0) + u[1].dx(1)
L2 = -div_u * q * 2*pi*r*dx
if p0:
L2 += r * dot(grad(p0), grad(q)) * 2*pi*dx
# In the Cartesian variant of the rotational form, one makes use of the
# fact that
#
# curl(curl(u)) = grad(div(u)) - div(grad(u)).
#
# The same equation holds true in cylindrical form. Hence, to get the
# rotational form of the splitting scheme, we need to
#
# rotational form
if rotational_form:
# If there is no dependence of the angular coordinate, what is
# div(grad(div(u))) in Cartesian coordinates becomes
#
# 1/r div(r * grad(1/r div(r*u)))
#
# in cylindrical coordinates (div and grad are in cylindrical
# coordinates). Unfortunately, we cannot write it down that
# compactly since u_phi is in the game.
# When using P2 elements, this value will be 0 anyways.
div_ui = 1/r * (r * ui[0]).dx(0) + ui[1].dx(1)
grad_div_ui = as_vector((div_ui.dx(0), div_ui.dx(1)))
L2 -= r * mu * dot(grad_div_ui, grad(q)) * 2*pi*dx
#div_grad_div_ui = 1/r * (r * grad_div_ui[0]).dx(0) \
# + (grad_div_ui[1]).dx(1)
#L2 += mu * div_grad_div_ui * q * 2*pi*r*dx
#n = FacetNormal(Q.mesh())
#L2 -= mu * (n[0] * grad_div_ui[0] + n[1] * grad_div_ui[1]) \
# * q * 2*pi*r*ds
if p_bcs:
solve(
a2 == L2, p1,
bcs=p_bcs,
solver_parameters={
'linear_solver': 'iterative',
'symmetric': True,
'preconditioner': 'amg',
'krylov_solver': {'relative_tolerance': tol,
'absolute_tolerance': 0.0,
'maximum_iterations': 100,
'monitor_convergence': verbose}
}
)
else:
# If we're dealing with a pure Neumann problem here (which is the
# default case), this doesn't hurt CG if the system is consistent,
# cf. :cite:`vdV03`. And indeed it is consistent if and only if
#
# \int_\Gamma r n.u = 0.
#
# This makes clear that for incompressible Navier-Stokes, one
# either needs to make sure that inflow and outflow always add up
# to 0, or one has to specify pressure boundary conditions.
#
# If the right-hand side is very small, round-off errors may impair
# the consistency of the system. Make sure the system we are
# solving remains consistent.
A = assemble(a2)
b = assemble(L2)
# Assert that the system is indeed consistent.
e = Function(Q)
e.interpolate(Constant(1.0))
evec = e.vector()
evec /= norm(evec)
alpha = b.inner(evec)
normB = norm(b)
# Assume that in every component of the vector, a round-off error
# of the magnitude DOLFIN_EPS is present. This leads to the
# criterion
# |<b,e>| / (||b||*||e||) < DOLFIN_EPS
# as a check whether to consider the system consistent up to
# round-off error.
#
# TODO think about condition here
#if abs(alpha) > normB * DOLFIN_EPS:
if abs(alpha) > normB * 1.0e-12:
divu = 1 / r * (r * u[0]).dx(0) + u[1].dx(1)
adivu = assemble(((r * u[0]).dx(0) + u[1].dx(1)) * 2 * pi * dx)
info('\int 1/r * div(r*u) * 2*pi*r = %e' % adivu)
n = FacetNormal(Q.mesh())
boundary_integral = assemble((n[0] * u[0] + n[1] * u[1])
* 2 * pi * r * ds)
info('\int_Gamma n.u * 2*pi*r = %e' % boundary_integral)
message = ('System not consistent! '
'<b,e> = %g, ||b|| = %g, <b,e>/||b|| = %e.') \
% (alpha, normB, alpha / normB)
info(message)
# Plot the stuff, and project it to a finer mesh with linear
# elements for the purpose.
plot(divu, title='div(u_tentative)')
#Vp = FunctionSpace(Q.mesh(), 'CG', 2)
#Wp = MixedFunctionSpace([Vp, Vp])
#up = project(u, Wp)
fine_mesh = Q.mesh()
for k in range(1):
fine_mesh = refine(fine_mesh)
V = FunctionSpace(fine_mesh, 'CG', 1)
W = V * V
#uplot = Function(W)
#uplot.interpolate(u)
uplot = project(u, W)
plot(uplot[0], title='u_tentative[0]')
plot(uplot[1], title='u_tentative[1]')
#plot(u, title='u_tentative')
interactive()
exit()
raise RuntimeError(message)
# Project out the roundoff error.
b -= alpha * evec
#
# In principle, the ILU preconditioner isn't advised here since it
# might destroy the semidefiniteness needed for CG.
#
# The system is consistent, but the matrix has an eigenvalue 0.
# This does not harm the convergence of CG, but when
# preconditioning one has to make sure that the preconditioner
# preserves the kernel. ILU might destroy this (and the
# semidefiniteness). With AMG, the coarse grid solves cannot be LU
# then, so try Jacobi here.
# <http://lists.mcs.anl.gov/pipermail/petsc-users/2012-February/012139.html>
#
prec = PETScPreconditioner('hypre_amg')
from dolfin import PETScOptions
PETScOptions.set('pc_hypre_boomeramg_relax_type_coarse', 'jacobi')
solver = PETScKrylovSolver('cg', prec)
solver.parameters['absolute_tolerance'] = 0.0
solver.parameters['relative_tolerance'] = tol
solver.parameters['maximum_iterations'] = 100
solver.parameters['monitor_convergence'] = verbose
# Create solver and solve system
A_petsc = as_backend_type(A)
b_petsc = as_backend_type(b)
p1_petsc = as_backend_type(p1.vector())
solver.set_operator(A_petsc)
solver.solve(p1_petsc, b_petsc)
# This would be the stump for Epetra:
#solve(A, p.vector(), b, 'cg', 'ml_amg')
return
def _pressure_poisson(self,
p1, p0,
mu, ui,
divu,
p_bcs=None,
p_n=None,
rotational_form=False,
tol=1.0e-10,
verbose=True
):
'''Solve the pressure Poisson equation
- \Delta phi = -div(u),
boundary conditions,
for
\nabla p = u.
'''
P = p1.function_space()
p = TrialFunction(P)
q = TestFunction(P)
a2 = dot(grad(p), grad(q)) * dx
L2 = -divu * q * dx
if p0:
L2 += dot(grad(p0), grad(q)) * dx
if p_n:
n = FacetNormal(P.mesh())
L2 += dot(n, p_n) * q * ds
if rotational_form:
L2 -= mu * dot(grad(div(ui)), grad(q)) * dx
if p_bcs:
solve(a2 == L2, p1,
bcs=p_bcs,
solver_parameters={
'linear_solver': 'iterative',
'symmetric': True,
'preconditioner': 'hypre_amg',
'krylov_solver': {'relative_tolerance': tol,
'absolute_tolerance': 0.0,
'maximum_iterations': 100,
'monitor_convergence': verbose}
})
else:
# If we're dealing with a pure Neumann problem here (which is the
# default case), this doesn't hurt CG if the system is consistent,
# cf.
#
# Iterative Krylov methods for large linear systems,
# Henk A. van der Vorst.
#
# And indeed, it is consistent: Note that
#
# <1, rhs> = \sum_i 1 * \int div(u) v_i
# = 1 * \int div(u) \sum_i v_i
# = \int div(u).
#
# With the divergence theorem, we have
#
# \int div(u) = \int_\Gamma n.u.
#
# The latter term is 0 iff inflow and outflow are exactly the same
# at any given point in time. This corresponds with the
# incompressibility of the liquid.
#
# In turn, this hints towards penetrable boundaries to require
# Dirichlet conditions on the pressure.
#
A = assemble(a2)
b = assemble(L2)
#
# In principle, the ILU preconditioner isn't advised here since it
# might destroy the semidefiniteness needed for CG.
#
# The system is consistent, but the matrix has an eigenvalue 0.
# This does not harm the convergence of CG, but when
# preconditioning one has to take care that the preconditioner
# preserves the kernel. ILU might destroy this (and the
# semidefiniteness). With AMG, the coarse grid solves cannot be LU
# then, so try Jacobi here.
# <http://lists.mcs.anl.gov/pipermail/petsc-users/2012-February/012139.html>
#
prec = PETScPreconditioner('hypre_amg')
PETScOptions.set('pc_hypre_boomeramg_relax_type_coarse', 'jacobi')
solver = PETScKrylovSolver('cg', prec)
solver.parameters['absolute_tolerance'] = 0.0
solver.parameters['relative_tolerance'] = tol
solver.parameters['maximum_iterations'] = 100
solver.parameters['monitor_convergence'] = verbose
# Create solver and solve system
A_petsc = as_backend_type(A)
b_petsc = as_backend_type(b)
p1_petsc = as_backend_type(p1.vector())
solver.set_operator(A_petsc)
try:
solver.solve(p1_petsc, b_petsc)
except RuntimeError as error:
info('')
# Check if the system is indeed consistent.
#
# If the right hand side is flawed (e.g., by round-off errors),
# then it may have a component b1 in the direction of the null
# space, orthogonal the image of the operator:
#
# b = b0 + b1.
#
# When starting with initial guess x0=0, the minimal achievable
# relative tolerance is then
#
# min_rel_tol = ||b1|| / ||b||.
#
# If ||b|| is very small, which is the case when ui is almost
# divergence-free, then min_rel_to may be larger than the
# prescribed relative tolerance tol.
#
# Use this as a consistency check, i.e., bail out if
#
# tol < min_rel_tol = ||b1|| / ||b||.
#
# For computing ||b1||, we use the fact that the null space is
# one-dimensional, i.e., b1 = alpha e, and
#
# e.b = e.(b0 + b1) = e.b1 = alpha ||e||^2,
#
# so alpha = e.b/||e||^2 and
#
# ||b1|| = |alpha| ||e|| = e.b / ||e||
#
e = Function(P)
e.interpolate(Constant(1.0))
evec = e.vector()
evec /= norm(evec)
alpha = b.inner(evec)
normB = norm(b)
info('Linear system convergence failure.')
info(error.message)
message = ('Linear system not consistent! '
'<b,e> = %g, ||b|| = %g, <b,e>/||b|| = %e, tol = %e.') \
% (alpha, normB, alpha/normB, tol)
info(message)
if tol < abs(alpha) / normB:
info('\int div(u) = %e' % assemble(divu * dx))
#n = FacetNormal(Q.mesh())
#info('\int_Gamma n.u = %e' % assemble(dot(n, u)*ds))
#info('\int_Gamma u[0] = %e' % assemble(u[0]*ds))
#info('\int_Gamma u[1] = %e' % assemble(u[1]*ds))
## Now plot the faulty u on a finer mesh (to resolve the
## quadratic trial functions).
#fine_mesh = Q.mesh()
#for k in range(1):
# fine_mesh = refine(fine_mesh)
#V1 = FunctionSpace(fine_mesh, 'CG', 1)
#W1 = V1*V1
#uplot = project(u, W1)
##uplot = Function(W1)
##uplot.interpolate(u)
#plot(uplot, title='u_tentative')
#plot(uplot[0], title='u_tentative[0]')
#plot(uplot[1], title='u_tentative[1]')
plot(divu, title='div(u_tentative)')
interactive()
exit()
raise RuntimeError(message)
else:
exit()
raise RuntimeError('Linear system failed to converge.')
except:
exit()
return
import pytest
from numpy import isclose
from dolfin import assemble, derivative, dx, Expression, Function, FunctionSpace, grad, inner, PETScOptions, project, solve, TestFunction, TrialFunction, UnitSquareMesh
from rbnics.backends import NonlinearSolver as FactoryNonlinearSolver
from rbnics.backends.abstract import NonlinearProblemWrapper
from rbnics.backends.dolfin import NonlinearSolver as DolfinNonlinearSolver
from test_utils import RandomDolfinFunction
NonlinearSolver = None
AllNonlinearSolver = {
"dolfin": DolfinNonlinearSolver,
"factory": FactoryNonlinearSolver
}
PETScOptions.set("snes_linesearch_type", "basic")
class Data(object):
def __init__(self, Th, callback_type):
# Create mesh and define function space
mesh = UnitSquareMesh(Th, Th)
self.V = FunctionSpace(mesh, "Lagrange", 1)
# Define variational problem
du = TrialFunction(self.V)
v = TestFunction(self.V)
self.u = Function(self.V)
self.r = lambda u, g: inner(grad(u), grad(v)) * dx + inner(
u + u**3, v) * dx - g * v * dx
self.j = lambda u, r: derivative(r, u, du)
# Define initial guess
def _compute_pressure(p0,
alpha,
rho,
dt,
mu,
div_ui,
p_bcs=None,
p_function_space=None,
rotational_form=False,
tol=1.0e-10,
verbose=True):
'''Solve the pressure Poisson equation
- \\Delta phi = -div(u),
boundary conditions,
for p with
\\nabla p = u.
'''
#
# The following is based on the update formula
#
# rho/dt (u_{n+1}-u*) + \nabla phi = 0
#
# with
#
# phi = (p_{n+1} - p*) + chi*mu*div(u*)
#
# and div(u_{n+1})=0. One derives
#
# - \nabla^2 phi = rho/dt div(u_{n+1} - u*),
# - n.\nabla phi = rho/dt n.(u_{n+1} - u*),
#
# In its weak form, this is
#
# \int \grad(phi).\grad(q)
# = - rho/dt \int div(u*) q - rho/dt \int_Gamma n.(u_{n+1}-u*) q.
#
# If Dirichlet boundary conditions are applied to both u* and u_{n+1} (the
# latter in the final step), the boundary integral vanishes.
#
# Assume that on the boundary
# L2 -= inner(n, rho/k (u_bcs - ui)) * q * ds
# is zero. This requires the boundary conditions to be set for ui as well
# as u_final.
# This creates some problems if the boundary conditions are supposed to
# remain 'free' for the velocity, i.e., no Dirichlet conditions in normal
# direction. In that case, one needs to specify Dirichlet pressure
# conditions.
#
if p0:
P = p0.function_space()
else:
P = p_function_space
p1 = Function(P)
p = TrialFunction(P)
q = TestFunction(P)
a2 = dot(grad(p), grad(q)) * dx
L2 = -alpha * rho / dt * div_ui * q * dx
L2 += dot(grad(p0), grad(q)) * dx
if rotational_form:
L2 -= mu * dot(grad(div_ui), grad(q)) * dx
if p_bcs:
solve(a2 == L2,
p1,
bcs=p_bcs,
solver_parameters={
'linear_solver': 'iterative',
'symmetric': True,
'preconditioner': 'hypre_amg',
'krylov_solver': {
'relative_tolerance': tol,
'absolute_tolerance': 0.0,
'maximum_iterations': 100,
'monitor_convergence': verbose,
'error_on_nonconvergence': True
}
})
else:
# If we're dealing with a pure Neumann problem here (which is the
# default case), this doesn't hurt CG if the system is consistent, cf.
#
# Iterative Krylov methods for large linear systems,
# Henk A. van der Vorst.
#
# And indeed, it is consistent: Note that
#
# <1, rhs> = \sum_i 1 * \int div(u) v_i
# = 1 * \int div(u) \sum_i v_i
# = \int div(u).
#
# With the divergence theorem, we have
#
# \int div(u) = \int_\Gamma n.u.
#
# The latter term is 0 if and only if inflow and outflow are exactly
# the same at any given point in time. This corresponds with the
# incompressibility of the liquid.
#
# Another lesson from this:
# If the mesh has penetration boundaries, you either have to specify
# the normal component of the velocity such that \int(n.u) = 0, or
# specify Dirichlet conditions for the pressure somewhere.
#
A = assemble(a2)
b = assemble(L2)
# If the right hand side is flawed (e.g., by round-off errors), then it
# may have a component b1 in the direction of the null space,
# orthogonal to the image of the operator:
#
# b = b0 + b1.
#
# When starting with initial guess x0=0, the minimal achievable
# relative tolerance is then
#
# min_rel_tol = ||b1|| / ||b||.
#
# If ||b|| is very small, which is the case when ui is almost
# divergence-free, then min_rel_to may be larger than the prescribed
# relative tolerance tol. This happens, for example, when the time
# steps is very small.
# Sanitation of right-hand side is easy with
#
# e = Function(P)
# e.interpolate(Constant(1.0))
# evec = e.vector()
# evec /= norm(evec)
# print(b.inner(evec))
# b -= b.inner(evec) * evec
#
# However it's hard to decide when the right-hand side is inconsistent
# because of round-off errors in previous steps, or because the system
# is actually inconsistent (insufficient boundary conditions or
# something like that). Hence, don't do anything and rather try to
# fight the cause for round-off.
# In principle, the ILU preconditioner isn't advised here since it
# might destroy the semidefiniteness needed for CG.
#
# The system is consistent, but the matrix has an eigenvalue 0. This
# does not harm the convergence of CG, but with preconditioning one has
# to make sure that the preconditioner preserves the kernel. ILU might
# destroy this (and the semidefiniteness). With AMG, the coarse grid
# solves cannot be LU then, so try Jacobi here.
# <http://lists.mcs.anl.gov/pipermail/petsc-users/2012-February/012139.html>
#
# TODO clear everything; possible in FEniCS 2017.1
# <https://fenicsproject.org/qa/12916/clear-petscoptions>
# PETScOptions.clear()
prec = PETScPreconditioner('hypre_amg')
PETScOptions.set('pc_hypre_boomeramg_relax_type_coarse', 'jacobi')
solver = PETScKrylovSolver('cg', prec)
solver.parameters['absolute_tolerance'] = 0.0
solver.parameters['relative_tolerance'] = tol
solver.parameters['maximum_iterations'] = 1000
solver.parameters['monitor_convergence'] = verbose
solver.parameters['error_on_nonconvergence'] = True
# Create solver and solve system
A_petsc = as_backend_type(A)
b_petsc = as_backend_type(b)
p1_petsc = as_backend_type(p1.vector())
solver.set_operator(A_petsc)
solver.solve(p1_petsc, b_petsc)
return p1
