feectools 0.1.0__py3-none-any.whl

feectools/api/fem_common.py

@@ -0,0 +1,286 @@
+from typing import Iterable
+
+from sympy import Expr, ImmutableDenseMatrix, Matrix
+
+import numpy as np
+
+from sympde.expr.basic           import BasicForm
+from sympde.expr.evaluation      import KernelExpression
+from sympde.topology.space       import ScalarFunction, VectorFunction, IndexedVectorFunction
+from sympde.topology.space       import ProductSpace, VectorFunctionSpace
+from sympde.topology.datatype    import H1SpaceType, L2SpaceType, UndefinedSpaceType
+from sympde.topology.derivatives import get_atom_logical_derivatives
+from sympde.topology.derivatives import _logical_partial_derivatives
+
+from feectools.fem.basic         import FemSpace
+from feectools.linalg.stencil    import StencilMatrix, StencilInterfaceMatrix
+from feectools.linalg.basic      import ComposedLinearOperator
+from feectools.api.utilities     import flatten
+from feectools.api.ast.utilities import math_atoms_as_str, get_max_partial_derivatives
+
+# TODO [YG 01.08.2025]: Avoid importing anything from feectools.pyccel
+from feectools.pyccel.ast.core import _atomic
+
+__all__ = (
+    'compute_max_nderiv',
+    'compute_imports',
+    'compute_free_arguments',
+    'collect_spaces',
+    'compute_diag_len',
+    'construct_test_space_arguments',
+    'construct_trial_space_arguments',
+    'construct_quad_grids_arguments',
+    'do_nothing',
+    'extract_stencil_mats',
+    'reset_arrays',
+)
+
+#==============================================================================
+def compute_max_nderiv(kernel_expr: KernelExpression) -> int:
+    """
+    Compute the highest derivative order in the given kernel expression.
+
+    Parameters
+    ----------
+    kernel_expr : KernelExpression (from sympde.expr.evaluation)
+
+    Returns
+    -------
+    nderiv : int
+        The highest order of derivation in `terminal_expr`.
+
+    """
+    assert isinstance(kernel_expr, KernelExpression)
+
+    terminal_expr = kernel_expr.expr
+    if not isinstance(terminal_expr, (ImmutableDenseMatrix, Matrix)):
+        terminal_expr = ImmutableDenseMatrix([[terminal_expr]])
+    n_rows, n_cols = terminal_expr.shape
+
+    atoms_types = (ScalarFunction, VectorFunction, IndexedVectorFunction)
+    extended_atoms_types = atoms_types + _logical_partial_derivatives
+
+    nderiv = 0
+    for i_row in range(n_rows):
+        for i_col in range(n_cols):
+            texpr = terminal_expr[i_row, i_col]
+            atoms = _atomic(texpr, cls=extended_atoms_types)
+            Fs = [get_atom_logical_derivatives(a) for a in atoms]
+            d = get_max_partial_derivatives(texpr, logical=True, F=Fs)
+            nderiv = max(nderiv, max(d.values()))
+
+    return nderiv
+
+#==============================================================================
+def compute_imports(expr: Expr,
+                    spaces: Iterable[FemSpace],
+                    *,
+                    openmp: bool
+                    ) -> dict[str, list[str]]:
+    """
+    Compute all the imports to be added to the generated Python code.
+
+    Parameters
+    ----------
+    expr : sympy.Expr
+        The integrand expression of a BilinearForm, LinearForm, or
+        Functional. This is a pure SymPy expression where SymPDE partial
+        derivatives have been converted to SymPy symbols. See Notes.
+
+    spaces : iterable of feectools.fem.FemSpace
+        The discrete spaces which define the finite element representation
+        of a BilinearForm, LinearForm, or Functional.
+
+    openmp : bool
+        Whether or not OpenMP pragmas and functions are used in the code.
+
+    Returns
+    -------
+    imports : dict[str, list[str]]
+        A dictionary whose keys are the names of the Python modules to be
+        imported, and whose values are the names of the corresponding
+        objects (variables, functions, classes) to be imported from the
+        modules.
+
+    Notes
+    -----
+    Assume that we start from an object of type BilinearForm, LinearForm,
+    or Functional. We take the integrand and expand its vector operations
+    with TerminalExpr(), then pull back from physical to logical
+    coordinates with LogicalExpr(), and finally convert the symbolic
+    partial derivatives with SymbolicExpr(). Where:
+        - TerminalExpr is defined in sympde.expr.evaluation
+        -  LogicalExpr is defined in sympde.topology.mapping
+        - SymbolicExpr is defined in sympde.topology.mapping
+
+    The resulting expression `expr` can be passed to this function.
+    """
+    assert isinstance(expr, Expr)
+    assert all(isinstance(V, FemSpace) for V in spaces)
+    assert isinstance(openmp, bool)
+
+    # Determine the type of scalar quantities to be managed in the code
+    dtypes = [getattr(V.symbolic_space, 'codomain_type', 'real') for V in spaces]
+    assert all(t in ['complex', 'real'] for t in dtypes)
+    dtype = 'complex' if 'complex' in dtypes else 'real'
+
+    # TODO uncomment this line when we have a SesquilinearForm defined in SymPDE
+    #assert isinstance(expr, SesquilinearForm)
+
+    #... Compute the imports
+    math_library  = 'cmath' if dtype=='complex' else 'math' # Function names are the same
+    math_imports  = math_atoms_as_str(expr, 'math')
+    numpy_imports = ['array', 'zeros', 'zeros_like', 'floor']
+
+    imports = {'numpy': numpy_imports}
+    if math_imports:
+        imports[math_library] = math_imports
+    if openmp:
+        imports['pyccel.stdlib.internal.openmp'] = ['omp_get_thread_num']
+    #...
+
+    return imports
+
+#==============================================================================
+def compute_free_arguments(expr: BasicForm, kernel_expr: KernelExpression) -> tuple[str]:
+    """
+    The string representation (i.e. the names) of the free arguments in
+    the given BilinearForm, LinearForm, or Functional.
+
+    Parameters
+    ----------
+    expr : BilinearForm | LinearForm | Functional
+        The expression of which we want to compute the free arguments.
+
+    kernel_expr : sympde.expr.evaluation.KernelExpression
+        The atomic representation of the form, which is obtained after using
+        LogicalExpr (if there is a mapping) and TerminalExpr on `expr`.
+
+    Returns
+    -------
+    tuple[str]
+        The string representation (i.e. the names) of the free arguments in
+        the given BilinearForm, LinearForm, or Functional.
+
+    """
+    assert isinstance(expr, BasicForm)
+    assert isinstance(kernel_expr, KernelExpression)
+
+    free_args_dict = expr.get_free_variables()
+    free_args_str  = tuple(str(a) for a in free_args_dict)
+
+    return free_args_str
+
+#==============================================================================
+def collect_spaces(space, *args):
+    """
+    This function collect the arguments used in the assembly function
+
+    Parameters
+    ----------
+    space: <FunctionSpace>
+        the symbolic space
+
+    args : <list>
+        list of discrete space components like basis values, spans, ...
+
+    Returns
+    -------
+    args : <list>
+        list of discrete space components elements used in the asembly
+
+    """
+
+    if isinstance(space, ProductSpace):
+        spaces = space.spaces
+        indices = []
+        i = 0
+        for space in spaces:
+            if isinstance(space, VectorFunctionSpace):
+                if isinstance(space.kind, (H1SpaceType, L2SpaceType, UndefinedSpaceType)):
+                    indices.append(i)
+                else:
+                    indices += [i+j for j in range(space.ldim)]
+                i = i + space.ldim
+            else:
+                indices.append(i)
+                i = i + 1
+        args = [[e[i] for i in indices] for e in args]
+
+    elif isinstance(space, VectorFunctionSpace):
+        if isinstance(space.kind, (H1SpaceType, L2SpaceType, UndefinedSpaceType)):
+            args = [[e[0]] for e in args]
+
+    return args
+
+#==============================================================================
+def compute_diag_len(p, md, mc):
+    n = ((np.ceil((p+1)/mc)-1)*md).astype('int')
+    n = n-np.minimum(0, n-p)+p+1
+    return n.astype('int')
+
+#==============================================================================
+def construct_test_space_arguments(basis_values):
+    space          = basis_values.space
+    test_basis     = basis_values.basis
+    spans          = basis_values.spans
+    test_degrees   = space.degree
+    pads           = space.pads
+    multiplicity   = space.multiplicity
+
+    test_basis, test_degrees, spans = collect_spaces(space.symbolic_space, test_basis, test_degrees, spans)
+
+    test_basis    = flatten(test_basis)
+    test_degrees  = flatten(test_degrees)
+    spans         = flatten(spans)
+    pads          = flatten(pads)
+    multiplicity  = flatten(multiplicity)
+    pads          = [p*m for p,m in zip(pads, multiplicity)]
+    return test_basis, test_degrees, spans, pads, multiplicity
+
+def construct_trial_space_arguments(basis_values):
+    space          = basis_values.space
+    trial_basis    = basis_values.basis
+    trial_degrees  = space.degree
+    pads           = space.pads
+    multiplicity   = space.multiplicity
+    trial_basis, trial_degrees = collect_spaces(space.symbolic_space, trial_basis, trial_degrees)
+
+    trial_basis    = flatten(trial_basis)
+    trial_degrees  = flatten(trial_degrees)
+    pads           = flatten(pads)
+    multiplicity   = flatten(multiplicity)
+    pads           = [p*m for p,m in zip(pads, multiplicity)]
+    return trial_basis, trial_degrees, pads, multiplicity
+
+#==============================================================================
+def construct_quad_grids_arguments(grid, use_weights=True):
+    points         = grid.points
+    if use_weights:
+        weights        = grid.weights
+        quads          = flatten(list(zip(points, weights)))
+    else:
+        quads = flatten(list(zip(points)))
+
+    nquads        = flatten(grid.nquads)
+    n_elements    = grid.n_elements
+    return n_elements, quads, nquads
+
+#==============================================================================
+def do_nothing(*args):
+    return 0
+
+#==============================================================================
+def extract_stencil_mats(mats):
+    new_mats = []
+    for M in mats:
+        if isinstance(M, (StencilInterfaceMatrix, StencilMatrix)):
+            new_mats.append(M)
+        elif isinstance(M, ComposedLinearOperator):
+            new_mats += [i for i in M.multiplicants if isinstance(i, (StencilInterfaceMatrix, StencilMatrix))]
+    return new_mats
+
+#==============================================================================
+def reset_arrays(*args):
+    for a in args:
+        a[:]= 0.j if a.dtype==complex else 0.

feectools/api/fem_sum_form.py

@@ -0,0 +1,123 @@
+import numpy as np
+
+from sympde.expr.expr import (
+    BilinearForm as sym_BilinearForm,
+    LinearForm as sym_LinearForm,
+    Functional as sym_Functional
+)
+
+from .basic             import BasicDiscrete
+from .fem               import DiscreteFunctional
+from .fem               import DiscreteLinearForm
+from .fem               import DiscreteBilinearForm
+from .fem_bilinear_form import DiscreteBilinearForm as DiscreteBilinearForm_SF
+from .fem_common        import reset_arrays
+from .utilities         import random_string
+
+__all__ = ('DiscreteSumForm',)
+
+#==============================================================================
+class DiscreteSumForm(BasicDiscrete):
+
+    def __init__(self, a, kernel_expr, *args, **kwargs):
+
+        # Sum factorization is only implemented for bilinear forms in 3D, in
+        # which case we use it by default. A 2D implementation should be the
+        # next step, hence we allow the user to pass `sum_factorization=True`
+        # even if not supported yet. In the case of linear forms or functionals
+        # this option is irrelevant for now, so we ignore it.
+        #
+        # In every case we remove the `sum_factorization` key from the dict
+        # in order to avoid errors, because none of the class constructors
+        # accept this argument.
+        sum_factorization = kwargs.pop('sum_factorization', a.ldim == 3)
+
+        # TODO Uncomment when the SesquilinearForm exist in SymPDE
+        #if not isinstance(a, (sym_BilinearForm, sym_SesquilinearForm, sym_LinearForm, sym_Functional)):
+            # raise TypeError('> Expecting a symbolic BilinearForm, SesquilinearForm, LinearForm, Functional')
+        if not isinstance(a, (sym_BilinearForm, sym_LinearForm, sym_Functional)):
+            raise TypeError('> Expecting a symbolic BilinearForm, LinearForm, Functional')
+
+        self._expr = a
+        backend = kwargs.pop('backend', None)
+        self._backend = backend
+
+        folder = kwargs.get('folder', None)
+        self._folder = self._initialize_folder(folder)
+
+        # create a module name if not given
+        tag = random_string(8)
+
+        # ...
+        forms = []
+        free_args = []
+        self._kernel_expr = kernel_expr
+        operator = None
+        for e in kernel_expr:
+            if isinstance(a, sym_LinearForm):
+                kwargs['update_ghost_regions'] = False
+                ah = DiscreteLinearForm(a, e, *args, backend=backend, **kwargs)
+                kwargs['vector'] = ah._vector
+                operator = ah._vector
+
+            # TODO Uncomment when the SesquilinearForm exist in SymPDE
+            # elif isinstance(a, sym_SesquilinearForm):
+            #     kwargs['update_ghost_regions'] = False
+            #     ah = DiscreteSesquilinearForm(a, e, *args, assembly_backend=backend, **kwargs)
+            #     kwargs['matrix'] = ah._matrix
+            #     operator = ah._matrix
+
+            elif isinstance(a, sym_BilinearForm):
+                kwargs['update_ghost_regions'] = False
+                if sum_factorization:
+                    ah = DiscreteBilinearForm_SF(a, e, *args, assembly_backend=backend, **kwargs)
+                else:
+                    ah = DiscreteBilinearForm(a, e, *args, assembly_backend=backend, **kwargs)
+                kwargs['matrix'] = ah._matrix
+                operator = ah._matrix
+
+            elif isinstance(a, sym_Functional):
+                ah = DiscreteFunctional(a, e, *args, backend=backend, **kwargs)
+
+            forms.append(ah)
+            free_args.extend(ah.free_args)
+
+        if isinstance(a, sym_BilinearForm):
+            is_broken   = len(args[0].domain)>1
+            if self._backend is not None and is_broken:
+                for mat in kwargs['matrix']._blocks.values():
+                    mat.set_backend(backend)
+            elif self._backend is not None:
+                kwargs['matrix'].set_backend(backend)
+
+        self._forms         = forms
+        self._operator      = operator
+        self._free_args     = tuple(set(free_args))
+        self._is_functional = isinstance(a, sym_Functional)
+        # ...
+
+    @property
+    def forms(self):
+        return self._forms
+
+    @property
+    def free_args(self):
+        return self._free_args
+
+    @property
+    def is_functional(self):
+        return self._is_functional
+
+    def assemble(self, *, reset=True, **kwargs):
+        if not self.is_functional:
+            if reset :
+                reset_arrays(*[i for M in self.forms for i in M.global_matrices])
+
+            for form in self.forms:
+                form.assemble(reset=False, **kwargs)
+            self._operator.exchange_assembly_data()
+            return self._operator
+        else:
+            M = [form.assemble(**kwargs) for form in self.forms]
+            M = np.sum(M)
+            return M

feectools/api/settings.py

@@ -0,0 +1,82 @@
+# coding: utf-8
+import subprocess # nosec B404
+import platform
+import re
+from packaging.version import Version
+
+
+__all__ = ('PSYDAC_DEFAULT_FOLDER', 'PSYDAC_BACKENDS')
+
+#==============================================================================
+
+PSYDAC_DEFAULT_FOLDER = {'name':'__psydac__'}
+
+# ... defining PSYDAC backends
+PSYDAC_BACKEND_PYTHON = {'name': 'python', 'tag':'python', 'openmp':False}
+
+PSYDAC_BACKEND_GPYCCEL  = {'name': 'pyccel',
+                       'compiler_family': 'GNU',
+                       'flags'   : '-O3 -ffast-math',
+                       'folder'  : '__gpyccel__',
+                       'tag'     : 'gpyccel',
+                       'openmp'  : False}
+
+PSYDAC_BACKEND_IPYCCEL  = {'name': 'pyccel',
+                       'compiler_family': 'intel',
+                       'flags'   : '-O3',
+                       'folder'  : '__ipyccel__',
+                       'tag'     :'ipyccel',
+                       'openmp'  : False}
+
+PSYDAC_BACKEND_PGPYCCEL = {'name': 'pyccel',
+                       'compiler_family': 'PGI',
+                       'flags'   : '-O3 -Munroll',
+                       'folder'  : '__pgpyccel__',
+                       'tag'     : 'pgpyccel',
+                       'openmp'  : False}
+
+PSYDAC_BACKEND_NVPYCCEL = {'name': 'pyccel',
+                       'compiler_family': 'nvidia',
+                       'flags'   : '-O3 -Munroll',
+                       'folder'  : '__nvpyccel__',
+                       'tag'     : 'nvpyccel',
+                       'openmp'  : False}
+# ...
+
+# Get gfortran version
+gfortran_version_output = subprocess.check_output(['gfortran', '--version']).decode('utf-8') # nosec B603, B607
+gfortran_version_string = re.search(r"(\d+\.\d+\.\d+)", gfortran_version_output).group()
+gfortran_version = Version(gfortran_version_string)
+
+# Platform-dependent flags
+if platform.system() == "Darwin" and platform.machine() == 'arm64' and gfortran_version >= Version("14"):
+
+    # Apple silicon requires architecture-specific flags (see https://github.com/pyccel/psydac/pull/411)
+    # which are only available on GCC version >= 14
+    cpu_brand = subprocess.check_output(['sysctl','-n','machdep.cpu.brand_string']).decode('utf-8').strip() # nosec B603, B607
+    if cpu_brand.startswith("Apple M"):
+        # Example: "Apple M3 Pro (virtual)" --> " -mcpu=apple-m3"
+        cpu_flag = '-'.join(cpu_brand.lower().split()[:2])
+        PSYDAC_BACKEND_GPYCCEL['flags'] += f' -mcpu={cpu_flag}'
+    else:
+        # TODO: Support later Apple CPU models. Perhaps the CPU naming scheme could be easily guessed
+        # based on the output of 'sysctl -n machdep.cpu.brand_string', but I wouldn't rely on this
+        # guess unless it has been manually verified. Loud errors are better than silent failures!
+        raise SystemError(f"Unsupported Apple CPU '{cpu_brand}'.")
+
+else:
+    # Default architecture flags
+    PSYDAC_BACKEND_GPYCCEL['flags'] += ' -march=native -mtune=native'
+    if platform.machine() == 'x86_64':
+        PSYDAC_BACKEND_GPYCCEL['flags'] += ' -mavx'
+
+#==============================================================================
+
+# List of all available backends for accelerating Python code
+PSYDAC_BACKENDS = {
+    'python'       : PSYDAC_BACKEND_PYTHON,
+    'pyccel-gcc'   : PSYDAC_BACKEND_GPYCCEL,
+    'pyccel-intel' : PSYDAC_BACKEND_IPYCCEL,
+    'pyccel-pgi'   : PSYDAC_BACKEND_PGPYCCEL,
+    'pyccel-nvidia': PSYDAC_BACKEND_NVPYCCEL,
+}

feectools/core/__init__.py

@@ -0,0 +1,11 @@
+from feectools.core import bsplines
+
+__all__ = ['bsplines']
+
+try:
+    from feectools.core import bsp
+    from feectools.core import interface
+except ImportError:
+    pass
+else:
+    __all__.extend( ['bsp','interface'] )