feectools 0.1.4__tar.gz → 0.1.5__tar.gz

{feectools-0.1.4 → feectools-0.1.5}/AUTHORS

@@ -2,21 +2,23 @@ Maintainers
 -----------
 * Yaman Güçlü <yaman.guclu@gmail.com> (original author, project lead)
 * Martin Campos Pinto <martin.campos-pinto@ipp.mpg.de>
-* Ahmed Ratnani <ratnaniahmed@gmail.com> (original author)
 
 Contributors
 ------------
+* Ahmed Ratnani (original author)
 * Said Hadjout (original author)
+* Jalal Lakhlili (original author)
+* Frederik Schnack
 * Julian Owezarek
+* Elena Moral Sánchez
 * Antoine Lavandier
 * Tom Caruso
-* Elena Moral Sánchez
 * Paul Rigor
-* Frederik Schnack
 * David Schneller
 * Valentin Carlier
 * Stefan Possanner
-* Jalal Lakhlili (original author)
-* William Barham
-* Max Lindqvist
 * Emily Bourne
+* Max Lindqvist
+* William Barham
+* Anushka Singh
+* Alisa Kirkinskaia

{feectools-0.1.4 → feectools-0.1.5}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2023, Psydac Developers.
+Copyright (c) 2018-2026, 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

{feectools-0.1.4/feectools.egg-info → feectools-0.1.5}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: feectools
-Version: 0.1.4
+Version: 0.1.5
 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.
+        Copyright (c) 2018-2026, 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

{feectools-0.1.4 → feectools-0.1.5}/README.md

@@ -6,4 +6,4 @@ 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.
+See the [Struphy documentation](https://struphy-hub.github.io/struphy/index.html) for details on how to use.

{feectools-0.1.4 → feectools-0.1.5}/feectools/core/bsplines.py

@@ -1,7 +1,8 @@
-# coding: utf-8
-#
-# Copyright 2018 Yaman Güçlü
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 """
 Basic module that provides the means for evaluating the B-Splines basis
 functions and their derivatives. In order to simplify automatic Fortran code

{feectools-0.1.4 → feectools-0.1.5}/feectools/core/bsplines_kernels.py

@@ -1,3 +1,9 @@
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
+
 # This file holds the pyccelisable versions of the functions in bsplines.py
 # This will be changed once pyccel can return arrays and can get out=None arguments
 # like Numpy functions.

{feectools-0.1.4 → feectools-0.1.5}/feectools/core/tests/test_bsplines.py

@@ -1,5 +1,8 @@
-#coding: utf-8
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import pytest
 import numpy as np
 

{feectools-0.1.4 → feectools-0.1.5}/feectools/core/tests/test_bsplines_pyccel.py

@@ -1,3 +1,8 @@
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import numpy as np
 import pytest
 

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/basic.py

@@ -1,7 +1,11 @@
-# coding: utf-8
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 from abc import ABC, abstractmethod
 
+
 __all__ = ('CartDataExchanger',)
 #===============================================================================
 class CartDataExchanger(ABC):

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/blocking_data_exchanger.py

@@ -1,11 +1,15 @@
-# coding: utf-8
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import numpy as np
 from feectools.ddm.mpi import mpi as MPI
 
 from .cart import CartDecomposition, find_mpi_type
 from .basic import CartDataExchanger
 
+
 __all__ = ('BlockingCartDataExchanger',)
 
 class BlockingCartDataExchanger(CartDataExchanger):

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/partition.py

@@ -1,8 +1,14 @@
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import numpy    as np
 import numpy.ma as ma
 
 from sympy.ntheory import factorint
 
+
 __all__ = ('compute_dims', 'partition_procs_per_patch')
 
 #==============================================================================

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/petsc.py

@@ -1,7 +1,11 @@
-# coding: utf-8
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
+from itertools import product
 
 import numpy as np
-from itertools import product
 
 from .cart import CartDecomposition
 

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/tests/test_cart_1d.py

@@ -1,5 +1,8 @@
-# Contents of test_cart_1d.py
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import numpy as np
 
 from feectools.ddm.blocking_data_exchanger    import BlockingCartDataExchanger
@@ -111,7 +114,7 @@ def run_cart_1d( data_exchanger_type, verbose=False ):
 import pytest
 
 @pytest.mark.parametrize( 'data_exchanger_type', [BlockingCartDataExchanger, NonBlockingCartDataExchanger] )
-@pytest.mark.parallel
+@pytest.mark.mpi
 def test_cart_1d( data_exchanger_type ):
 
     namespace = run_cart_1d( data_exchanger_type )

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/tests/test_multicart_2d.py

@@ -1,4 +1,8 @@
-# File test_multicart_2d.py
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 
 #===============================================================================
 # TEST MultiCartDecomposition in 2D

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/tests/test_partition.py

@@ -1,3 +1,8 @@
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import pytest
 
 from feectools.ddm.partition import compute_dims
@@ -119,6 +124,3 @@ if __name__ == '__main__':
     # test_partition_2d_dims_mask(10, [58, 64], [True, False])
     
     test_partition_3d_dims_mask(10, [32, 64, 128], [True, False, True])
-
-
-

{feectools-0.1.4 → feectools-0.1.5}/feectools/ddm/utilities.py

@@ -1,10 +1,14 @@
-# coding: utf-8
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 from .cart                       import CartDecomposition, InterfaceCartDecomposition
 from .blocking_data_exchanger    import BlockingCartDataExchanger
 from .nonblocking_data_exchanger import NonBlockingCartDataExchanger
 from .interface_data_exchanger   import InterfaceCartDataExchanger
 
+
 __all__ = ('get_data_exchanger',)
 
 def get_data_exchanger(cart, dtype, *, coeff_shape=(),  assembly=False, axis=None, shape=None, blocking=True):

{feectools-0.1.4 → feectools-0.1.5}/feectools/fem/grid.py

@@ -1,7 +1,8 @@
-# coding: utf-8
-#
-# Copyright 2018 Yaman Güçlü
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import numpy as np
 
 from feectools.core.bsplines         import elements_spans

feectools-0.1.5/feectools/fem/lst_preconditioner.py

@@ -0,0 +1,292 @@
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
+from   functools                    import lru_cache
+from   scipy.sparse                 import dia_matrix
+import numpy as np
+
+from   sympde.topology              import elements_of, Line, ScalarFunctionSpace
+from   sympde.topology.datatype     import SpaceType
+from   sympde.expr                  import integral, BilinearForm
+
+from   psydac.linalg.basic          import IdentityOperator, LinearOperator
+from   psydac.linalg.block          import BlockVectorSpace, BlockLinearOperator
+from   psydac.linalg.direct_solvers import BandedSolver
+from   psydac.linalg.kron           import KroneckerLinearSolver, KroneckerStencilMatrix
+from   psydac.linalg.stencil        import StencilVectorSpace
+from   psydac.fem.projectors        import DirichletProjector
+
+
+@lru_cache
+def construct_LST_preconditioner(M, domain_h, fem_space, hom_bc=False, kind=None):
+    """
+    LST (Loli, Sangalli, Tani) preconditioners [1] are mass matrix preconditioners of the form
+    pc = D_inv_sqrt @ D_log_sqrt @ M_log_kron_solver @ D_log_sqrt @ D_inv_sqrt, where
+
+    D_inv_sqrt          is the diagonal matrix of the square roots of the inverse diagonal entries of the mass matrix M,
+    D_log_sqrt          is the diagonal matrix of the square roots of the diagonal entries of the mass matrix on the logical domain,
+    M_log_kron_solver   is the Kronecker Solver of the mass matrix on the logical domain.
+
+    These preconditioners work very well even on complex domains as numerical experiments have shown.
+    Upon choosing hom_bc=True, a preconditioner for the modified mass matrix M_0 is returned.
+    M_0 is a mass matrix of the form
+    M_0 = DP @ M @ DP + (I - DP)
+    where DP and I are the corresponding DirichletProjector and IdentityOperator.
+    See examples/vector_potential_3d.
+
+    Parameters
+    ----------
+    M : psydac.linalg.stencil.StencilMatrix | psydac.linalg.block.BlockLinearOperator
+        Mass matrix corresponding to fem_space
+
+    domain_h : psydac.cad.geometry.Geometry
+        discretized physical domain used to discretize fem_space
+
+    fem_space : psydac.fem.basic.FemSpace
+        discretized Scalar- or VectorFunctionSpace. M is the corresponding mass matrix
+
+    hom_bc : bool
+        If True, return LST preconditioner for modified M_0 = DP @ M @ DP + (I - DP) mass matrix.
+        The argument M in that case remains the same (M, not M_0). DP and I are DirichletProjector and IdentityOperator.
+        Default: False.
+
+    kind : str | None
+        Optional. Must be passed if fem_space has no kind. Must match the kind of fem_space if fem_space has a kind.
+        Relevant as we must know whether M is a H1, Hcurl, Hdiv or L2 mass matrix.
+
+    Returns
+    -------
+    psydac.linalg.stencil.StencilMatrix | psydac.linalg.block.BlockLinearOperator
+        LST preconditioner for M (hom_bc=False) or M_0 (hom_b=True).
+
+    References
+    ----------
+    [1] Gabriele Loli, Giancarlo Sangalli, Mattia Tani. “Easy and efficient preconditioning of the isogeometric mass 
+        matrix”. In: Computers & Mathematics with Applications 116 (2022), pp. 245–264
+    """
+
+    # to avoid circular import
+    from psydac.api.discretization                   import discretize
+
+    dim = fem_space.ldim
+    # In 1D one can solve the linear system directly (instead of using this preconditioner)
+    assert dim in (2, 3)
+
+    if hom_bc == True:
+        def toarray_1d(A):
+            """
+            Obtain a numpy array representation of a (1D) LinearOperator (which has not implemented toarray()).
+            
+            We fill an empty numpy array row by row by repeatedly applying unit vectors
+            to the transpose of A. In order to obtain those unit vectors in Stencil format,
+            we make use of an auxiliary function that takes periodicity into account.
+            """
+            
+            assert isinstance(A, LinearOperator)
+            W = A.codomain
+            assert isinstance(W, StencilVectorSpace)
+
+            def get_unit_vector_1d(v, periodic, n1, npts1, pads1):
+
+                v *= 0.0
+                v._data[pads1+n1] = 1.
+
+                if periodic:
+                    if n1 < pads1:
+                        v._data[-pads1+n1] = 1.
+                    if n1 >= npts1-pads1:
+                        v._data[n1-npts1+pads1] = 1.
+                
+                return v
+
+            periods  = W.periods
+            periodic = periods[0]
+
+            w = W.zeros()
+            At = A.T
+
+            A_arr = np.zeros(A.shape, dtype=A.dtype)
+
+            npts1,  = W.npts
+            pads1,  = W.pads
+            for n1 in range(npts1):
+                e_n1 = get_unit_vector_1d(w, periodic, n1, npts1, pads1)
+                A_n1 = At @ e_n1
+                A_arr[n1, :] = A_n1.toarray()
+
+            return A_arr
+
+        def M_0_1d_to_bandsolver(A):
+            """
+            Converts the M0_0_1d StencilMatrix to a BandedSolver.
+
+            Closely resembles BandedSolver.from_stencil_mat_1d,
+            the difference being that M0_0_1d neither has a 
+            remove_spurious_entries() nor a toarray() function.
+            
+            """
+
+            dmat = dia_matrix(toarray_1d(A), dtype=A.dtype)
+            la   = abs(dmat.offsets.min())
+            ua   = dmat.offsets.max()
+            cmat = dmat.tocsr()
+
+            A_bnd = np.zeros((1+ua+2*la, cmat.shape[1]), A.dtype)
+
+            for i,j in zip(*cmat.nonzero()):
+                A_bnd[la+ua+i-j, j] = cmat[i,j]
+
+            return BandedSolver(ua, la, A_bnd)
+
+    domain      = domain_h.domain
+
+    ncells,     = domain_h.ncells.values()
+    degree      = fem_space.degree
+    periodic,   = domain_h.periodic.values()
+
+    V_cs        = fem_space.coeff_space
+    
+    logical_domain      = domain.logical_domain
+
+    # ----- Compute D_inv_sqrt
+
+    D_inv_sqrt = M.diagonal(inverse=True, sqrt=True)
+
+    # ----- Compute M_log_kron_solver
+
+    logical_domain_1d_x = Line('L', bounds=logical_domain.bounds1)
+    logical_domain_1d_y = Line('L', bounds=logical_domain.bounds2)
+    if dim == 3:
+        logical_domain_1d_z = Line('L', bounds=logical_domain.bounds3)
+
+    logical_domain_1d_list = [logical_domain_1d_x, logical_domain_1d_y]
+    if dim == 3:
+        logical_domain_1d_list += [logical_domain_1d_z]
+
+    # We gather the 1D mass matrices.
+    # Those will be used to obtain D_log_sqrt using the new
+    # diagonal function for KroneckerStencilMatrices.
+    M_1d_solvers = [[],[]]
+    Ms_1d        = [[],[]]
+    if dim == 3:
+        M_1d_solvers += [[]]
+        Ms_1d        += [[]]
+
+    # Mark 1D 'h1' spaces built using B-splines. 
+    # 1D spaces for which (i, j) \notin keys are 'l2' spaces built using M-splines.
+    fem_space_kind = fem_space.symbolic_space.kind.name
+
+    if kind is not None:
+        if isinstance(kind, str):
+            kind = kind.lower()
+            assert(kind in ['h1', 'hcurl', 'hdiv', 'l2'])
+        elif isinstance(kind, SpaceType):
+            kind = kind.name
+        else:
+            raise TypeError(f'Expecting kind {kind} to be a str or of SpaceType')
+        
+        # If fem_space has a kind, it must be compatible with kind
+        if fem_space_kind != 'undefined':
+            assert fem_space_kind == kind, f'fem_space and space_kind are not compatible.'
+    else:
+        kind = fem_space_kind
+
+    if kind == 'h1':
+        keys = ((0, 0), (1, 0), (2, 0))
+    elif kind == 'hcurl':
+        keys = ((0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1))
+    elif kind == 'hdiv':
+        keys = ((0, 0), (1, 1), (2, 2))
+    elif kind == 'l2':
+        keys = ()
+    else:
+        raise ValueError(f'kind {kind} must be either h1, hcurl, hdiv or l2.')
+
+    for i, (ncells_1d, periodic_1d, logical_domain_1d) in enumerate(zip(ncells, periodic, logical_domain_1d_list)):
+
+        logical_domain_1d_h = discretize(logical_domain_1d, ncells=[ncells_1d, ], periodic=[periodic_1d, ])
+
+        degrees_1d = [degree_dir[i] for degree_dir in degree] if isinstance(fem_space.coeff_space, BlockVectorSpace) else [degree[i], ]
+
+        for j, d in enumerate(degrees_1d):
+
+            kind_1d = 'h1' if (i, j) in keys else 'l2'
+            basis   = 'B'  if (i, j) in keys else 'M'
+
+            if basis == 'M':
+                d += 1
+
+            V_1d    = ScalarFunctionSpace('V', logical_domain_1d,        kind =kind_1d)
+            Vh_1d   = discretize(V_1d, logical_domain_1d_h, degree=[d,], basis=basis)
+
+            u, v    = elements_of(V_1d, names='u, v')
+            a_1d    = BilinearForm((u, v), integral(logical_domain_1d, u*v))
+            ah_1d   = discretize(a_1d, logical_domain_1d_h, (Vh_1d, Vh_1d))
+            M_1d    = ah_1d.assemble()
+            Ms_1d[j].append(M_1d)
+
+            if (hom_bc == True) and ((i, j) in keys):
+                DP = DirichletProjector(Vh_1d, space_kind='h1')
+                if DP.bcs != ():
+                    I      = IdentityOperator(Vh_1d.coeff_space)
+                    M_0_1d = DP @ M_1d @ DP + (I - DP)
+
+                    M_0_1d_solver = M_0_1d_to_bandsolver(M_0_1d)
+                    M_1d_solvers[j].append(M_0_1d_solver)
+                else:
+                    M_1d_solver = BandedSolver.from_stencil_mat_1d(M_1d)
+                    M_1d_solvers[j].append(M_1d_solver)
+            else:
+                M_1d_solver = BandedSolver.from_stencil_mat_1d(M_1d)
+                M_1d_solvers[j].append(M_1d_solver)
+
+    if isinstance(V_cs, StencilVectorSpace):
+        M_log_kron_solver       = KroneckerLinearSolver(V_cs, V_cs, M_1d_solvers[0])
+
+    else:
+        M_0_log_kron_solver     = KroneckerLinearSolver(V_cs[0], V_cs[0], M_1d_solvers[0])
+        M_1_log_kron_solver     = KroneckerLinearSolver(V_cs[1], V_cs[1], M_1d_solvers[1])
+        if dim == 3:
+            M_2_log_kron_solver = KroneckerLinearSolver(V_cs[2], V_cs[2], M_1d_solvers[2])
+
+        if dim == 2:
+            blocks = [[M_0_log_kron_solver, None],
+                      [None, M_1_log_kron_solver]]
+        else:
+            blocks = [[M_0_log_kron_solver, None, None],
+                      [None, M_1_log_kron_solver, None],
+                      [None, None, M_2_log_kron_solver]]
+        
+        M_log_kron_solver       = BlockLinearOperator  (V_cs, V_cs, blocks)
+
+    # ----- Compute D_log_sqrt
+
+    if isinstance(V_cs, StencilVectorSpace):
+        M_log            = KroneckerStencilMatrix(V_cs, V_cs, *Ms_1d[0])
+
+        D_log_sqrt       = M_log.diagonal  (inverse=False, sqrt=True)
+
+    else:
+        M_0_log          = KroneckerStencilMatrix(V_cs[0], V_cs[0], *Ms_1d[0])
+        M_1_log          = KroneckerStencilMatrix(V_cs[1], V_cs[1], *Ms_1d[1])
+        if dim == 3:
+            M_2_log      = KroneckerStencilMatrix(V_cs[2], V_cs[2], *Ms_1d[2])
+
+        if dim == 2:
+            blocks  = [[M_0_log, None],
+                      [None, M_1_log]]
+        else:
+            blocks = [[M_0_log, None, None],
+                      [None, M_1_log, None],
+                      [None, None, M_2_log]]
+            
+        M_log = BlockLinearOperator(V_cs, V_cs, blocks=blocks)
+        D_log_sqrt = M_log.diagonal(inverse=False, sqrt=True)
+
+    # --------------------------------
+
+    M_pc = D_inv_sqrt @ D_log_sqrt @ M_log_kron_solver @ D_log_sqrt @ D_inv_sqrt
+
+    return M_pc

{feectools-0.1.4 → feectools-0.1.5}/feectools/fem/tests/analytical_profiles_1d.py

@@ -1,13 +1,15 @@
-# coding: utf-8
-# Copyright 2018 Yaman Güçlü
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 import math
 import numpy as np
 
 from feectools.fem.tests.analytical_profiles_base import AnalyticalProfile
 from feectools.fem.tests.utilities                import horner, falling_factorial
 
-__all__ = ('AnalyticalProfile_1d_cos', 'AnalyticalProfile1D_Poly')
+__all__ = ('AnalyticalProfile1D_Cos', 'AnalyticalProfile1D_Poly')
 
 #===============================================================================
 class AnalyticalProfile1D_Cos( AnalyticalProfile ):

{feectools-0.1.4 → feectools-0.1.5}/feectools/fem/tests/analytical_profiles_base.py

@@ -1,6 +1,8 @@
-# coding: utf-8
-# Copyright 2018 Yaman Güçlü
-
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
 from abc import ABCMeta, abstractmethod
 
 __all__ = ('AnalyticalProfile',)

{feectools-0.1.4 → feectools-0.1.5}/feectools/fem/tests/splines_error_bounds.py

@@ -1,6 +1,9 @@
-# coding: utf-8
-# Copyright 2018 Yaman Güçlü
-#
+#---------------------------------------------------------------------------#
+# This file is part of PSYDAC which is released under MIT License. See the  #
+# LICENSE file or go to https://github.com/pyccel/psydac/blob/devel/LICENSE #
+# for full license details.                                                 #
+#---------------------------------------------------------------------------#
+
 # This file is the Python translation of a Selalib Fortran module:
 # 'selalib/src/splines/tests/m_splines_error_bounds.F90'