示例#1
0
文件: function.py 项目: RuruX/dolfinx
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)
示例#2
0
文件: function.py 项目: RuruX/dolfinx
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)
示例#3
0
    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)