feectools 0.1.0__py3-none-any.whl

feectools/linalg/utilities.py

@@ -0,0 +1,200 @@
+# coding: utf-8
+
+import numpy as np
+from math import sqrt
+
+from feectools.linalg.basic   import Vector
+from feectools.linalg.stencil import StencilVector, StencilVectorSpace
+from feectools.linalg.block   import BlockVector, BlockVectorSpace
+from feectools.linalg.topetsc import petsc_local_to_psydac, get_npts_per_block
+
+__all__ = (
+    'array_to_psydac',
+    'petsc_to_psydac',
+    '_sym_ortho',
+)
+
+#==============================================================================
+def array_to_psydac(x, V):
+    """ 
+    Convert a NumPy array to a Vector of the space V. This function is designed to be the inverse of the method .toarray() of the class Vector.
+    Note: This function works in parallel but it is very costly and should be avoided if performance is a priority.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Array to be converted. It only contains the true data, the ghost regions must not be included.
+
+    V : feectools.linalg.stencil.StencilVectorSpace or feectools.linalg.block.BlockVectorSpace
+        Space of the final Psydac Vector.
+
+    Returns
+    -------
+    u : feectools.linalg.stencil.StencilVector or feectools.linalg.block.BlockVector
+        Element of space V, the coefficients of which (excluding ghost regions) are the entries of x. The ghost regions of u are up to date.
+
+    """
+
+    assert x.ndim == 1, 'Array must be 1D.'
+    if x.dtype==complex:
+        assert V.dtype==complex, 'Complex array cannot be converted to a real StencilVector'
+    assert x.size == V.dimension, 'Array must have the same global size as the space.'
+
+    u = V.zeros()
+    _array_to_psydac_recursive(x, u)
+    u.update_ghost_regions()
+
+    return u
+
+
+def _array_to_psydac_recursive(x, u):
+    """
+    Recursive function filling in the coefficients of each block of u.
+    """
+    assert isinstance(u, Vector)
+    V = u.space
+
+    assert x.ndim == 1, 'Array must be 1D.'
+    if x.dtype==complex:
+        assert V.dtype==complex, 'Complex array cannot be converted to a real StencilVector'
+    assert x.size == V.dimension, 'Array must have the same global size as the space.'    
+
+    if isinstance(V, BlockVectorSpace):
+        for i, V_i in enumerate(V.spaces):
+            x_i = x[:V_i.dimension]
+            x   = x[V_i.dimension:]
+            u_i = u[i]
+            _array_to_psydac_recursive(x_i, u_i)
+
+    elif isinstance(V, StencilVectorSpace):
+        index_global = tuple(slice(s, e+1) for s, e in zip(V.starts, V.ends))
+        u[index_global] = x.reshape(V.npts)[index_global]
+
+    else:
+        raise NotImplementedError(f'Can only handle StencilVector or BlockVector spaces, got {type(V)} instead')
+    
+#==============================================================================
+def petsc_to_psydac(x, Xh, out=None):
+    """
+    Convert a PETSc.Vec object to a StencilVector or BlockVector. It assumes that PETSc was installed with the configuration for complex numbers.
+    Uses the index conversion functions in feectools.linalg.topetsc.py.
+
+    Parameters
+    ----------
+    x : PETSc.Vec
+      PETSc vector
+
+    Xh : feectools.linalg.stencil.StencilVectorSpace | feectools.linalg.block.BlockVectorSpace
+      Space of the coefficients of the Psydac vector.
+
+    out : feectools.linalg.stencil.StencilVector | feectools.linalg.block.BlockVector, optional
+      The Psydac vector where to store the result.
+
+    Returns
+    -------
+    u : feectools.linalg.stencil.StencilVector | feectools.linalg.block.BlockVector
+        Psydac vector. In the case of a BlockVector, the blocks must be StencilVector. The general case is not yet implemented.
+    """
+    
+    if isinstance(Xh, BlockVectorSpace):
+        if any([isinstance(Xh.spaces[b], BlockVectorSpace) for b in range(len(Xh.spaces))]):
+            raise NotImplementedError('Block of blocks not implemented.')
+        
+        if out is not None:
+            assert isinstance(out, BlockVector)
+            assert out.space is Xh
+            u = out
+        else:
+            u = BlockVector(Xh)
+
+        comm       = x.comm
+        dtype      = Xh._dtype
+        localsize, globalsize = x.getSizes()
+        assert globalsize == u.shape[0], 'Sizes of global vectors do not match'
+
+        # Find shift for process k:
+        # ..get number of points for each block, each process and each dimension:
+        npts_local_per_block_per_process = np.array(get_npts_per_block(Xh)) #indexed [b,k,d] for block b and process k and dimension d
+        # ..get local sizes for each block and each process:
+        local_sizes_per_block_per_process = np.prod(npts_local_per_block_per_process, axis=-1) #indexed [b,k] for block b and process k
+        # ..sum the sizes over all the blocks and the previous processes:
+        index_shift = 0 + np.sum(local_sizes_per_block_per_process[:,:comm.Get_rank()], dtype=int) #global variable
+
+        for local_petsc_index in range(localsize):
+            block_index, psydac_index = petsc_local_to_psydac(Xh, local_petsc_index)
+            # Get value of local PETSc vector passing the global PETSc index
+            value = x.getValue(local_petsc_index + index_shift) 
+            if value != 0:
+                u[block_index[0]]._data[psydac_index] = value if dtype is complex else value.real # PETSc always handles dtype specified in the installation configuration
+        
+    elif isinstance(Xh, StencilVectorSpace):
+
+        if out is not None:
+            assert isinstance(out, StencilVector)
+            assert out.space is Xh
+            u = out
+        else:
+            u = StencilVector(Xh)
+
+        comm       = x.comm
+        dtype      = Xh.dtype
+        localsize, globalsize = x.getSizes()
+        assert globalsize == u.shape[0], 'Sizes of global vectors do not match'
+
+        # Find shift for process k:
+        # ..get number of points for each process and each dimension:
+        npts_local_per_block_per_process = np.array(get_npts_per_block(Xh))[0] #indexed [k,d] for process k and dimension d
+        # ..get local sizes for each process:
+        local_sizes_per_block_per_process = np.prod(npts_local_per_block_per_process, axis=-1) #indexed [k] for process k
+        # ..sum the sizes over all the previous processes:
+        index_shift = 0 + np.sum(local_sizes_per_block_per_process[:comm.Get_rank()], dtype=int) #global variable
+
+        for local_petsc_index in range(localsize):
+            block_index, psydac_index = petsc_local_to_psydac(Xh, local_petsc_index) 
+            # Get value of local PETSc vector passing the global PETSc index
+            value = x.getValue(local_petsc_index + index_shift)
+            if value != 0:
+                u._data[psydac_index] = value if dtype is complex else value.real # PETSc always handles dtype specified in the installation configuration            
+
+    else:
+        raise ValueError('Xh must be a StencilVectorSpace or a BlockVectorSpace')
+
+    u.update_ghost_regions()
+
+    return u
+
+#==============================================================================
+def _sym_ortho(a, b):
+    """
+    Stable implementation of Givens rotation.
+    This function was taken from the scipy repository
+    https://github.com/scipy/scipy/blob/master/scipy/sparse/linalg/isolve/lsqr.py
+
+    Notes
+    -----
+    The routine 'SymOrtho' was added for numerical stability. This is
+    recommended by S.-C. Choi in [1]_.  It removes the unpleasant potential of
+    ``1/eps`` in some important places (see, for example text following
+    "Compute the next plane rotation Qk" in minres.py).
+
+    References
+    ----------
+    .. [1] S.-C. Choi, "Iterative Methods for Singular Linear Equations
+           and Least-Squares Problems", Dissertation,
+           http://www.stanford.edu/group/SOL/dissertations/sou-cheng-choi-thesis.pdf
+    """
+    if b == 0:
+        return np.sign(a), 0, abs(a)
+    elif a == 0:
+        return 0, np.sign(b), abs(b)
+    elif abs(b) > abs(a):
+        tau = a / b
+        s = np.sign(b) / sqrt(1 + tau * tau)
+        c = s * tau
+        r = b / s
+    else:
+        tau = b / a
+        c = np.sign(a) / sqrt(1+tau*tau)
+        s = c * tau
+        r = a / c
+    return c, s, r

feectools/utilities/quadratures.py

@@ -0,0 +1,113 @@
+# -*- coding: UTF-8 -*-
+#! /usr/bin/python
+
+"""
+This module contains some routines to generate quadrature points in 1D
+it has also a routine uniform, which generates uniform points
+with weights equal to 1
+"""
+
+import numpy as np
+
+from math import cos, pi
+from numpy import zeros
+
+
+__all__ = ('gauss_legendre', 'gauss_lobatto', 'quadrature')
+
+
+def gauss_legendre(m, tol=1e-13):
+    """
+    Compute Gauss-Legendre quadrature points and weights on [-1, 1].
+
+    Returns nodal abscissas {x} and weights {A} of a Gauss-Legendre m-point
+    quadrature over the canonical interval [-1, 1].
+
+    Parameters
+    ----------
+    m : int
+        Number of quadrature points in the quadrature rule.
+
+    tol : float
+        Tolerance for the Newton-Raphson root-searching method.
+
+    Returns
+    -------
+    x : numpy.ndarray[float]
+        Abscissas of the quadrature points, in ascending order.
+
+    A : numpy.ndarray[float]
+        Weights of the quadrature points corresponding to the abscissas above.
+
+    """
+    assert isinstance(m, int)
+    assert isinstance(tol, float)
+    assert m >= 1
+    assert tol >= 0
+
+    def legendre(t, m):
+        p0 = 1.0
+        p1 = t
+        for k in range(1, m):
+            p = ((2.0*k + 1.0)*t*p1 - k*p0)/(1.0 + k)
+            p0 = p1
+            p1 = p
+        dp = m*(p0 - t*p1)/(1.0 - t**2)
+        return p1, dp
+
+    A = zeros(m)
+    x = zeros(m)
+    nRoots = (m + 1) // 2          # Number of non-neg. roots
+    for i in range(nRoots):
+        t = cos(pi*(i + 0.75)/(m + 0.5))  # Approx. root
+        for j in range(30):
+            p, dp = legendre(t, m)        # Newton-Raphson
+            dt = -p/dp                    # method
+            t = t + dt
+            if abs(dt) < tol:
+                x[i]     = -t
+                x[m-i-1] =  t
+                A[i]     = 2.0/(1.0 - t**2)/(dp**2) # Eq.(6.25)
+                A[m-i-1] = A[i]
+                break
+    return x, A
+
+
+def gauss_lobatto(k):
+    """
+    Returns nodal abscissas {x} and weights {A} of
+    Gauss-Legendre m-point quadrature.
+    """
+    beta = .5 / np.sqrt(1-(2 * np.arange(1., k + 1)) ** (-2)) #3-term recurrence coeffs
+    beta[-1] = np.sqrt((k / (2 * k-1.)))
+    T = np.diag(beta, 1) + np.diag(beta, -1) # jacobi matrix
+    D, V = np.linalg.eig(T) # eigenvalue decomposition
+    xg = np.real(D); i = xg.argsort(); xg.sort() # nodes (= Legendres points)
+    w = 2 * (V[0, :]) ** 2; # weights
+
+    return xg, w[i]
+
+
+def quadrature(a, k, method="legendre"):
+    """
+    this routine generates a quad pts on the grid linspace(a,b,N)
+    """
+
+    if method == "legendre":
+        x, w = gauss_legendre(k)
+    elif method == "lobatto":
+        x, w = gauss_lobatto(k)
+    else:
+        raise NotImplemented("> Only Gauss-Legendre is implemented.")
+
+    grid = a
+    N = len(a)
+    xgl = np.zeros((N-1, k + 1))
+    wgl = np.zeros((N-1, k + 1))
+    for i in range (0, N-1):
+        xmin = grid[i];xmax = grid[i + 1];dx = 0.5 * (xmax-xmin)
+        tab = dx * x + dx + xmin
+        xgl[i, :] = tab[::-1]
+        wgl[i, :] = 0.5 * ( xmax - xmin ) * w
+
+    return xgl,wgl

feectools/utilities/utils.py

@@ -0,0 +1,166 @@
+# coding: utf-8
+#
+# Copyright 2018 Yaman Güçlü
+
+import numpy as np
+from numbers import Number
+
+__all__ = (
+    'refine_array_1d',
+    'unroll_edges',
+    'split_space',
+    'split_field',
+    'animate_field'
+)
+
+#==============================================================================
+def is_real(x):
+    """Determine whether the given input represents a real number.
+
+    Parameters
+    ----------
+    x : Any
+
+    Returns
+    -------
+    bool
+        True if x is real, False otherwise.
+
+    """
+    return isinstance(x, Number) and np.isrealobj(x) and not isinstance(x, bool)
+
+#===============================================================================
+def refine_array_1d(x, n, remove_duplicates=True):
+    """
+    Refines a 1D array by subdividing each interval (x[i], x[i+1]) into n identical parts.
+
+    Parameters
+    ----------
+    x : ndarray
+        1D array to be refined.
+    
+    n : int
+        Number of subdivisions to be created in each interval (x[i], x[i+1]).
+
+    remove_duplicates : bool, default=True
+        If True, the refined array will not contain any duplicate points.
+        If False, the original internal grid points x[1:-1] will appear twice: this may
+        be useful to visualize fields that are discontinuous across cell boundaries.
+
+    Returns
+    -------
+    ndarray
+        Refined 1D array. The length of this array is `n * (len(x) - 1) + 1`
+        if remove_duplicates and `(n + 1) * (len(x) - 1)` if not.
+    """
+    xr = []
+    if not remove_duplicates:
+        n += 1
+    for (a, b) in zip(x[:-1], x[1:]):
+        xr.extend(np.linspace(a, b, n, endpoint=not remove_duplicates))
+    if remove_duplicates:
+        xr.append(x[-1])
+    return np.array(xr)
+
+#===============================================================================
+def unroll_edges(domain, xgrid):
+    """If necessary, "unroll" intervals that cross boundary of periodic domain.
+    """
+
+    xA, xB = domain
+
+    assert all(np.diff(xgrid) >= 0)
+    assert xA < xB
+    assert xA <= xgrid[0]
+    assert xgrid[-1] <= xB
+
+    if xgrid[0] == xA and xgrid[-1] == xB:
+        return xgrid
+
+    elif xgrid[0] != xA:
+        return np.array([xgrid[-1] - (xB-xA), *xgrid])
+
+    elif xgrid[-1] != xB:
+        return np.array([*xgrid, xgrid[0] + (xB-xA)])
+
+#===============================================================================
+def roll_edges(domain, points):
+    """If necessary, "roll" back intervals that cross boundary of periodic domain.
+    Changes are made in place to avoid duplicating the array
+    """
+    xA, xB = domain
+    assert xA < xB
+    points -=xA
+    points %=(xB-xA)
+    points +=xA
+
+#===============================================================================
+def split_field(uh, spaces, out=None):
+    """Split a field into a list of fields that corresponds to the spaces.
+       The split field function will allocate new memory if out is not passed.
+
+    Parameters
+    ----------
+    uh : FemField
+        The fem field.
+
+    spaces: <list, FemSpace>
+        List of spaces that split the field.
+
+    out: optional, <list, FemField>
+        List of fields to write the results to.
+ 
+    Returns
+    -------
+    out : <list, FemField>
+         List of fem fields.
+    """
+    from feectools.fem.basic import FemField
+    if out is None:
+        out = [FemField(S) for S in spaces]
+
+    flattened_fields = [f.fields if f.fields else [f] for f in out]
+    flattened_fields = [f for l in flattened_fields for f in l]
+    for f1,f2 in zip(flattened_fields, uh.fields):
+        assert f1.space is f2.space
+        f1.coeffs[:] = f2.coeffs[:]
+
+    return out
+
+#===============================================================================
+def animate_field(fields, domain, mapping, res=(150,150), vrange=None, cmap=None, interval=35, progress=False, figsize=(14,4)):
+    """Animate a sequence of scalar fields over a geometry."""
+    from matplotlib import animation
+    import matplotlib.pyplot as plt
+    import tqdm
+
+    fields = list(fields)
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.set_aspect('equal')
+
+    etas    = [refine_array_1d( bounds, r ) for r,bounds in zip(res, zip(domain.min_coords, domain.max_coords))]
+    pcoords = np.array( [[mapping( e1,e2 ) for e2 in etas[1]] for e1 in etas[0]] )
+    xx      = pcoords[:,:,0]
+    yy      = pcoords[:,:,1]
+
+    # determine range of values from first field
+    num1     = np.array( [[fields[0].fields[0]( e1,e2 ) for e2 in etas[1]] for e1 in etas[0]] )
+    num2     = np.array( [[fields[0].fields[1]( e1,e2 ) for e2 in etas[1]] for e1 in etas[0]] )
+    num      = np.hypot(num1, num2)
+    vrange   = (num.min(), num.max())
+
+    quadmesh = plt.pcolormesh(xx, yy, num, shading='gouraud', cmap=cmap,
+                vmin=vrange[0], vmax=vrange[1], axes=ax)
+    fig.colorbar(quadmesh, ax=ax)
+
+    pbar = tqdm.tqdm(total=len(fields))
+    def anim_func(i):
+        num1     = np.array( [[fields[i].fields[0]( e1,e2 ) for e2 in etas[1]] for e1 in etas[0]] )
+        num2     = np.array( [[fields[i].fields[1]( e1,e2 ) for e2 in etas[1]] for e1 in etas[0]] )
+        C        = np.hypot(num1, num2)
+        quadmesh.set_array(C)
+        pbar.update()
+        if i == len(fields) - 1:
+            pbar.close()
+
+    return animation.FuncAnimation(fig, anim_func, frames=len(fields), interval=interval)

feectools/version.py

@@ -0,0 +1 @@
+__version__ = "0.1"

feectools-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: feectools
+Version: 0.1.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>
+License: MIT License
+        
+        Copyright (c) 2018-2023, Psydac Developers.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/struphy-hub/psydac-for-struphy
+Project-URL: Documentation, https://github.com/struphy-hub/psydac-for-struphy
+Project-URL: Repository, https://github.com/struphy-hub/psydac-for-struphy
+Keywords: FEM,IGA,B-spline,NURBS
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: numpy>=1.16
+Requires-Dist: scipy>=1.12
+Requires-Dist: sympy>=1.5
+Requires-Dist: matplotlib
+Requires-Dist: pyyaml>=5.1
+Requires-Dist: packaging
+Requires-Dist: pyevtk
+Requires-Dist: pyccel>=2.0.1
+Requires-Dist: h5py
+Requires-Dist: tblib
+Provides-Extra: test
+Requires-Dist: pytest-cov>=5.0.0; extra == "test"
+Requires-Dist: pytest>=4.5; extra == "test"
+Requires-Dist: pytest-xdist>=1.16; extra == "test"
+Requires-Dist: pytest-testmon; extra == "test"
+Requires-Dist: Pillow; extra == "test"
+Provides-Extra: mpi
+Requires-Dist: mpi4py>=4; extra == "mpi"
+Dynamic: license-file
+
+# Welcome!
+
+This is a fork of [Psydac](https://github.com/pyccel/psydac) that provides Finite Element Exterior Calculus (FEEC) for [Struphy](https://github.com/struphy-hub/struphy). It is a stripped-down version of the original repo with less functionality and fewer dependencies.
+
+The latest version can be installed with
+```
+pip install -U feectools
+```
+See the [Struphy documentation](https://struphy-hub.github.io/struphy/index.html) for details on how to use.

feectools-0.1.0.dist-info/RECORD

@@ -0,0 +1,98 @@
+feectools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/version.py,sha256=Lgf9keBX7aG_JEFt6UYSyiFKcm-BYGtmk9ohpQhYpyk,20
+feectools/accelerate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/accelerate/accelerate.py,sha256=pdkCJoiz7IfBbrNh78INKIGPm5kmauGEy7risiW3GRA,6731
+feectools/accelerate/compile_psydac.mk,sha256=NE-NQPoYoZNKDd_eMgx_fVuh0AGbMNLU7NIx99RG8qs,1505
+feectools/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/api/essential_bc.py,sha256=MDdUUFHRwe3Y_pBTX3YKvcxVK1JNWU3EnSTYMvBIprY,4340
+feectools/api/fem_bilinear_form.py,sha256=nhYCipAQZn6OoZuGXBi7v3xi-af_0k71G25ohoziqkA,116758
+feectools/api/fem_common.py,sha256=sIa6_66O95Gcuv41JMGp_K9pt7q_CxVzqlxIl-AjhjQ,10511
+feectools/api/fem_sum_form.py,sha256=y3BXSsJad4jX45y-G4jXuJ4kN4GAivV3nnOjoZ5V3Wk,4801
+feectools/api/settings.py,sha256=0oV7jm3MC6Cy2WR5AwC75VNSRIHyCKOCvJyyZZ1ZnaM,3442
+feectools/core/__init__.py,sha256=uqpuv7LH4TVhngaglUs4EVQ7ZaF74Utt7p0Yih8r3XI,219
+feectools/core/bsplines.py,sha256=3cg54HuHmWVI3eJClk8aGZLB9ZBPquovkxs_LW_F3_4,35848
+feectools/core/bsplines_kernels.py,sha256=sygGjBf4ZdjQLaO7r6pF50G_rq11fAbNXToD76fMRpg,41880
+feectools/core/field_evaluation_kernels.py,sha256=hGs40CHrtjEl12yPXjUf9CX38VhtgGyNtN7LxnueejE,213406
+feectools/core/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/core/tests/test_bsplines.py,sha256=prD8-uGuValM5dsKTPb_Wuu-w7RmgyiugN20AMqa5-I,9375
+feectools/core/tests/test_bsplines_kernel.py,sha256=gvoKizXtv-KV2q_8RX8sXWylltlKcx_PDlJwzXJ9WgE,1539
+feectools/core/tests/test_bsplines_pyccel.py,sha256=0PJkjzIKpm8aoZm0tuUAjcZTw66NK7JeMiAsWsEuqa0,33880
+feectools/ddm/__init__.py,sha256=g8T4cCNL0Stchi3l8QtQ5FnujdvgtfxXf1QhxatM_M4,51
+feectools/ddm/basic.py,sha256=73xhS9QPH6ks44ptGJ3lHrLQdWgzxMsSGH6bSFQC0Rw,2511
+feectools/ddm/blocking_data_exchanger.py,sha256=9gLIWM235QDcwwmqN4xPTtInldlP6I4Vu6kqZ-NLyeQ,13340
+feectools/ddm/cart.py,sha256=rZncdhodsknDL6Cau3p0OxobFCXqWbh8S0F7z7aSDp8,74291
+feectools/ddm/interface_data_exchanger.py,sha256=z-PQbao80S5BvEvku8vzZ464d9OBj7QCXsnvc0HJHjE,4801
+feectools/ddm/mpi.py,sha256=twmesoFC2FbdFM41ykAgyhk0xHufMwsHjuJ6iw49sSs,2236
+feectools/ddm/nonblocking_data_exchanger.py,sha256=RaLgxjscpa6-BSa2BbkRcUQInekzz4mVvQEJHpyKnKY,12939
+feectools/ddm/partition.py,sha256=uEa0t4HQs6QT9e6bqqIVyytsd_pq5_bzhUrhXx7FU-g,6594
+feectools/ddm/petsc.py,sha256=L30vNB5hfagIfR1MOTL4-ZkhdeayedJ1Wa8n5HrGsTE,3353
+feectools/ddm/utilities.py,sha256=_vDaAQDCamDfiKHZz_CkIhhqkxEOyBJ8JpVCZa9PjeU,1044
+feectools/ddm/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/ddm/tests/test_cart_1d.py,sha256=dBsiXaYpBr5J-eOvFJXIG6Jb3JPUWg9YUOClQMmEYBs,4694
+feectools/ddm/tests/test_cart_2d.py,sha256=0BRrxCELxMmXKPrYhUyusrRBpF6TVzTVAVF6PpRrpFc,5545
+feectools/ddm/tests/test_cart_3d.py,sha256=RP1rUmEoQ8wMWDA7nNAwV9q_v8efrVrd7L8DW4Pwckw,5601
+feectools/ddm/tests/test_multicart_2d.py,sha256=iwjguH7q7BZi_eXFH4kZ_G7g-VfAoKF8QavIG-sQXn0,7581
+feectools/ddm/tests/test_partition.py,sha256=vMEiko7Yhzkm21ZEBdGQNSlI9QevSpWzm2wQdDYYBuE,4015
+feectools/feec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/feec/derivatives.py,sha256=8zcxxVwyXewwNFXuVKfJVQFD89oj9g4ab0aJ0zs_gOM,29204
+feectools/feec/dof_kernels.py,sha256=ZyFG6x-coGq5iBnld82LAKPqH2HuCJUIzxi1EZzGTzA,8012
+feectools/feec/global_geometric_projectors.py,sha256=zm2PGdGYa8V5HNn3ButsYtpRRUXkCtwi4A6DUoIIKZo,44259
+feectools/feec/hodge.py,sha256=09bQ8ZtiGo6vQNp4W3oDdTKmw7HAOaON2tJNdMBpOa4,4693
+feectools/fem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/fem/basic.py,sha256=n1SArxFiS1od9i6GXvhDMozR5obJQO9APbXhYO9-Kqs,14020
+feectools/fem/grid.py,sha256=YmH8GElXxSU4G3O64tJZYAWKQ3aldK6vcmrbz_ngmFY,5428
+feectools/fem/partitioning.py,sha256=eA4XFEVU3m6GsVI0pBK8coaIwmh9eD_MpKq7fgum1sA,16363
+feectools/fem/projectors.py,sha256=DJ5bklXBdgzjBSXY5LFOtAab2YDQdbj3ovPjvfFyujA,5489
+feectools/fem/splines.py,sha256=-C4u3ZrdJttnNqi49COQPChbmUKjwhKu0FJt-9Sy1Pc,17847
+feectools/fem/tensor.py,sha256=vKLOFd1naEpTo2589ERC0ZvZ8mg13K_fcTCZ6A9ng1U,53123
+feectools/fem/vector.py,sha256=z3SfLu2cnb33m4y889AJCaZHBhWariw8yvvpvwWu5OY,28396
+feectools/fem/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/fem/tests/analytical_profiles_1d.py,sha256=6SqOasGUnjqKF0E4NqW6jBxVo1ZRqva5kSQkY_atcjA,2582
+feectools/fem/tests/analytical_profiles_base.py,sha256=Dg6az-vRu7YGVLpcRM6dMckYQanqTrcvTUsh4cLY1Ls,868
+feectools/fem/tests/splines_error_bounds.py,sha256=linE5oiSWTJMO5wHRORQrSyVBfRIX2Dw3Q1yQ-Hnevo,4862
+feectools/fem/tests/test_spline_histopolation.py,sha256=9Q9iTiuafFmEPCSUKXjuEOLqLYPYdv9CXDYJUvNi-Dw,4105
+feectools/fem/tests/test_spline_interpolation.py,sha256=RWeEZLjTSPwiJjF1KRjJbBTWJ605zqvBhwWMpqbr6xc,6585
+feectools/fem/tests/test_splines.py,sha256=0nM2kxerz0E8RBKb6uKgX9zo4CfR_InVhvPTRbNvjXg,4506
+feectools/fem/tests/test_splines_par.py,sha256=UYCylVICCGzB08ahBeTzb8gKJX1ZicUTYi-IFTkTjME,1299
+feectools/fem/tests/test_vector_spaces.py,sha256=3aL7pz2N8NEk3Ke4JSh8LRZ468wiWcTmJqCa9ZDeWXc,4646
+feectools/fem/tests/utilities.py,sha256=FfCGEouNSdKaUVP03YlZ3so3BvHo4DAQ4NGx15taVWA,1352
+feectools/linalg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/linalg/basic.py,sha256=NwVolrYCpQKMOWt1l_4hBce1tTBDZEt2J-04lWy33cI,43677
+feectools/linalg/block.py,sha256=Cgo82Tn9GFR4T4iSkPkM8vTUS-PjnPwyQmwWO8Q7qpk,53997
+feectools/linalg/direct_solvers.py,sha256=yvNS__UJwhfWsaX4dFGDbvK5cyZD9VMzce68ZboG6K4,6139
+feectools/linalg/fft.py,sha256=TNECOIDuZpjjRN2fX-WDbRfbPd6EgIi_SbOGcdgKV68,10348
+feectools/linalg/kron.py,sha256=zWoeoToryg2dJq1KTV9fdEmZ8U0pJrI95ibZ7dkY3C4,31348
+feectools/linalg/solvers.py,sha256=VqaVJadv_ALKIWwZQmFXAjF4D0ZlY_e4yu1Yo0J_sLM,62724
+feectools/linalg/sparse.py,sha256=sFdPYBjdHIe9-eGTr4GK8fPrcr-UAKd3tkk_Npqu2D0,3405
+feectools/linalg/stencil.py,sha256=KSAGVNo6Q2V5euEDBE_DRdhUhAOF8-UKwO1LIRLLUtQ,100798
+feectools/linalg/stencil_dot_kernels.py,sha256=Ti5GxyUUSgW43l3cxamJlTuIXUah-yV94TIV2ugrzrk,11882
+feectools/linalg/stencil_transpose_kernels.py,sha256=fvEw6dS-Lux9b3G-m83UGeXyS9xELpg0ErSy-NsSb_A,19270
+feectools/linalg/topetsc.py,sha256=3csnt1tG1_5CLk6XzhcZmewjoVQ40wz_UzxcWusDZXg,21159
+feectools/linalg/utilities.py,sha256=8CujOsy4-d0rWKiF8ARSIfeyK4QPSmuf3mnV3YxWCUY,8110
+feectools/linalg/kernels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/linalg/kernels/axpy_kernels.py,sha256=r42Ub2DDOLj-0D_wNnsm82w5xRO1mw5AdECDzMpMqXg,1587
+feectools/linalg/kernels/inner_kernels.py,sha256=QRIFtEFnlnAQ1nDmqVAOotfqzgFgHlqyvsc_KLbs0lo,2997
+feectools/linalg/kernels/matvec_kernels.py,sha256=ZO5AgDjdIQv1k71oYY072lRiSFefj3ZygZZbTN7fA_0,8352
+feectools/linalg/kernels/stencil2IJV_kernels.py,sha256=OAZc4X6MtJNJwrbwwrQcC2Co5Q3-jf7ixvsaT9Vigjw,8696
+feectools/linalg/kernels/stencil2coo_kernels.py,sha256=2WO8Hyj81-0BGSBFCEDfGw7oASCvkDfm5f8buQWyVow,7317
+feectools/linalg/kernels/transpose_kernels.py,sha256=R1mcqUA4fwH-s3MZD82KJGA9RyDzHOmFY0xRAxTUNPk,9875
+feectools/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/linalg/tests/test_block.py,sha256=iq8BVojGCE13iCF2rZOsphkecWQdNKCCrJX9TtBhnvc,53004
+feectools/linalg/tests/test_fft.py,sha256=pKATZEQyvd3DInJKB8C_Whq1xz1SxHfSxJefPFoZlCU,3868
+feectools/linalg/tests/test_kron_stencil_matrix.py,sha256=U7PQR25a__nKZDC9dmvQVriPVpabrVkA0r170A7BszU,3757
+feectools/linalg/tests/test_linalg.py,sha256=R88gKiFP2Ft8GQ1MCy3NtRiu1DQMpD746UX1ZrcMux8,35604
+feectools/linalg/tests/test_matrix_free.py,sha256=Cyxyhn5135pcxW88ytV26numIW8jG7sm6O08fOfKa7o,4258
+feectools/linalg/tests/test_solvers.py,sha256=uXPBugyGFQjyFlCdiPE5B2buVythdND9h1TYppnjzhA,7171
+feectools/linalg/tests/test_stencil_interface_matrix.py,sha256=_Y_aIxR0uYLlzjga3at-vMNMEv8r3kMVnRgGKNja7_c,15197
+feectools/linalg/tests/test_stencil_vector.py,sha256=77SUOGt-Wzx8yW413XNTxUVxsucBzWdMb9iPAb8Q0J0,36006
+feectools/linalg/tests/test_stencil_vector_space.py,sha256=xPn0prKDFM5OuIXk01kcBYQSoo79gLEsq4sG2cXlFCo,16412
+feectools/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feectools/utilities/quadratures.py,sha256=hm0k97MXHQBRrX3NtqX0p1tFQgvmaGeHLIcneirsmps,3074
+feectools/utilities/utils.py,sha256=vpuTk_mVtrqivIARxikj_9jLPz7VQCvQ9gy_k_Vh83I,5311
+feectools-0.1.0.dist-info/licenses/AUTHORS,sha256=5g5Pg9AjaumZrgaAXG3WdjKtxHaRuYTYaRPgv6fnUvA,516
+feectools-0.1.0.dist-info/licenses/LICENSE,sha256=E1UeOpPwmCqE57lN0WS24M0lYLNP3vi6dz41JlIZgBw,1081
+feectools-0.1.0.dist-info/METADATA,sha256=XjrUwIraAGGJprc3TyTHW0Zt9ykfcRlsg3FB0sadxVk,3203
+feectools-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+feectools-0.1.0.dist-info/entry_points.txt,sha256=OZEKfHA9qqruoFgVNXAeP_Oe-z4s26leAxUVuMBpv9A,113
+feectools-0.1.0.dist-info/top_level.txt,sha256=tS-3BbPTNpe3Nn0E5O6jOXPKqAyGw_v_AbGUaDM0pUs,10
+feectools-0.1.0.dist-info/RECORD,,

feectools-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

feectools-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+psydac-accelerate = feectools.accelerate.accelerate:main
+psydac-mesh = feectools.cmd.mesh:main