def __init__(self,
mesh: cpp.mesh.Mesh,
element: typing.Union[ufl.FiniteElementBase, ElementMetaData],
cppV: typing.Optional[cpp.fem.FunctionSpace] = None,
form_compiler_parameters: dict = {},
jit_parameters: dict = {}):
"""Create a finite element function space."""
# Create function space from a UFL element and existing cpp
# FunctionSpace
if cppV is not None:
assert mesh is None
ufl_domain = cppV.mesh.ufl_domain()
super().__init__(ufl_domain, element)
self._cpp_object = cppV
return
# Initialise the ufl.FunctionSpace
if isinstance(element, ufl.FiniteElementBase):
super().__init__(mesh.ufl_domain(), element)
else:
e = ElementMetaData(*element)
ufl_element = ufl.FiniteElement(e.family,
mesh.ufl_cell(),
e.degree,
form_degree=e.form_degree)
super().__init__(mesh.ufl_domain(), ufl_element)
# Compile dofmap and element and create DOLFINx objects
ufc_element, ufc_dofmap = jit.ffcx_jit(
mesh.mpi_comm(),
self.ufl_element(),
form_compiler_parameters=form_compiler_parameters,
jit_parameters=jit_parameters)
ffi = cffi.FFI()
cpp_element = cpp.fem.FiniteElement(
ffi.cast("uintptr_t", ffi.addressof(ufc_element)))
cpp_dofmap = cpp.fem.create_dofmap(
mesh.mpi_comm(), ffi.cast("uintptr_t", ffi.addressof(ufc_dofmap)),
mesh.topology)
# Initialize the cpp.FunctionSpace
self._cpp_object = cpp.fem.FunctionSpace(mesh, cpp_element, cpp_dofmap)
def Circumradius(mesh: cpp.mesh.Mesh) -> ufl.Circumradius:
"""Return symbolic cell circumradius for given mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
R = Circumradius(mesh)
"""
return ufl.Circumradius(mesh.ufl_domain())
def SpatialCoordinate(mesh: cpp.mesh.Mesh) -> ufl.SpatialCoordinate:
"""Return symbolic physical coordinates for given mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
x = SpatialCoordinate(mesh)
"""
return ufl.SpatialCoordinate(mesh.ufl_domain())
def CellNormal(mesh: cpp.mesh.Mesh) -> ufl.CellNormal:
"""Return symbolic cell normal for given manifold mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
n = CellNormal(mesh)
"""
return ufl.CellNormal(mesh.ufl_domain())
def CellVolume(mesh: cpp.mesh.Mesh) -> ufl.CellVolume:
"""Return symbolic cell volume for given mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
vol = CellVolume(mesh)
"""
return ufl.CellVolume(mesh.ufl_domain())
def FacetNormal(mesh: cpp.mesh.Mesh) -> ufl.FacetNormal:
"""Return symbolic facet normal for given mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
n = FacetNormal(mesh)
"""
return ufl.FacetNormal(mesh.ufl_domain())
def MaxFacetEdgeLength(mesh: cpp.mesh.Mesh) -> ufl.MaxFacetEdgeLength:
"""Return symbolic maximum facet edge length of a cell
for given mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
maxfe = MaxFacetEdgeLength(mesh)
"""
return ufl.MaxFacetEdgeLength(mesh.ufl_domain())
def MinCellEdgeLength(mesh: cpp.mesh.Mesh) -> ufl.MinCellEdgeLength:
"""Return symbolic minimum cell edge length of a cell
for given mesh.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
mince = MinCellEdgeLength(mesh)
"""
return ufl.MinCellEdgeLength(mesh.ufl_domain())
def CellDiameter(mesh: cpp.mesh.Mesh) -> ufl.CellDiameter:
r"""Return function cell diameter for given mesh.
Note that diameter of cell :math:`K` is defined as
:math:`\sup_{\mathbf{x, y} \in K} |\mathbf{x - y}|`.
*Example of usage*
.. code-block:: python
mesh = UnitSquare(4,4)
h = CellDiameter(mesh)
"""
return ufl.CellDiameter(mesh.ufl_domain())
