def __init__(self, F, u, bc):
super().__init__()
V = u.function_space
du = function.TrialFunction(V)
self.L = F
self.a = derivative(F, u, du)
self.bc = bc
self._F, self._J = None, None
def __init__(self, F, u, bc):
super().__init__()
V = u.function_space
du = function.TrialFunction(V)
self.L = F
self.a = derivative(F, u, du)
self.a_comp = dolfin.fem.Form(self.a)
self.bc = bc
self._F, self._J = None, None
self.u = u
def project(v, V=None, bcs=[], mesh=None, funct=None):
"""Return projection of given expression *v* onto the finite element
space *V*.
*Arguments*
v
a :py:class:`Function <dolfin.functions.function.Function>` or
an :py:class:`Expression <dolfin.functions.expression.Expression>`
bcs
Optional argument :py:class:`list of DirichletBC
<dolfin.fem.bcs.DirichletBC>`
V
Optional argument :py:class:`FunctionSpace
<dolfin.functions.functionspace.FunctionSpace>`
mesh
Optional argument :py:class:`mesh <dolfin.cpp.Mesh>`.
funct
Target function where result is stored.
*Example of usage*
.. code-block:: python
v = Expression("sin(pi*x[0])")
V = FunctionSpace(mesh, "Lagrange", 1)
Pv = project(v, V)
This is useful for post-processing functions or expressions
which are not readily handled by visualization tools (such as
for example discontinuous functions).
"""
# Try figuring out a function space if not specified
if V is None:
# Create function space based on Expression element if trying
# to project an Expression
if isinstance(v, function.Expression):
if mesh is not None and isinstance(mesh, cpp.mesh.Mesh):
V = function.FunctionSpace(mesh, v.ufl_element())
# else:
# cpp.dolfin_error("projection.py",
# "perform projection",
# "Expected a mesh when projecting an Expression")
else:
# Otherwise try extracting function space from expression
V = _extract_function_space(v, mesh)
# Check arguments
# Ensure we have a mesh and attach to measure
if mesh is None:
mesh = V.mesh
dx = ufl.dx(mesh)
# Define variational problem for projection
w = function.TestFunction(V)
Pv = function.TrialFunction(V)
a = ufl.inner(Pv, w) * dx
L = ufl.inner(v, w) * dx
# Assemble linear system
A = fem.assemble_matrix(a, bcs)
A.assemble()
b = fem.assemble_vector(L)
fem.apply_lifting(b, [a], [bcs])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
fem.set_bc(b, bcs)
# Solve linear system for projection
if funct is None:
funct = function.Function(V)
la.solve(A, funct.vector, b)
return funct
def project(v,
V=None,
bcs=None,
mesh=None,
function=None,
solver_type="lu",
preconditioner_type="default",
form_compiler_parameters=None):
"""Return projection of given expression *v* onto the finite element
space *V*.
*Arguments*
v
a :py:class:`Function <dolfin.functions.function.Function>` or
an :py:class:`Expression <dolfin.functions.expression.Expression>`
bcs
Optional argument :py:class:`list of DirichletBC
<dolfin.fem.bcs.DirichletBC>`
V
Optional argument :py:class:`FunctionSpace
<dolfin.functions.functionspace.FunctionSpace>`
mesh
Optional argument :py:class:`mesh <dolfin.cpp.Mesh>`.
solver_type
see :py:func:`solve <dolfin.fem.solving.solve>` for options.
preconditioner_type
see :py:func:`solve <dolfin.fem.solving.solve>` for options.
form_compiler_parameters
see :py:class:`Parameters <dolfin.cpp.Parameters>` for more
information.
*Example of usage*
.. code-block:: python
v = Expression("sin(pi*x[0])")
V = FunctionSpace(mesh, "Lagrange", 1)
Pv = project(v, V)
This is useful for post-processing functions or expressions
which are not readily handled by visualization tools (such as
for example discontinuous functions).
"""
# Try figuring out a function space if not specified
if V is None:
# Create function space based on Expression element if trying
# to project an Expression
if isinstance(v, function.Expression):
if mesh is not None and isinstance(mesh, cpp.mesh.Mesh):
V = function.FunctionSpace(mesh, v.ufl_element())
# else:
# cpp.dolfin_error("projection.py",
# "perform projection",
# "Expected a mesh when projecting an Expression")
else:
# Otherwise try extracting function space from expression
V = _extract_function_space(v, mesh)
# Check arguments
# Ensure we have a mesh and attach to measure
if mesh is None:
mesh = V.mesh()
dx = ufl.dx(mesh)
# Define variational problem for projection
w = function.TestFunction(V)
Pv = function.TrialFunction(V)
a = ufl.inner(w, Pv) * dx
L = ufl.inner(w, v) * dx
# Assemble linear system
A, b = fem.assemble_system(
a, L, bcs=bcs, form_compiler_parameters=form_compiler_parameters)
# Solve linear system for projection
if function is None:
function = function.Function(V)
la.solve(A, function.vector(), b, solver_type, preconditioner_type)
return function
