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, dolfin.function.expression.Expression):
if mesh is not None and isinstance(mesh, cpp.mesh.Mesh):
V = 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)
# Projection into a MultiMeshFunctionSpace
if isinstance(V, MultiMeshFunctionSpace):
# Create the measuresum of uncut and cut-cells
dX = ufl.dx() + ufl.dC()
# Define variational problem for projection
w = TestFunction(V)
Pv = TrialFunction(V)
a = ufl.inner(w, Pv) * dX
L = ufl.inner(w, v) * dX
# Assemble linear system
A = assemble_multimesh(a, form_compiler_parameters=form_compiler_parameters)
b = assemble_multimesh(L, form_compiler_parameters=form_compiler_parameters)
# Solve linear system for projection
if function is None:
function = MultiMeshFunction(V)
cpp.la.solve(A, function.vector(), b, solver_type, preconditioner_type)
return function
# 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 = TestFunction(V)
Pv = TrialFunction(V)
a = ufl.inner(w, Pv) * dx
L = ufl.inner(w, v) * dx
# Assemble linear system
A, b = assemble_system(a, L, bcs=bcs,
form_compiler_parameters=form_compiler_parameters)
# Solve linear system for projection
if function is None:
function = Function(V)
cpp.la.solve(A, function.vector(), b, solver_type, preconditioner_type)
return function
def project(v, V=None, func_degree=None, bcs=None, mesh=None,
function=None,
solver_type="lu",
preconditioner_type="default",
form_compiler_parameters=None):
"""
This function is a modification of FEniCS's built-in project 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/projection.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.
"""
# 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, Expression):
# FIXME: Add handling of cpp.MultiMesh
if mesh is not None and isinstance(mesh, cpp.mesh.Mesh):
V = 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)
# 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
# DS: HERE IS WHERE I MODIFY
r2 = Expression('pow(x[0],2)', degree=func_degree)
w = TestFunction(V)
Pv = TrialFunction(V)
a = ufl.inner(w, Pv) * r2 * dx
L = ufl.inner(w, v) * r2 * dx
# Assemble linear system
A, b = assemble_system(a, L, bcs=bcs,
form_compiler_parameters=form_compiler_parameters)
# Solve linear system for projection
if function is None:
function = Function(V)
cpp.la.solve(A, function.vector(), b, solver_type, preconditioner_type)
return function
