def VectorFunctionSpace(mesh: cpp.mesh.Mesh, element: ElementMetaData, dim=None, restriction=None) -> "FunctionSpace": """Create vector finite element (composition of scalar elements) function space.""" e = ElementMetaData(*element) ufl_element = ufl.VectorElement(e.family, mesh.ufl_cell(), e.degree, form_degree=e.form_degree, dim=dim) return FunctionSpace(mesh, ufl_element)
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 TensorFunctionSpace(mesh: cpp.mesh.Mesh, element: ElementMetaData, shape=None, symmetry: bool = None, restriction=None) -> "FunctionSpace": """Create tensor finite element (composition of scalar elements) function space.""" e = ElementMetaData(*element) ufl_element = ufl.TensorElement(e.family, mesh.ufl_cell(), e.degree, shape, symmetry) return FunctionSpace(mesh, ufl_element)
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())
def from_cpp(cls, obj: _cpp.mesh.Mesh, domain: ufl.Mesh) -> Mesh: """Create Mesh object from a C++ Mesh object""" obj._ufl_domain = domain obj.__class__ = Mesh domain._ufl_cargo = obj return obj