Method __init__

python/dolfinx/fem/function.py:125–232

Create an Expression. Args: e: UFL expression. X: Array of points of shape ``(num_points, tdim)`` on the reference element. comm: Communicator that the Expression is defined on. form_compiler_options: Options used in FFCx compi

(
        self,
        e: ufl.core.expr.Expr,
        X: np.ndarray,
        comm: _MPI.Comm | None = None,
        form_compiler_options: dict | None = None,
        jit_options: dict | None = None,
        dtype: npt.DTypeLike | None = None,
        entity_maps: list[_EntityMap] | None = None,
    )

    _code: str

    def __init__(
        self,
        e: ufl.core.expr.Expr,
        X: np.ndarray,
        comm: _MPI.Comm | None = None,
        form_compiler_options: dict | None = None,
        jit_options: dict | None = None,
        dtype: npt.DTypeLike | None = None,
        entity_maps: list[_EntityMap] | None = None,
    ):
        """Create an Expression.

        Args:
            e: UFL expression.
            X: Array of points of shape ``(num_points, tdim)`` on the
                reference element.
            comm: Communicator that the Expression is defined on.
            form_compiler_options: Options used in FFCx compilation of
                this Expression. Run ``ffcx --help`` in the commandline
                to see all available options.
            jit_options: Options controlling JIT compilation of C code.
            dtype: Type of the Expression values. If ``None``,
                the dtype is deduced from the UFL expression.
            entity_maps: Maps between different meshes.

        Note:
            This wrapper is responsible for the FFCx compilation of the
            UFL Expr and attaching the correct data to the underlying
            C++ Expression.
        """
        assert X.ndim < 3
        num_points = X.shape[0] if X.ndim == 2 else 1
        _X = np.reshape(X, (num_points, -1))

        # Get MPI communicator
        if comm is None:
            try:
                domains = ufl.domain.extract_domains(e)
                if len(domains) == 0:
                    raise RuntimeError("Could not extract MPI communicator for Expression.")
                domain = domains[0]
                assert isinstance(domain, ufl.Mesh)
                mesh = domain.ufl_cargo()
                comm = mesh.comm
            except AttributeError:
                print(
                    "Could not extract MPI communicator for Expression. "
                    + "Maybe you need to pass a communicator?"
                )
                raise

        # Attempt to deduce dtype
        if dtype is None:
            dtype = getattr(e, "dtype", default_scalar_type)

        # Compile UFL expression with JIT
        if form_compiler_options is None:
            form_compiler_options = dict()