struphy 2.1.1__tar.gz → 2.3.0__tar.gz

{struphy-2.1.1 → struphy-2.3.0}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2019-2023, Struphy developers, Max Planck Institute for Plasma Physics
+Copyright (c) 2019-2024, Struphy developers, Max Planck Institute for Plasma Physics
 
 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, 

{struphy-2.1.1/src/struphy.egg-info → struphy-2.3.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: struphy
-Version: 2.1.1
+Version: 2.3.0
 Summary: Multi-model plasma physics package
 Author: Max Planck Institute for Plasma Physics
 Author-email: stefan.possanner@ipp.mpg.de, eric.sonnendruecker@ipp.mpg.de
-License: Copyright (c) 2019-2023, Struphy developers, Max Planck Institute for Plasma Physics
+License: Copyright (c) 2019-2024, Struphy developers, Max Planck Institute for Plasma Physics
         
         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, 
@@ -30,30 +30,32 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: <3.12,>=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: mpi4py
-Requires-Dist: h5py
-Requires-Dist: matplotlib
-Requires-Dist: PyYAML
-Requires-Dist: vtk
-Requires-Dist: pytest
-Requires-Dist: pytest-mpi
-Requires-Dist: sphinx
-Requires-Dist: sphinxcontrib-napoleon
-Requires-Dist: pydata-sphinx-theme
-Requires-Dist: nbsphinx
-Requires-Dist: notebook
-Requires-Dist: m2r2
-Requires-Dist: mistune
-Requires-Dist: docutils
-Requires-Dist: wheel
-Requires-Dist: tqdm
-Requires-Dist: argcomplete
-Requires-Dist: ipyparallel
-Requires-Dist: pytest-monitor
-Requires-Dist: pyccel>=1.10.0
-Requires-Dist: gvec-to-python
+Requires-Dist: PyYAML==6.0.1
+Requires-Dist: argcomplete==3.2.3
+Requires-Dist: docutils==0.20.1
+Requires-Dist: gvec-to-python==1.2.1
+Requires-Dist: h5py==3.10.0
+Requires-Dist: ipyparallel==8.7.0
+Requires-Dist: lxml_html_clean==0.1.0
+Requires-Dist: m2r2==0.3.3.post2
+Requires-Dist: matplotlib==3.8.3
+Requires-Dist: mistune==0.8.4
+Requires-Dist: mpi4py==3.1.5
+Requires-Dist: myst-parser==2.0.0
+Requires-Dist: nbsphinx==0.9.3
+Requires-Dist: notebook==7.1.2
+Requires-Dist: numpy==1.24.4
+Requires-Dist: pyccel==1.11.2
+Requires-Dist: pydata-sphinx-theme==0.15.2
+Requires-Dist: pytest==8.1.1
+Requires-Dist: pytest-monitor==1.6.6
+Requires-Dist: pytest-mpi==0.6
+Requires-Dist: scipy==1.12.0
+Requires-Dist: Sphinx==7.2.6
+Requires-Dist: sphinxcontrib-napoleon==0.7
+Requires-Dist: tqdm==4.66.2
+Requires-Dist: vtk==9.3.0
+Requires-Dist: wheel==0.43.0
 
 # Struphy - Structure-preserving hybrid codes
 

{struphy-2.1.1 → struphy-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "struphy"
-version = "2.1.1"
+version = "2.3.0"
 readme = "README.md"
 requires-python = ">=3.7, <3.12"
 license = {file = "LICENSE"}
@@ -19,30 +19,32 @@ classifiers = [
     "Programming Language :: Python :: 3",
     ]
 dependencies = [
-    'numpy',
-    'scipy',
-    'mpi4py',
-    'h5py',
-    'matplotlib',
-    'PyYAML',
-    'vtk',
-    'pytest',
-    'pytest-mpi',
-    'sphinx',
-    'sphinxcontrib-napoleon',
-    'pydata-sphinx-theme',
-    'nbsphinx',
-    'notebook',
-    'm2r2',
-    'mistune',
-    'docutils',
-    'wheel',
-    'tqdm',
-    'argcomplete',
-    'ipyparallel',
-    'pytest-monitor',
-    'pyccel>=1.10.0',
-    'gvec-to-python',
+    'PyYAML==6.0.1',
+    'argcomplete==3.2.3',
+    'docutils==0.20.1',
+    'gvec-to-python==1.2.1',
+    'h5py==3.10.0',
+    'ipyparallel==8.7.0',
+    'lxml_html_clean==0.1.0',
+    'm2r2==0.3.3.post2',
+    'matplotlib==3.8.3',
+    'mistune==0.8.4',
+    'mpi4py==3.1.5',
+    'myst-parser==2.0.0',
+    'nbsphinx==0.9.3',
+    'notebook==7.1.2',
+    'numpy==1.24.4',
+    'pyccel==1.11.2',
+    'pydata-sphinx-theme==0.15.2',
+    'pytest==8.1.1',
+    'pytest-monitor==1.6.6',
+    'pytest-mpi==0.6',
+    'scipy==1.12.0',
+    'Sphinx==7.2.6',
+    'sphinxcontrib-napoleon==0.7',
+    'tqdm==4.66.2',
+    'vtk==9.3.0',
+    'wheel==0.43.0',
 ]
 
 [project.urls]
@@ -78,5 +80,5 @@ struphy = "struphy.console.main:struphy"
                     ]
                     
 struphy = ['compile_struphy.mk',
-           'psydac-0.1.7-py3-none-any.whl',
+           'psydac-0.1.12-py3-none-any.whl',
            ]

{struphy-2.1.1 → struphy-2.3.0}/src/struphy/bsplines/bsplines.py

@@ -373,7 +373,7 @@ def collocation_matrix(knots, degree, xgrid, periodic, normalize=False):
 # ==============================================================================
 def histopolation_matrix(knots, degree, xgrid, periodic):
     """
-    Computes the histopolation matrix $H_ij = int_x_i^x_{i+1} D_j(x) dx$ of the M_splines.
+    Computes the histopolation matrix $H_ij = int_{x_i}^x_{i+1} D_j(x) dx$ of the M_splines.
 
     Parameters
     ----------

{struphy-2.1.1 → struphy-2.3.0}/src/struphy/bsplines/bsplines_kernels.py

@@ -56,7 +56,6 @@ def find_span(t: 'float[:]', p: 'int', eta: 'float') -> 'int':
 
     # Knot index at left/right boundary
     low = p
-    high = 0
     high = len(t) - 1 - p
 
     # Check if point is exactly on left/right boundary, or outside domain

{struphy-2.1.1 → struphy-2.3.0}/src/struphy/bsplines/evaluation_kernels_1d.py

@@ -124,7 +124,7 @@ def evaluate(kind1: int, t1: 'float[:]', p1: int, ind1: 'int[:,:]', coeff: 'floa
 @pure
 def evaluate_vector(t1: 'float[:]', p1: int, ind1: 'int[:,:]', coeff: 'float[:]', eta1: 'float[:]', spline_values: 'float[:]', kind: int):
     """
-    Vector evaluation of a tensor-product spline. 
+    Vector evaluation of a uni-variate spline. 
 
     Parameters
     ----------

{struphy-2.1.1 → struphy-2.3.0}/src/struphy/bsplines/evaluation_kernels_3d.py

@@ -24,10 +24,12 @@ from numpy import empty, zeros
 
 import struphy.bsplines.bsplines_kernels as bsplines_kernels
 
-
+#################################
+### Single process evaluation ###
+#################################
 def evaluation_kernel_3d(p1: int, p2: int, p3: int, basis1: 'float[:]', basis2: 'float[:]', basis3: 'float[:]', ind1: 'int[:]', ind2: 'int[:]', ind3: 'int[:]', coeff: 'float[:,:,:]') -> float:
     """
-    Summing non-zero contributions of a spline function.
+    Summing non-zero contributions of a spline function (serial, needs global arrays).
 
     Parameters
     ----------
@@ -64,10 +66,10 @@ def evaluation_kernel_3d(p1: int, p2: int, p3: int, basis1: 'float[:]', basis2:
     return spline_value
 
 
-@stack_array('tmp1', 'tmp2', 'tmp3')
+@stack_array('b1', 'b2', 'b3', 'bl1', 'bl2', 'bl3', 'br1', 'br2', 'br3', 'tmp1', 'tmp2', 'tmp3')
 def evaluate_3d(kind1: int, kind2: int, kind3: int, t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int, p2: int, p3: int, ind1: 'int[:,:]', ind2: 'int[:,:]', ind3: 'int[:,:]', coeff: 'float[:,:,:]', eta1: float, eta2: float, eta3: float) -> float:
     """
-    Point-wise evaluation of a tensor-product spline. 
+    Point-wise evaluation of a tensor-product spline (serial, needs global arrays). 
 
     Parameters
     ----------
@@ -156,7 +158,7 @@ def evaluate_3d(kind1: int, kind2: int, kind3: int, t1: 'float[:]', t2: 'float[:
 
 def evaluate_tensor_product(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int, p2: int, p3: int, ind1: 'int[:,:]', ind2: 'int[:,:]', ind3: 'int[:,:]', coeff: 'float[:,:,:]', eta1: 'float[:]', eta2: 'float[:]', eta3: 'float[:]', spline_values: 'float[:,:,:]', kind: int):
     """
-    Tensor-product evaluation of a tensor-product spline. 
+    Tensor-product evaluation of a tensor-product spline (serial, needs global arrays). 
 
     Parameters
     ----------
@@ -234,7 +236,7 @@ def evaluate_tensor_product(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1:
 
 def evaluate_matrix(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int,  p2: int, p3: int, ind1: 'int[:,:]', ind2: 'int[:,:]', ind3: 'int[:,:]', coeff: 'float[:,:,:]', eta1: 'float[:,:,:]', eta2: 'float[:,:,:]', eta3: 'float[:,:,:]', spline_values: 'float[:,:,:]', kind: int):
     """
-    General evaluation of a tensor-product spline. 
+    General evaluation of a tensor-product spline (serial, needs global arrays). 
 
     Parameters
     ----------
@@ -318,7 +320,7 @@ def evaluate_matrix(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int,  p2
 
 def evaluate_sparse(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int, p2: int, p3: int, ind1: 'int[:,:]', ind2: 'int[:,:]', ind3: 'int[:,:]', coeff: 'float[:,:,:]', eta1: 'float[:,:,:]', eta2: 'float[:,:,:]', eta3: 'float[:,:,:]', spline_values: 'float[:,:,:]', kind: int):
     """
-    Evaluation of a tensor-product spline using sparse meshgrids. 
+    Evaluation of a tensor-product spline using sparse meshgrids (serial, needs global arrays). 
 
     Parameters
     ----------
@@ -399,10 +401,12 @@ def evaluate_sparse(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int, p2:
                     spline_values[i1, i2, i3] = evaluate_3d(
                         1, 1, 3, t1, t2, t3, p1, p2, p3, ind1, ind2, ind3, coeff, eta1[i1, 0, 0], eta2[0, i2, 0], eta3[0, 0, i3])
 
-
+##############################
+### Distributed evaluation ###
+##############################
 def eval_spline_mpi_kernel(p1: 'int', p2: 'int', p3: 'int', basis1: 'float[:]', basis2: 'float[:]', basis3: 'float[:]', span1: 'int', span2: 'int', span3: 'int', _data: 'float[:,:,:]', starts: 'int[:]') -> float:
     """
-    Kernel for struphy.feec.basics.spline_evaluation_3d.eval_spline_mpi.
+    Summing non-zero contributions of a spline function with distributed memory (domain decomposition).
 
     Parameters
     ----------
@@ -444,7 +448,7 @@ def eval_spline_mpi_kernel(p1: 'int', p2: 'int', p3: 'int', basis1: 'float[:]',
 
 def eval_spline_derivative_mpi_kernel(p1: 'int', p2: 'int', p3: 'int', basis1: 'float[:]', basis2: 'float[:]', basis3: 'float[:]', span1: 'int', span2: 'int', span3: 'int', _data: 'float[:,:,:]', starts: 'int[:]', direction: 'int') -> float:
     """
-    Kernel for the derivative of a spline in one direction (distributed).
+    Kernel for the derivative of a spline in one direction (distributed, domain decomp.).
 
     Parameters
     ----------
@@ -507,6 +511,7 @@ def eval_spline_derivative_mpi_kernel(p1: 'int', p2: 'int', p3: 'int', basis1: '
     return spline_value
 
 
+@stack_array('bn1', 'bn2', 'bn3', 'bd1', 'bd2', 'bd3')
 def eval_spline_mpi(eta1: float, eta2: float, eta3: float,
                     _data: 'float[:,:,:]', kind: 'int[:]',
                     pn: 'int[:]', tn1: 'float[:]', tn2: 'float[:]', tn3: 'float[:]',
@@ -590,7 +595,7 @@ def eval_spline_mpi_tensor_product(eta1: 'float[:]', eta2: 'float[:]', eta3: 'fl
     ----------
         eta1, eta2, eta3 : array[float]              
             Evaluation points as 1d arrays; points not on local process domain must be flagged as -1.
-            Spline values are obtained as S_ijk = S(eta1[i], eta2[j], eta3[k]).
+            The out array is global and contains the spline values as S_ijk = S(eta1[i], eta2[j], eta3[k]).
 
         _data : array[float]
             The spline coefficients c_ijk. 
@@ -625,6 +630,153 @@ def eval_spline_mpi_tensor_product(eta1: 'float[:]', eta2: 'float[:]', eta3: 'fl
                     eta1[i], eta2[j], eta3[k], _data, kind, pn, tn1, tn2, tn3, starts)
 
 
+@stack_array('bn1', 'bn2', 'bn3', 'bd1', 'bd2', 'bd3')
+def eval_spline_mpi_tensor_product_fast(eta1: 'float[:]', eta2: 'float[:]', eta3: 'float[:]',
+                                        _data: 'float[:,:,:]', kind: 'int[:]',
+                                        pn: 'int[:]', tn1: 'float[:]', tn2: 'float[:]', tn3: 'float[:]',
+                                        starts: 'int[:]', values: 'float[:,:,:]'):
+    """
+    Tensor-product evaluation of a tensor-product spline, distributed, 
+    and optimized by computing spans and spline values only once. 
+
+    Parameters
+    ----------
+        eta1, eta2, eta3 : array[float]              
+            Evaluation points as 1d arrays; points not on local process domain must be flagged as -1.
+            Spline values are obtained as S_ijk = S(eta1[i], eta2[j], eta3[k]).
+
+        _data : array[float]
+            The spline coefficients c_ijk. 
+
+        kind : array[int]
+            Kind of 1d basis in each direction: 0 = N-spline, 1 = D-spline.
+
+        pn : array[int]
+            Spline degrees of V0 in each direction.
+
+        tn1, tn2, tn3 : array[float]
+            Knot vectors of V0 in each direction.
+
+        starts : array[float]
+            Start indices of splines on current process.
+
+        values : array[float]
+            Return array for spline values S_ijk = S(eta1[i], eta2[j], eta3[k]).
+    """
+    # allocate spline values
+    bn1 = empty(pn[0] + 1, dtype=float)
+    bn2 = empty(pn[1] + 1, dtype=float)
+    bn3 = empty(pn[2] + 1, dtype=float)
+
+    bd1 = empty(pn[0], dtype=float)
+    bd2 = empty(pn[1], dtype=float)
+    bd3 = empty(pn[2], dtype=float)
+
+    for i in range(len(eta1)):
+        if eta1[i] == -1.:
+            continue  # point not in process domain
+
+        span1 = bsplines_kernels.find_span(tn1, pn[0], eta1[i])
+        bsplines_kernels.b_d_splines_slim(tn1, pn[0], eta1[i], span1, bn1, bd1)
+        if kind[0] == 0:
+            b1 = bn1
+        else:
+            b1 = bd1
+
+        for j in range(len(eta2)):
+            if eta2[j] == -1.:
+                continue  # point not in process domain
+
+            span2 = bsplines_kernels.find_span(tn2, pn[1], eta2[j])
+            bsplines_kernels.b_d_splines_slim(
+                tn2, pn[1], eta2[j], span2, bn2, bd2)
+            if kind[1] == 0:
+                b2 = bn2
+            else:
+                b2 = bd2
+
+            for k in range(len(eta3)):
+                if eta3[k] == -1.:
+                    continue  # point not in process domain
+
+                span3 = bsplines_kernels.find_span(tn3, pn[2], eta3[k])
+                bsplines_kernels.b_d_splines_slim(
+                    tn3, pn[2], eta3[k], span3, bn3, bd3)
+                if kind[2] == 0:
+                    b3 = bn3
+                else:
+                    b3 = bd3
+
+                values[i, j, k] = eval_spline_mpi_kernel(pn[0] - kind[0],
+                                                         pn[1] - kind[1],
+                                                         pn[2] - kind[2],
+                                                         b1, b2, b3,
+                                                         span1, span2, span3,
+                                                         _data,
+                                                         starts)
+
+
+@stack_array('b1', 'b2', 'b3')
+def eval_spline_mpi_tensor_product_fixed(span1s: 'int[:]', span2s: 'int[:]', span3s: 'int[:]',
+                                         b1s: 'float[:,:]', b2s: 'float[:,:]', b3s: 'float[:,:]',
+                                         _data: 'float[:,:,:]', kind: 'int[:]', pn: 'int[:]',
+                                         starts: 'int[:]', values: 'float[:,:,:]'):
+    """
+    Tensor-product evaluation of a tensor-product spline, distributed, 
+    and optimized for a fixed grid (spans and spline values have been pre-evaluated). 
+
+    Parameters
+    ----------
+        span1s, span2s, span3s : array[int]              
+            Knot span indices.
+
+        b1s, b2s, b3s : array[float]
+            Values of p+1 non-zero basis functions at evaluation points.
+
+        _data : array[float]
+            The spline coefficients c_ijk. 
+
+        kind : array[int]
+            Kind of 1d basis in each direction: 0 = N-spline, 1 = D-spline.
+
+        pn : array[int]
+            Spline degrees of V0 in each direction.
+
+        starts : array[float]
+            Start indices of splines on current process.
+
+        values : array[float]
+            Return array for spline values S_ijk where ijk are the flattened indices corresponding to spans.
+    """
+
+    # allocate spline values
+    b1 = empty(pn[0] - kind[0] + 1, dtype=float)
+    b2 = empty(pn[1] - kind[1] + 1, dtype=float)
+    b3 = empty(pn[2] - kind[2] + 1, dtype=float)
+
+    ni = span1s.size
+    nj = span2s.size
+    nk = span3s.size
+
+    for i in range(ni):
+        span1 = span1s[i]
+        b1[:] = b1s[i, :]
+        for j in range(nj):
+            span2 = span2s[j]
+            b2[:] = b2s[j, :]
+            for k in range(nk):
+                span3 = span3s[k]
+                b3[:] = b3s[k, :]
+                
+                values[i, j, k] = eval_spline_mpi_kernel(pn[0] - kind[0],
+                                                         pn[1] - kind[1],
+                                                         pn[2] - kind[2],
+                                                         b1, b2, b3,
+                                                         span1, span2, span3,
+                                                         _data,
+                                                         starts)
+
+
 def eval_spline_mpi_matrix(eta1: 'float[:,:,:]', eta2: 'float[:,:,:]', eta3: 'float[:,:,:]',
                            _data: 'float[:,:,:]', kind: 'int[:]',
                            pn: 'int[:]', tn1: 'float[:]', tn2: 'float[:]', tn3: 'float[:]',
@@ -724,4 +876,4 @@ def eval_spline_mpi_sparse_meshgrid(eta1: 'float[:,:,:]', eta2: 'float[:,:,:]',
                     continue  # point not in process domain
 
                 values[i, j, k] = eval_spline_mpi(
-                    eta1[i, 0, 0], eta2[0, j, 0], eta3[0, 0, k], _data, kind, pn, tn1, tn2, tn3, starts)
+                    eta1[i, 0, 0], eta2[0, j, 0], eta3[0, 0, k], _data, kind, pn, tn1, tn2, tn3, starts)

struphy-2.3.0/src/struphy/bsplines/tests/test_bsplines_kernels.py

@@ -0,0 +1,197 @@
+import pytest
+import numpy as np
+from mpi4py import MPI
+import time
+
+
+@pytest.mark.mpi(min_size=2)
+@pytest.mark.parametrize('Nel', [[8, 9, 10]])
+@pytest.mark.parametrize('p', [[1, 2, 1], [2, 1, 2], [3, 4, 3]])
+@pytest.mark.parametrize('spl_kind', [[False, False, True], [False, True, False], [True, False, False]])
+def test_bsplines_span_and_basis(Nel, p, spl_kind):
+    '''
+    Compare Struphy and Psydac bsplines kernels for knot spans and basis values computation.
+    Print timings.
+    '''
+
+    from struphy.feec.psydac_derham import Derham
+
+    from struphy.feec.utilities import create_equal_random_arrays as cera
+    import struphy.bsplines.bsplines_kernels as bsp
+    import psydac.core.bsplines_pyccel as bsp_psy
+
+    comm = MPI.COMM_WORLD
+    assert comm.size >= 2
+    rank = comm.Get_rank()
+
+    # Psydac discrete Derham sequence
+    derham = Derham(Nel, p, spl_kind, comm=comm)
+
+    # knot vectors
+    tn1, tn2, tn3 = derham.Vh_fem['0'].knots
+    td1, td2, td3 = derham.Vh_fem['3'].knots
+
+    # Random points in domain of process
+    n_pts = 100
+    dom = derham.domain_array[rank]
+    eta1s = np.random.rand(n_pts)*(dom[1] - dom[0]) + dom[0]
+    eta2s = np.random.rand(n_pts)*(dom[4] - dom[3]) + dom[3]
+    eta3s = np.random.rand(n_pts)*(dom[7] - dom[6]) + dom[6]
+
+    # struphy find_span
+    t0 = time.time()
+    span1s, span2s, span3s = [], [], []
+    for eta1, eta2, eta3 in zip(eta1s, eta2s, eta3s):
+        span1s += [bsp.find_span(tn1, derham.p[0], eta1)]
+        span2s += [bsp.find_span(tn2, derham.p[1], eta2)]
+        span3s += [bsp.find_span(tn3, derham.p[2], eta3)]
+    t1 = time.time()
+    if rank == 0:
+        print(f'struphy find_span  : {t1 - t0}')
+        
+    # psydac find_span_p
+    t0 = time.time()
+    span1s_psy, span2s_psy, span3s_psy = [], [], []
+    for eta1, eta2, eta3 in zip(eta1s, eta2s, eta3s):
+        span1s_psy += [bsp_psy.find_span_p(tn1, derham.p[0], eta1)]
+        span2s_psy += [bsp_psy.find_span_p(tn2, derham.p[1], eta2)]
+        span3s_psy += [bsp_psy.find_span_p(tn3, derham.p[2], eta3)]
+    t1 = time.time()
+    if rank == 0:
+        print(f'psydac find_span_p : {t1 - t0}')
+        
+    assert np.allclose(span1s, span1s_psy)
+    assert np.allclose(span2s, span2s_psy)
+    assert np.allclose(span3s, span3s_psy)
+    
+    # allocate tmps
+    bn1 = np.empty(derham.p[0] + 1, dtype=float)
+    bn2 = np.empty(derham.p[1] + 1, dtype=float)
+    bn3 = np.empty(derham.p[2] + 1, dtype=float)
+    
+    bd1 = np.empty(derham.p[0], dtype=float)
+    bd2 = np.empty(derham.p[1], dtype=float)
+    bd3 = np.empty(derham.p[2], dtype=float)
+    
+    # struphy b_splines_slim
+    val1s, val2s, val3s = [], [], []
+    t0 = time.time()
+    for eta1, eta2, eta3, span1, span2, span3 in zip(eta1s, eta2s, eta3s, span1s, span2s, span3s):
+        bsp.b_splines_slim(tn1, derham.p[0], eta1, span1, bn1)
+        bsp.b_splines_slim(tn2, derham.p[1], eta2, span2, bn2)
+        bsp.b_splines_slim(tn3, derham.p[2], eta3, span3, bn3)
+        val1s += [bn1]
+        val2s += [bn2]
+        val3s += [bn3]
+    t1 = time.time()
+    if rank == 0:
+        print(f'bsp.b_splines_slim        : {t1 - t0}')
+        
+    # psydac basis_funs_p
+    val1s_psy, val2s_psy, val3s_psy = [], [], []
+    t0 = time.time()
+    for eta1, eta2, eta3, span1, span2, span3 in zip(eta1s, eta2s, eta3s, span1s, span2s, span3s):
+        bsp_psy.basis_funs_p(tn1, derham.p[0], eta1, span1, bn1)
+        bsp_psy.basis_funs_p(tn2, derham.p[1], eta2, span2, bn2)
+        bsp_psy.basis_funs_p(tn3, derham.p[2], eta3, span3, bn3)
+        val1s_psy += [bn1]
+        val2s_psy += [bn2]
+        val3s_psy += [bn3]
+    t1 = time.time()
+    if rank == 0:
+        print(f'bsp_psy.basis_funs_p for N: {t1 - t0}')
+    
+    # compare
+    for val1, val1_psy in zip(val1s, val1s_psy):
+        assert np.allclose(val1, val1_psy)
+        
+    for val2, val2_psy in zip(val2s, val2s_psy):
+        assert np.allclose(val2, val2_psy)
+        
+    for val3, val3_psy in zip(val3s, val3s_psy):
+        assert np.allclose(val3, val3_psy)
+        
+    # struphy b_d_splines_slim
+    val1s_n, val2s_n, val3s_n = [], [], []
+    val1s_d, val2s_d, val3s_d = [], [], []
+    t0 = time.time()
+    for eta1, eta2, eta3, span1, span2, span3 in zip(eta1s, eta2s, eta3s, span1s, span2s, span3s):
+        bsp.b_d_splines_slim(tn1, derham.p[0], eta1, span1, bn1, bd1)
+        bsp.b_d_splines_slim(tn2, derham.p[1], eta2, span2, bn2, bd2)
+        bsp.b_d_splines_slim(tn3, derham.p[2], eta3, span3, bn3, bd3)
+        val1s_n += [bn1]
+        val2s_n += [bn2]
+        val3s_n += [bn3]
+        val1s_d += [bd1]
+        val2s_d += [bd2]
+        val3s_d += [bd3]
+    t1 = time.time()
+    if rank == 0:
+        print(f'bsp.b_d_splines_slim      : {t1 - t0}')
+        
+    # compare
+    for val1, val1_psy in zip(val1s_n, val1s_psy):
+        assert np.allclose(val1, val1_psy)
+        
+    for val2, val2_psy in zip(val2s_n, val2s_psy):
+        assert np.allclose(val2, val2_psy)
+        
+    for val3, val3_psy in zip(val3s_n, val3s_psy):
+        assert np.allclose(val3, val3_psy)
+        
+    # struphy d_splines_slim
+    span1s, span2s, span3s = [], [], []
+    for eta1, eta2, eta3 in zip(eta1s, eta2s, eta3s):
+        span1s += [bsp.find_span(td1, derham.p[0] - 1, eta1)]
+        span2s += [bsp.find_span(td2, derham.p[1] - 1, eta2)]
+        span3s += [bsp.find_span(td3, derham.p[2] - 1, eta3)]
+    
+    val1s, val2s, val3s = [], [], []
+    t0 = time.time()
+    for eta1, eta2, eta3, span1, span2, span3 in zip(eta1s, eta2s, eta3s, span1s, span2s, span3s):
+        bsp.d_splines_slim(td1, derham.p[0] - 1, eta1, span1, bd1)
+        bsp.d_splines_slim(td2, derham.p[1] - 1, eta2, span2, bd2)
+        bsp.d_splines_slim(td3, derham.p[2] - 1, eta3, span3, bd3)
+        val1s += [bd1]
+        val2s += [bd2]
+        val3s += [bd3]
+    t1 = time.time()
+    if rank == 0:
+        print(f'bsp.d_splines_slim        : {t1 - t0}')
+        
+    # psydac basis_funs_p for D-splines
+    val1s_psy, val2s_psy, val3s_psy = [], [], []
+    t0 = time.time()
+    for eta1, eta2, eta3, span1, span2, span3 in zip(eta1s, eta2s, eta3s, span1s, span2s, span3s):
+        bsp_psy.basis_funs_p(td1, derham.p[0] - 1, eta1, span1, bd1)
+        bsp_psy.basis_funs_p(td2, derham.p[1] - 1, eta2, span2, bd2)
+        bsp_psy.basis_funs_p(td3, derham.p[2] - 1, eta3, span3, bd3)
+        val1s_psy += [bd1]
+        val2s_psy += [bd2]
+        val3s_psy += [bd3]
+    t1 = time.time()
+    if rank == 0:
+        print(f'bsp_psy.basis_funs_p for D: {t1 - t0}')
+    
+    # compare
+    for val1, val1_psy in zip(val1s, val1s_psy):
+        assert np.allclose(val1, val1_psy)
+        
+    for val2, val2_psy in zip(val2s, val2s_psy):
+        assert np.allclose(val2, val2_psy)
+        
+    for val3, val3_psy in zip(val3s, val3s_psy):
+        assert np.allclose(val3, val3_psy)
+        
+    for val1, val1_psy in zip(val1s_d, val1s_psy):
+        assert np.allclose(val1, val1_psy)
+        
+    for val2, val2_psy in zip(val2s_d, val2s_psy):
+        assert np.allclose(val2, val2_psy)
+        
+    for val3, val3_psy in zip(val3s_d, val3s_psy):
+        assert np.allclose(val3, val3_psy)
+    
+    
+if __name__ == '__main__':
+    test_bsplines_span_and_basis([8, 9, 10], [3, 4, 3], [False, False, True])