feectools 0.1.10__tar.gz → 0.2.0__tar.gz

{feectools-0.1.10/feectools.egg-info → feectools-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feectools
-Version: 0.1.10
+Version: 0.2.0
 Summary: Slimmed-down fork of Psydac (https://github.com/pyccel/psydac) with less functionality and fewer dependencies.
 Author-email: Psydac development team <psydac@googlegroups.com>
 Maintainer-email: Stefan Possanner <stefan.possanner@ipp.mpg.de>, Max Lindqvist <max.lindqvist@ipp.mpg.de>, Yaman Güçlü <yaman.guclu@gmail.com>, Martin Campos Pinto <martin.campos-pinto@ipp.mpg.de>, Ahmed Ratnani <ratnaniahmed@gmail.com>

feectools-0.2.0/feectools/__init__.py

@@ -0,0 +1,4 @@
+# MPI switch, read once when feectools.ddm.mpi is first imported:
+#   None  -> use mpi4py if it is available (default)
+#   False -> do not import mpi4py, use MockMPI (serial runs; saves ~1 s of import time)
+use_mpi = None

{feectools-0.1.10 → feectools-0.2.0}/feectools/api/settings.py

@@ -43,13 +43,16 @@ PSYDAC_BACKEND_NVPYCCEL = {'name': 'pyccel',
                        '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)
+def _get_gfortran_version():
+    """Version of the installed gfortran. Only queried where it is needed (see below), since it spawns a subprocess."""
+    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()
+    return Version(gfortran_version_string)
 
 # Platform-dependent flags
-if platform.system() == "Darwin" and platform.machine() == 'arm64' and gfortran_version >= Version("14"):
+# (the gfortran version is only relevant on Apple silicon; evaluating it lazily avoids running
+#  a subprocess on every import and lets feectools be imported without gfortran on other platforms)
+if platform.system() == "Darwin" and platform.machine() == 'arm64' and _get_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

feectools-0.2.0/feectools/ddm/mpi.py

@@ -0,0 +1,225 @@
+"""Detection of whether the process was launched by an MPI launcher.
+
+Importing ``mpi4py.MPI`` calls ``MPI_Init``, and any collective (``bcast``,
+``Barrier``, ...) issued afterwards costs something even on a single process.
+A plain ``python script.py`` run should therefore never touch MPI at all, even
+when mpi4py happens to be installed. This module answers the only question
+that decides it: was this process started by ``mpirun``/``mpiexec``/``srun``
+(or an equivalent launcher)?
+
+The answer is read from the environment the launcher sets up, so it is
+available before mpi4py is imported.
+"""
+
+import os
+import sys
+
+from dataclasses import dataclass
+from time import time
+from typing import TYPE_CHECKING
+
+
+# Per-process variables exported by the process managers behind the common
+# launchers. Each is set only for processes started *by* the launcher, so the
+# presence of any one of them means "this rank belongs to an MPI job".
+# SLURM_PROCID is deliberately absent: it is also set for the script of a
+# plain `sbatch` job, which is not an MPI launch. `srun` is covered by the
+# PMI/PMIX variables its MPI plugin exports.
+_LAUNCHER_ENV_VARS = (
+    "OMPI_COMM_WORLD_RANK",  # Open MPI (and derivatives: Spectrum, ...)
+    "PMI_RANK",  # MPICH, Intel MPI, MS-MPI, Cray, srun (pmi2)
+    "PMIX_RANK",  # PMIx, used by srun --mpi=pmix and Open MPI 5
+    "MV2_COMM_WORLD_RANK",  # MVAPICH2
+    "MPI_LOCALRANKID",  # Hydra (mpiexec.hydra)
+    "ALPS_APP_PE",  # Cray ALPS aprun
+    "PALS_RANKID",  # Cray PALS palsrun
+)
+
+# Escape hatch: force the decision either way without touching code, e.g. for
+# a launcher whose variables are not listed above.
+_OVERRIDE_ENV_VAR = "STRUPHY_MPI"
+
+_TRUE_VALUES = ("1", "true", "yes", "on")
+_FALSE_VALUES = ("0", "false", "no", "off")
+
+
+def _override() -> bool | None:
+    """Value of ``STRUPHY_MPI``, or None if unset/unrecognized."""
+    value = os.environ.get(_OVERRIDE_ENV_VAR)
+    if value is None:
+        return None
+    value = value.strip().lower()
+    if value in _TRUE_VALUES:
+        return True
+    if value in _FALSE_VALUES:
+        return False
+    return None
+
+
+def launched_under_mpi() -> bool:
+    """Whether this process was started by an MPI launcher.
+
+    Returns
+    -------
+    bool
+        True if a launcher's per-rank environment variable is present, or if
+        the application itself already initialized MPI (in which case using
+        the communicator is free). ``STRUPHY_MPI=0``/``1`` overrides
+        the detection.
+    """
+    override = _override()
+    if override is not None:
+        return override
+
+    if any(var in os.environ for var in _LAUNCHER_ENV_VARS):
+        return True
+
+    # The application may have initialized MPI itself (embedded interpreter,
+    # or an explicit `from mpi4py import MPI`). Only inspect mpi4py if it is
+    # already imported: importing it here is exactly what must be avoided.
+    mpi_module = sys.modules.get("mpi4py.MPI")
+    if mpi_module is not None:
+        try:
+            return bool(mpi_module.Is_initialized())
+        except AttributeError:
+            return False
+
+    return False
+
+
+# Might not be needed
+class MPICommWrapper:
+    def __init__(self, use_mpi=True):
+        self.use_mpi = use_mpi
+        if use_mpi:
+            from mpi4py import MPI
+
+            self.comm = MPI.COMM_WORLD
+        else:
+            self.comm = MockComm()
+
+    def __getattr__(self, name):
+        return getattr(self.comm, name)
+
+
+class MockComm:
+    def __getattr__(self, name):
+        # Return a function that does nothing and returns None
+        def dummy(*args, **kwargs):
+            return None
+
+        return dummy
+
+    # Override some functions
+    def Get_rank(self):
+        return 0
+
+    def Get_size(self):
+        return 1
+
+    def Barrier(self):
+        return
+
+
+class MPIwrapper:
+    def __init__(
+        self,
+        use_mpi: bool = False,
+        verbose: bool = False,
+    ):
+        self.use_mpi = use_mpi
+        if use_mpi:
+            from mpi4py import MPI
+
+            self._MPI = MPI
+            if verbose:
+                print("MPI is enabled")
+        else:
+            self._MPI = MockMPI()
+            if verbose:
+                print("MPI is NOT enabled")
+
+    @property
+    def MPI(self):
+        return self._MPI
+
+
+class MockMPI:
+    def __getattr__(self, name):
+        # Return a function that does nothing and returns None
+        def dummy(*args, **kwargs):
+            return None
+
+        return dummy
+
+    # Override some functions
+    @property
+    def COMM_WORLD(self):
+        return MockComm()
+
+    # def comm_Get_rank(self):
+    #     return 0
+
+    # def comm_Get_size(self):
+    #     return 1
+
+
+def _mpi_disabled():
+    """True if the user or the host application opted out of MPI.
+
+    Importing mpi4py initializes MPI, which takes close to a second. Serial runs that
+    never use MPI can skip it entirely, in two ways:
+
+    * export ``FEECTOOLS_MPI=0`` before starting Python, or
+    * set ``feectools.use_mpi = False`` before this module is first imported
+      (in-process, so it is not inherited by subprocesses such as ``mpirun``).
+
+    The MockMPI wrapper below is then used, exactly as if mpi4py were not installed.
+    """
+    import os
+
+    import feectools
+
+    if getattr(feectools, 'use_mpi', None) is False:
+        return True
+    return os.environ.get('FEECTOOLS_MPI', '').strip().lower() in ('0', 'false', 'no', 'off')
+
+
+if launched_under_mpi():
+    try:
+        # Disable MPI when using CuPy due to known segfault issues with OpenMPI + CUDA
+        import os
+        if os.environ.get('ARRAY_BACKEND') == 'cupy':
+            raise ImportError("MPI disabled when using CuPy backend")
+
+        if _mpi_disabled():
+            raise ImportError("MPI disabled (feectools.use_mpi = False or FEECTOOLS_MPI=0)")
+
+        from mpi4py import MPI
+
+        _comm = MPI.COMM_WORLD
+        # rank = _comm.Get_rank()
+        # size = _comm.Get_size()
+        mpi_enabled = True
+    except ImportError:
+        # mpi4py not installed
+        mpi_enabled = False
+    except Exception:
+        # mpi4py installed but not running under mpirun
+        mpi_enabled = False
+else:
+    mpi_enabled = False
+
+# TODO: add environment variable for mpi use
+mpi_wrapper = MPIwrapper(
+    use_mpi=mpi_enabled,
+    verbose=False,
+)
+
+# TYPE_CHECKING is True when type checking (e.g., mypy), but False at runtime.
+if TYPE_CHECKING:
+    from mpi4py import MPI
+
+    mpi = MPI
+else:
+    mpi = mpi_wrapper.MPI

{feectools-0.1.10 → feectools-0.2.0}/feectools/ddm/partition.py

@@ -2,10 +2,49 @@ import cunumpy as xp
 import numpy as np
 import numpy.ma as ma
 
-from sympy.ntheory import factorint
+__all__ = ('compute_dims', 'partition_procs_per_patch')
+
+#==============================================================================
+def factorint(n, multiple=False):
+    """
+    Prime factorization of an integer by trial division.
 
+    Drop-in replacement for the subset of ``sympy.ntheory.factorint`` used here.
+    Importing sympy takes ~1 s and is not needed for the small integers
+    (process counts, number of grid points) that are factorized in this module.
 
-__all__ = ('compute_dims', 'partition_procs_per_patch')
+    Parameters
+    ----------
+    n : int
+        Integer to factorize.
+
+    multiple : bool
+        If False (default), return a dict {prime: multiplicity}.
+        If True, return the list of primes in ascending order, repeated
+        according to their multiplicity.
+    """
+    n = int(n)
+    factors = {}
+
+    # same conventions as sympy for non-positive input
+    if n == 0:
+        factors[0] = 1
+    else:
+        if n < 0:
+            factors[-1] = 1
+            n = -n
+        p = 2
+        while p * p <= n:
+            while n % p == 0:
+                factors[p] = factors.get(p, 0) + 1
+                n //= p
+            p += 1 if p == 2 else 2
+        if n > 1:
+            factors[n] = factors.get(n, 0) + 1
+
+    if multiple:
+        return [p for p in sorted(factors) for _ in range(factors[p])]
+    return factors
 
 #==============================================================================
 def partition_procs_per_patch(npts, size):

{feectools-0.1.10 → feectools-0.2.0}/feectools/linalg/basic.py

@@ -7,6 +7,7 @@ provides the fundamental classes for linear algebra operations.
 
 """
 
+import itertools
 from abc import ABC, abstractmethod
 from types import LambdaType 
 from inspect import signature
@@ -280,13 +281,143 @@ class LinearOperator(ABC):
         upon convertion to matrix.
         """
 
-    @abstractmethod
-    def tosparse(self):
-        """ Convert to a sparse matrix in any of the formats supported by scipy.sparse."""
+    def toarray(self, out=None, is_sparse=False, format='csr'):
+        """
+        Assemble the global matrix of the linear operator column by column.
 
-    @abstractmethod
-    def toarray(self):
-        """ Convert to Numpy 2D array. """
+        Column j is computed as ``self.dot(e_j)``, where e_j is the j-th
+        canonical basis vector of the domain, in the global numbering of
+        ``Vector.toarray()`` (C-ordered within each StencilVector, blocks
+        concatenated). Since only ``dot`` is used, this works for any linear
+        operator, including matrix-free ones, whose domain is a
+        StencilVectorSpace or a (possibly nested) BlockVectorSpace thereof.
+
+        The cost is one call to ``dot`` per global degree of freedom of the
+        domain, hence this default is meant for testing and small problems.
+        Subclasses with an explicit matrix representation should override it.
+
+        In parallel, all ranks call ``dot`` collectively, each rank fills the
+        rows it owns, and every rank receives the full matrix.
+
+        Parameters
+        ----------
+        out : numpy.ndarray, optional
+            Dense array of shape ``self.shape`` into which the result is
+            written in place. Must be None if ``is_sparse`` is True.
+
+        is_sparse : bool
+            If True, return a scipy.sparse matrix, otherwise a dense
+            numpy.ndarray.
+
+        format : str
+            Sparse format, only used if ``is_sparse`` is True: one of 'csr'
+            (default), 'csc', 'bsr', 'lil', 'dok', 'coo' or 'dia'.
+
+        Returns
+        -------
+        numpy.ndarray or scipy.sparse matrix
+            The global matrix of shape ``self.shape``, identical on all ranks.
+        """
+        from feectools.linalg.block import BlockVectorSpace
+        from feectools.linalg.stencil import StencilVectorSpace
+
+        # Flatten the (possibly nested) block structure of the domain
+        def leaves(w):
+            if isinstance(w.space, StencilVectorSpace):
+                return [w]
+            elif isinstance(w.space, BlockVectorSpace):
+                return [lw for b in w.blocks for lw in leaves(b)]
+            else:
+                raise TypeError(f'{type(self).__name__}.toarray() requires a domain made of '
+                                f'StencilVectorSpaces, not {type(w.space).__name__}.')
+
+        e_j = self.domain.zeros()
+        Ae_j = self.codomain.zeros()
+        e_j_leaves = leaves(e_j)
+        offsets = xp.cumsum([0] + [lw.space.dimension for lw in e_j_leaves[:-1]])
+
+        if is_sparse:
+            assert out is None, 'out must be None if is_sparse is True.'
+            assert format in ('csr', 'csc', 'bsr', 'lil', 'dok', 'coo', 'dia'), \
+                f'Unknown sparse format {format!r}.'
+            rows, cols, data = [], [], []
+        elif out is None:
+            out = xp.zeros(self.shape, dtype=self.dtype)
+        else:
+            assert isinstance(out, xp.ndarray)
+            assert out.shape == self.shape, f'out has shape {out.shape}, expected {self.shape}.'
+
+        # Index ranges owned by each rank, for every leaf
+        bounds = [(lw.starts, lw.ends) for lw in e_j_leaves]
+        if e_j_leaves[0].space.parallel:
+            comm = e_j_leaves[0].space.cart.comm
+            rank = comm.Get_rank()
+            all_bounds = comm.allgather(bounds)
+        else:
+            comm = None
+            rank = 0
+            all_bounds = [bounds]
+
+        # All ranks loop over all columns, since dot() is collective;
+        # only the owner of index i sets the entry of e_j to one.
+        for owner, owner_bounds in enumerate(all_bounds):
+            for lw, offset, (starts, ends) in zip(e_j_leaves, offsets, owner_bounds):
+                for i in itertools.product(*(range(s, e + 1) for s, e in zip(starts, ends))):
+                    if rank == owner:
+                        lw[i] = 1
+                    lw.update_ghost_regions()
+                    self.dot(e_j, out=Ae_j)
+                    if rank == owner:
+                        lw[i] = 0
+
+                    # Global vector with nonzeros only in the rows owned by this rank
+                    col_j = Ae_j.toarray()
+                    j = offset + xp.ravel_multi_index(i, lw.space.npts)
+                    if is_sparse:
+                        nz = xp.flatnonzero(col_j)
+                        rows.append(nz)
+                        cols.append(xp.full(nz.size, j))
+                        data.append(col_j[nz])
+                    else:
+                        out[:, j] = col_j
+                # Clear the ghost regions of the last entry set to one
+                lw.update_ghost_regions()
+
+        if not is_sparse:
+            if comm is not None:
+                from feectools.ddm.mpi import mpi as MPI
+                comm.Allreduce(MPI.IN_PLACE, out, op=MPI.SUM)
+            return out
+
+        rows = xp.concatenate(rows) if rows else xp.zeros(0, dtype=int)
+        cols = xp.concatenate(cols) if cols else xp.zeros(0, dtype=int)
+        data = xp.concatenate(data) if data else xp.zeros(0, dtype=self.dtype)
+        if comm is not None:
+            rows = xp.concatenate(comm.allgather(rows))
+            cols = xp.concatenate(comm.allgather(cols))
+            data = xp.concatenate(comm.allgather(data))
+
+        return coo_matrix((data, (rows, cols)), shape=self.shape).asformat(format)
+
+    def tosparse(self, format='csr'):
+        """
+        Assemble the global matrix of the linear operator as a scipy.sparse matrix.
+
+        Default implementation calling the generic ``LinearOperator.toarray``
+        with ``is_sparse=True``; see there for cost and parallel behavior.
+        Subclasses with an explicit matrix representation should override it.
+
+        Parameters
+        ----------
+        format : str
+            One of 'csr' (default), 'csc', 'bsr', 'lil', 'dok', 'coo' or 'dia'.
+
+        Returns
+        -------
+        scipy.sparse matrix
+            The global matrix of shape ``self.shape``, identical on all ranks.
+        """
+        return LinearOperator.toarray(self, is_sparse=True, format=format)
 
     @abstractmethod
     def dot(self, v, out=None):
@@ -977,9 +1108,6 @@ class ComposedLinearOperator(LinearOperator):
     def dtype(self):
         return None
 
-    def toarray(self):
-        raise NotImplementedError('toarray() is not defined for ComposedLinearOperators.')
-
     def tosparse(self):
         mats = [M.tosparse() for M in self._multiplicants]
         M = mats[0]
@@ -1084,12 +1212,6 @@ class PowerLinearOperator(LinearOperator):
         """ Returns the power to which the operator is raised. """
         return self._factorial
 
-    def toarray(self):
-        raise NotImplementedError('toarray() is not defined for PowerLinearOperators.')
-
-    def tosparse(self):
-        raise NotImplementedError('tosparse() is not defined for PowerLinearOperators.')
-
     def transpose(self, conjugate=False):
         return PowerLinearOperator(domain=self.codomain, codomain=self.domain, A=self._operator.transpose(conjugate=conjugate), n=self._factorial)
 
@@ -1207,12 +1329,6 @@ class InverseLinearOperator(LinearOperator):
             elif key == 'verbose':
                 assert isinstance(value, bool), "verbose must be a bool"
 
-    def toarray(self):
-        raise NotImplementedError('toarray() is not defined for InverseLinearOperators.')
-
-    def tosparse(self):
-        raise NotImplementedError('tosparse() is not defined for InverseLinearOperators.')
-
     def get_info(self):
         """ Returns the previous convergence information. """
         return self._info
@@ -1366,12 +1482,6 @@ class MatrixFreeLinearOperator(LinearOperator):
                     
         return out
         
-    def toarray(self):
-        raise NotImplementedError('toarray() is not defined for MatrixFreeLinearOperator.')
-
-    def tosparse(self):
-        raise NotImplementedError('tosparse() is not defined for MatrixFreeLinearOperator.')
-    
     def transpose(self, conjugate=False):
         if self._dot_transpose is None:
             raise NotImplementedError('no transpose dot method was given -- cannot create the transpose operator')

{feectools-0.1.10 → feectools-0.2.0}/feectools/linalg/direct_solvers.py

@@ -6,9 +6,7 @@
 from abc                 import abstractmethod
 import cunumpy as xp
 from cunumpy.xp import array_backend
-from scipy.linalg.lapack import dgbtrf, dgbtrs, sgbtrf, sgbtrs, cgbtrf, cgbtrs, zgbtrf, zgbtrs
 from scipy.sparse        import spmatrix, dia_matrix
-from scipy.sparse.linalg import splu
 
 from feectools.linalg.basic    import LinearSolver
 
@@ -53,6 +51,9 @@ class BandedSolver(LinearSolver):
         self._l    = l
         self._transposed = transposed
 
+        # imported here: scipy.linalg costs ~0.3 s to import and is only needed once a solver is built
+        from scipy.linalg.lapack import dgbtrf, dgbtrs, sgbtrf, sgbtrs, cgbtrf, cgbtrs, zgbtrf, zgbtrs
+
         # ... LU factorization
         if bmat.dtype == xp.float32:
             self._factor_function = sgbtrf
@@ -186,6 +187,8 @@ class SparseSolver (LinearSolver):
 
         assert isinstance(spmat, spmatrix)
 
+        from scipy.sparse.linalg import splu  # deferred, see BandedSolver
+
         self._space = xp.ndarray
         self._splu  = splu(spmat.tocsc())
         self._transposed = transposed

{feectools-0.1.10 → feectools-0.2.0}/feectools/linalg/fft.py

@@ -21,12 +21,6 @@ class DistributedFFTBase(LinearOperator):
         The function at position i is applied to the i-th tensor direction.
         If only a single callable is given, it is used for all directions.
     """
-    def toarray(self):
-        raise NotImplementedError('toarray() is not defined for DistributedFFTBase.')
-
-    def tosparse(self):
-        raise NotImplementedError('tosparse() is not defined for DistributedFFTBase.')
-
     # Possible additions for the future:
     # * split off the LinearSolver class when used with the space ndarray (as used in the KroneckerLinearSolver),
     #   and make it state if it works in-place (or if it needs temporary memory), and what its optimal

{feectools-0.1.10 → feectools-0.2.0}/feectools/linalg/kron.py

@@ -528,12 +528,6 @@ class KroneckerLinearSolver(LinearOperator):
     @property
     def dtype(self):
         return None
-    
-    def toarray(self):
-        raise NotImplementedError('toarray() is not defined for KroneckerLinearSolvers.')
-    
-    def tosparse(self):
-        raise NotImplementedError('tosparse() is not defined for KroneckerLinearSolvers.')
 
     def transpose(self, conjugate=False):
         new_domain = self._codomain

feectools-0.2.0/feectools/linalg/tests/test_toarray.py

@@ -0,0 +1,162 @@
+# -*- coding: UTF-8 -*-
+#
+# Tests for the generic LinearOperator.toarray() and LinearOperator.tosparse(),
+# which assemble the matrix of any linear operator from its dot() method.
+#
+import pytest
+import cunumpy as xp
+
+from feectools.ddm.mpi import mpi as MPI
+from feectools.ddm.cart import DomainDecomposition, CartDecomposition
+from feectools.linalg.basic import LinearOperator, MatrixFreeLinearOperator, IdentityOperator
+from feectools.linalg.stencil import StencilVectorSpace, StencilMatrix
+from feectools.linalg.block import BlockVectorSpace, BlockLinearOperator
+from feectools.linalg.solvers import inverse
+from feectools.linalg.tests.test_block import compute_global_starts_ends
+
+SPARSE_FORMATS = ['csr', 'csc', 'bsr', 'lil', 'dok', 'coo', 'dia']
+
+#===============================================================================
+# HELPERS
+#===============================================================================
+def get_space(npts, pads, periods, comm=None):
+    D = DomainDecomposition(npts, periods=periods, comm=comm)
+    global_starts, global_ends = compute_global_starts_ends(D, npts)
+    C = CartDecomposition(D, npts, global_starts, global_ends, pads=pads, shifts=[1] * len(npts))
+    return StencilVectorSpace(C)
+
+def get_random_matrix(V, W, seed):
+    """ Random StencilMatrix, identical on all ranks in the global numbering. """
+    rng = xp.random.default_rng(seed)
+    M = StencilMatrix(V, W)
+    # Draw the full (global) band and keep the local part, so the matrix
+    # does not depend on the domain decomposition.
+    shape = tuple(W.npts) + M._data.shape[W.ndim:]
+    band = rng.random(shape) - 0.5
+    idx = tuple(slice(s, e + 1) for s, e in zip(W.starts, W.ends))
+    M[idx] = band[idx]
+    M.remove_spurious_entries()
+    return M
+
+def matrix_free(A):
+    """ Hide the explicit matrix of A, so that the generic toarray() is used. """
+    return MatrixFreeLinearOperator(A.domain, A.codomain, lambda v, out=None: A.dot(v, out=out))
+
+def reference(A):
+    """ Global dense matrix of A, from its own (row-local in parallel) tosparse(). """
+    local = A.tosparse().toarray()
+    comm = A.domain.cart.comm if isinstance(A.domain, StencilVectorSpace) else A.domain.spaces[0].cart.comm
+    if A.domain.parallel:
+        glob = xp.zeros_like(local)
+        comm.Allreduce(local, glob, op=MPI.SUM)
+        return glob
+    return local
+
+def check_all(O, ref):
+    """ Check dense, in-place and all sparse outputs of the generic toarray()/tosparse(). """
+    assert xp.allclose(O.toarray(), ref)
+
+    out = xp.full(O.shape, 7.0)
+    res = O.toarray(out=out)
+    assert res is out
+    assert xp.allclose(out, ref)
+
+    for fmt in SPARSE_FORMATS:
+        S = O.toarray(is_sparse=True, format=fmt)
+        assert S.format == fmt
+        assert S.shape == O.shape
+        assert xp.allclose(S.toarray(), ref)
+
+    S = O.tosparse()
+    assert S.format == 'csr'
+    assert xp.allclose(S.toarray(), ref)
+    assert O.tosparse('csc').format == 'csc'
+
+def stencil_case(periods, comm):
+    V = get_space([6, 5], [2, 1], periods, comm=comm)
+    return get_random_matrix(V, V, seed=0)
+
+def block_case(periods, comm):
+    """ 2x2 block operator, and a nested block operator [[B, 0], [0, A]]. """
+    V = get_space([6, 5], [2, 1], periods, comm=comm)
+    A = get_random_matrix(V, V, seed=0)
+    A01 = get_random_matrix(V, V, seed=1)
+    VV = BlockVectorSpace(V, V)
+    B = BlockLinearOperator(VV, VV, blocks=[[A, A01], [None, A]])
+    Vn = BlockVectorSpace(VV, V)
+    N = BlockLinearOperator(Vn, Vn, blocks=[[B, None], [None, A]])
+    return A, B, N
+
+#===============================================================================
+# SERIAL TESTS
+#===============================================================================
+@pytest.mark.parametrize('periods', [[False, False], [True, False], [True, True]])
+def test_toarray_stencil(periods):
+    A = stencil_case(periods, comm=None)
+    check_all(matrix_free(A), reference(A))
+
+@pytest.mark.parametrize('periods', [[False, False], [True, True]])
+def test_toarray_block(periods):
+    A, B, N = block_case(periods, comm=None)
+    refA, refB = reference(A), reference(B)
+    check_all(matrix_free(B), refB)
+
+    Z = xp.zeros((refB.shape[0], refA.shape[1]))
+    refN = xp.block([[refB, Z], [Z.T, refA]])
+    check_all(matrix_free(N), refN)
+
+def test_toarray_composite_operators():
+    """ Operators that used to raise NotImplementedError in toarray()/tosparse(). """
+    A = stencil_case([True, False], comm=None)
+    ref = reference(A)
+    V = A.domain
+
+    assert xp.allclose((A @ A).toarray(), ref @ ref)
+    assert xp.allclose((A ** 2).toarray(), ref @ ref)
+    assert xp.allclose((A ** 2).tosparse().toarray(), ref @ ref)
+
+    M = A.T @ A + IdentityOperator(V)
+    refM = ref.T @ ref + xp.eye(ref.shape[0])
+    Minv = inverse(M, 'cg', tol=1e-13, maxiter=1000)
+    assert xp.allclose(Minv.toarray(), xp.linalg.inv(refM), atol=1e-8)
+
+def test_toarray_invalid_input():
+    O = matrix_free(stencil_case([False, False], comm=None))
+    with pytest.raises(AssertionError):
+        O.toarray(out=xp.zeros((O.shape[0], O.shape[1] + 1)))
+    with pytest.raises(AssertionError):
+        O.toarray(out=xp.zeros(O.shape), is_sparse=True)
+    with pytest.raises(AssertionError):
+        O.toarray(is_sparse=True, format='xyz')
+
+#===============================================================================
+# PARALLEL TESTS
+#===============================================================================
+@pytest.mark.parametrize('periods', [[False, False], [True, False], [True, True]])
+@pytest.mark.parallel
+def test_toarray_stencil_parallel(periods):
+    A = stencil_case(periods, comm=MPI.COMM_WORLD)
+    check_all(matrix_free(A), reference(A))
+
+@pytest.mark.parametrize('periods', [[False, False], [True, True]])
+@pytest.mark.parallel
+def test_toarray_block_parallel(periods):
+    A, B, N = block_case(periods, comm=MPI.COMM_WORLD)
+    refA, refB = reference(A), reference(B)
+    check_all(matrix_free(B), refB)
+
+    Z = xp.zeros((refB.shape[0], refA.shape[1]))
+    refN = xp.block([[refB, Z], [Z.T, refA]])
+    check_all(matrix_free(N), refN)
+
+@pytest.mark.parallel
+def test_toarray_composite_operators_parallel():
+    A = stencil_case([True, False], comm=MPI.COMM_WORLD)
+    ref = reference(A)
+    assert xp.allclose((A @ A).toarray(), ref @ ref)
+    assert xp.allclose((A ** 2).tosparse().toarray(), ref @ ref)
+
+#===============================================================================
+if __name__ == '__main__':
+    import sys
+    pytest.main(sys.argv)

{feectools-0.1.10 → feectools-0.2.0/feectools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feectools
-Version: 0.1.10
+Version: 0.2.0
 Summary: Slimmed-down fork of Psydac (https://github.com/pyccel/psydac) with less functionality and fewer dependencies.
 Author-email: Psydac development team <psydac@googlegroups.com>
 Maintainer-email: Stefan Possanner <stefan.possanner@ipp.mpg.de>, Max Lindqvist <max.lindqvist@ipp.mpg.de>, Yaman Güçlü <yaman.guclu@gmail.com>, Martin Campos Pinto <martin.campos-pinto@ipp.mpg.de>, Ahmed Ratnani <ratnaniahmed@gmail.com>

{feectools-0.1.10 → feectools-0.2.0}/feectools.egg-info/SOURCES.txt

@@ -100,6 +100,7 @@ feectools/linalg/tests/test_solvers.py
 feectools/linalg/tests/test_stencil_interface_matrix.py
 feectools/linalg/tests/test_stencil_vector.py
 feectools/linalg/tests/test_stencil_vector_space.py
+feectools/linalg/tests/test_toarray.py
 feectools/linalg/tests/utilities.py
 feectools/utilities/__init__.py
 feectools/utilities/quadratures.py

{feectools-0.1.10 → feectools-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name            = "feectools"
-version         = "0.1.10"
+version         = "0.2.0"
 description     = "Slimmed-down fork of Psydac (https://github.com/pyccel/psydac) with less functionality and fewer dependencies."
 readme          = "README.md"
 requires-python = ">= 3.10"

feectools-0.1.10/feectools/ddm/mpi.py

@@ -1,114 +0,0 @@
-from dataclasses import dataclass
-from time import time
-from typing import TYPE_CHECKING
-
-
-# Might not be needed
-class MPICommWrapper:
-    def __init__(self, use_mpi=True):
-        self.use_mpi = use_mpi
-        if use_mpi:
-            from mpi4py import MPI
-
-            self.comm = MPI.COMM_WORLD
-        else:
-            self.comm = MockComm()
-
-    def __getattr__(self, name):
-        return getattr(self.comm, name)
-
-
-class MockComm:
-    def __getattr__(self, name):
-        # Return a function that does nothing and returns None
-        def dummy(*args, **kwargs):
-            return None
-
-        return dummy
-
-    # Override some functions
-    def Get_rank(self):
-        return 0
-
-    def Get_size(self):
-        return 1
-
-    def Barrier(self):
-        return
-
-
-class MPIwrapper:
-    def __init__(
-        self,
-        use_mpi: bool = False,
-        verbose: bool = False,
-    ):
-        self.use_mpi = use_mpi
-        if use_mpi:
-            from mpi4py import MPI
-
-            self._MPI = MPI
-            if verbose:
-                print("MPI is enabled")
-        else:
-            self._MPI = MockMPI()
-            if verbose:
-                print("MPI is NOT enabled")
-
-    @property
-    def MPI(self):
-        return self._MPI
-
-
-class MockMPI:
-    def __getattr__(self, name):
-        # Return a function that does nothing and returns None
-        def dummy(*args, **kwargs):
-            return None
-
-        return dummy
-
-    # Override some functions
-    @property
-    def COMM_WORLD(self):
-        return MockComm()
-
-    # def comm_Get_rank(self):
-    #     return 0
-
-    # def comm_Get_size(self):
-    #     return 1
-
-
-try:
-    # Disable MPI when using CuPy due to known segfault issues with OpenMPI + CUDA
-    import os
-    if os.environ.get('ARRAY_BACKEND') == 'cupy':
-        raise ImportError("MPI disabled when using CuPy backend")
-    
-    from mpi4py import MPI
-
-    _comm = MPI.COMM_WORLD
-    # rank = _comm.Get_rank()
-    # size = _comm.Get_size()
-    mpi_enabled = True
-except ImportError:
-    # mpi4py not installed
-    mpi_enabled = False
-except Exception:
-    # mpi4py installed but not running under mpirun
-    mpi_enabled = False
-
-# TODO: add environment variable for mpi use
-mpi_wrapper = MPIwrapper(
-    use_mpi=mpi_enabled,
-    verbose=False,
-)
-
-# TYPE_CHECKING is True when type checking (e.g., mypy), but False at runtime.
-if TYPE_CHECKING:
-    from mpi4py import MPI
-
-    mpi = MPI
-else:
-    mpi = mpi_wrapper.MPI