struphy 2.3.1__tar.gz → 2.3.3__tar.gz

{struphy-2.3.1/src/struphy.egg-info → struphy-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: struphy
-Version: 2.3.1
+Version: 2.3.3
 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
@@ -31,12 +31,16 @@ Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML==6.0.1
+Requires-Dist: add-trailing-comma==3.1.0
 Requires-Dist: argcomplete==3.4.0
-Requires-Dist: desc-opt==0.11.1
+Requires-Dist: autopep8==2.3.1
+Requires-Dist: desc-opt==0.12.0
 Requires-Dist: docutils==0.21.2
+Requires-Dist: flake8==7.1.1
 Requires-Dist: gvec-to-python==1.2.2
 Requires-Dist: h5py==3.11.0
 Requires-Dist: ipyparallel==8.8.0
+Requires-Dist: isort==5.13.2
 Requires-Dist: lxml_html_clean==0.1.1
 Requires-Dist: m2r2==0.3.3.post2
 Requires-Dist: matplotlib==3.9.0
@@ -47,8 +51,10 @@ Requires-Dist: nbsphinx==0.9.4
 Requires-Dist: netCDF4==1.6.5
 Requires-Dist: notebook==7.2.1
 Requires-Dist: numpy==1.24.4
-Requires-Dist: pyccel==1.12.0
+Requires-Dist: pre_commit==4.0.1
+Requires-Dist: pyccel==1.12.1
 Requires-Dist: pydata-sphinx-theme==0.15.3
+Requires-Dist: pylint==3.3.1
 Requires-Dist: pytest==8.2.2
 Requires-Dist: pytest-monitor==1.6.6
 Requires-Dist: pytest-mpi==0.6

{struphy-2.3.1 → struphy-2.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "struphy"
-version = "2.3.1"
+version = "2.3.3"
 readme = "README.md"
 requires-python = ">=3.10, <3.12"
 license = {file = "LICENSE"}
@@ -20,12 +20,16 @@ classifiers = [
     ]
 dependencies = [
     'PyYAML==6.0.1',
+    'add-trailing-comma==3.1.0',
     'argcomplete==3.4.0',
-    'desc-opt==0.11.1',
+    'autopep8==2.3.1',
+    'desc-opt==0.12.0',
     'docutils==0.21.2',
+    'flake8==7.1.1',
     'gvec-to-python==1.2.2',
     'h5py==3.11.0',
     'ipyparallel==8.8.0',
+    'isort==5.13.2',
     'lxml_html_clean==0.1.1',
     'm2r2==0.3.3.post2',
     'matplotlib==3.9.0',
@@ -36,8 +40,10 @@ dependencies = [
     'netCDF4==1.6.5',
     'notebook==7.2.1',
     'numpy==1.24.4',
-    'pyccel==1.12.0',
+    'pre_commit==4.0.1',
+    'pyccel==1.12.1',
     'pydata-sphinx-theme==0.15.3',
+    'pylint==3.3.1',
     'pytest==8.2.2',
     'pytest-monitor==1.6.6',
     'pytest-mpi==0.6',
@@ -83,4 +89,31 @@ struphy = "struphy.console.main:struphy"
                     
 struphy = ['compile_struphy.mk',
            'psydac-0.1.13-py3-none-any.whl',
-           ]
+           ]
+
+[tool.autopep8]
+# Add specific settings for autopep8
+max_line_length = 120
+ignore = ["E221,E226,E203,E265,E731,E711"]
+# Descriptions of error codes: https://www.flake8rules.com/
+# E201 – Whitespace after  (, [ or {
+# E202 – Whitespace before (, [ or {
+# E221 – Multiple spaces before operator
+# E226 – Missing whitespace around arithmetic operators
+# E265 - Block comment should start with '# '
+# E266 – Too many leading # for block comment
+# E731 – Do not assign a lambda expression
+# E203 – Whitespace before : (used in slicing)
+# E711 - Ignore enforcing 'is not None' over '!= None'
+
+[tool.isort]
+# Configuration for isort
+profile = "black"  # Using the Black profile to match formatting styles
+line_length = 120
+multi_line_output = 3  # Control how isort wraps imports
+include_trailing_comma = true
+force_grid_wrap = 0
+combine_as_imports = true
+
+[tool.pylint]
+max-line-length=120

{struphy-2.3.1 → struphy-2.3.3}/setup.cfg

@@ -4,6 +4,9 @@ source-dir = doc/
 build-dir = doc/
 warning_is_error = 1
 
+[flake8]
+max-line-length = 120
+
 [egg_info]
 tag_build = 
 tag_date = 0

{struphy-2.3.1 → struphy-2.3.3}/src/struphy/bsplines/bsplines_kernels.py

@@ -3,9 +3,8 @@
 """
 Basic functions for point-wise B-spline evaluation
 """
-from pyccel.decorators import pure, stack_array
-
 from numpy import empty, zeros
+from pyccel.decorators import pure, stack_array
 
 
 @pure
@@ -256,8 +255,9 @@ def basis_funs_all_ders(knots: 'float[:]', degree: int, eta: float, span: int, l
                 d = a[s2, 0] * ndu[rk, pk]
             j1 = 1 if (rk > -1) else -rk
             j2 = k-1 if (r-1 <= pk) else degree-r
-            a[s2, j1:j2+1] = (a[s1, j1:j2+1] - a[s1, j1-1:j2]
-                              ) * ndu[pk+1, rk+j1:rk+j2+1]
+            a[s2, j1:j2+1] = (
+                a[s1, j1:j2+1] - a[s1, j1-1:j2]
+            ) * ndu[pk+1, rk+j1:rk+j2+1]
             for l in range(j2 + 1 - j1):
                 d += a[s2, j1 + l] * ndu[rk + j1 + l, pk]
             #d += dot(a[s2, j1:j2+1], ndu[rk+j1:rk+j2+1, pk])
@@ -375,8 +375,10 @@ def d_splines_slim(tn: 'float[:]', pn: 'int', eta: 'float', span: 'int', values:
 
     # compute D-splines values by scaling
     for il in range(pd + 1):
-        values[pd - il] = pn/(tn[span - il + pn] -
-                              tn[span - il]) * b_values[pd - il]
+        values[pd - il] = pn/(
+            tn[span - il + pn] -
+            tn[span - il]
+        ) * b_values[pd - il]
 
 
 @pure
@@ -427,8 +429,10 @@ def b_d_splines_slim(tn: 'float[:]', pn: 'int', eta: 'float', span: 'int', bn: '
         if j == pn-1:
             # compute D-splines values by scaling B-splines of degree pn-1
             for il in range(pd + 1):
-                bd[pd - il] = pn/(tn[span - il + pn] -
-                                  tn[span - il]) * bn[pd - il]
+                bd[pd - il] = pn/(
+                    tn[span - il + pn] -
+                    tn[span - il]
+                ) * bn[pd - il]
 
         for r in range(j + 1):
             temp = bn[r]/(right[r] + left[j - r])
@@ -656,7 +660,7 @@ def b_spl_1st_der_slim(t: 'float[:]', p: 'int', eta: 'float', span: 'int', value
 def piecewise(p: 'int', delta: 'float', eta: 'float') -> 'float':
     r"""
     evaluate a hat function (B-spline) centered at eta0 (the center of the support) at eta1, i.e. 
-    
+
     .. math::
         1.0 / delta * S((eta1 - eta0)/ delta)
 
@@ -753,7 +757,7 @@ def piecewise_der(p: 'int', delta: 'float', eta: 'float') -> 'float':
 def convolution(p: 'int', grids: 'float[:]', eta: 'float') -> 'float':
     r"""
     evaluate a hat function (B-spline) at eta, i.e. 
-    
+
     .. math::
         1.0 / delta * S(eta/ delta)
 
@@ -808,7 +812,7 @@ def convolution(p: 'int', grids: 'float[:]', eta: 'float') -> 'float':
 def convolution_der(p: 'int', grids: 'float[:]', eta: 'float') -> 'float':
     r"""
     evaluate the derivative of a hat function (B-spline) at eta, i.e. 
-    
+
     .. math::
         1.0 / delta^2 * S'(eta/ delta)
 

{struphy-2.3.1 → struphy-2.3.3}/src/struphy/bsplines/evaluation_kernels_3d.py

@@ -24,9 +24,14 @@ from numpy import empty, zeros
 
 import struphy.bsplines.bsplines_kernels as bsplines_kernels
 
+import struphy.pic.pushing.pusher_args_kernels as pusher_args_kernels
+from struphy.pic.pushing.pusher_args_kernels import DerhamArguments, DomainArguments
+
 #################################
 ### 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 (serial, needs global arrays).
@@ -404,7 +409,19 @@ def evaluate_sparse(t1: 'float[:]', t2: 'float[:]', t3: 'float[:]', p1: int, p2:
 ##############################
 ### 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:
+
+
+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:
     """
     Summing non-zero contributions of a spline function with distributed memory (domain decomposition).
 
@@ -767,7 +784,7 @@ def eval_spline_mpi_tensor_product_fixed(span1s: 'int[:]', span2s: 'int[:]', spa
             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],
@@ -876,4 +893,203 @@ 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)
+
+
+###########################################
+### Distributed Derham field evaluation ###
+###########################################
+
+def get_spans(eta1: float,
+              eta2: float,
+              eta3: float,
+              args_derham: 'DerhamArguments'):
+    '''Compute the knot span index, 
+    the N-spline values (in bn) and the D-spline values (in bd) 
+    at (eta1, eta2, eta3).'''
+
+    # find spans
+    span1 = bsplines_kernels.find_span(
+        args_derham.tn1, args_derham.pn[0], eta1)
+    span2 = bsplines_kernels.find_span(
+        args_derham.tn2, args_derham.pn[1], eta2)
+    span3 = bsplines_kernels.find_span(
+        args_derham.tn3, args_derham.pn[2], eta3)
+
+    # get spline values at eta
+    bsplines_kernels.b_d_splines_slim(
+        args_derham.tn1, args_derham.pn[0], eta1, int(span1), args_derham.bn1, args_derham.bd1)
+    bsplines_kernels.b_d_splines_slim(
+        args_derham.tn2, args_derham.pn[1], eta2, int(span2), args_derham.bn2, args_derham.bd2)
+    bsplines_kernels.b_d_splines_slim(
+        args_derham.tn3, args_derham.pn[2], eta3, int(span3), args_derham.bn3, args_derham.bd3)
+
+    return span1, span2, span3
+
+
+def eval_0form_spline_mpi(span1: int,
+                          span2: int,
+                          span3: int,
+                          args_derham: 'DerhamArguments',
+                          form_coeffs: 'float[:,:,:]') -> float:
+    '''Single-point evaluation of Derham 0-form spline defined by form_coeffs,
+    given N-spline values (in bn) and knot span indices span.'''
+
+    out = eval_spline_mpi_kernel(args_derham.pn[0],
+                                 args_derham.pn[1],
+                                 args_derham.pn[2],
+                                 args_derham.bn1,
+                                 args_derham.bn2,
+                                 args_derham.bn3,
+                                 span1, span2, span3,
+                                 form_coeffs,
+                                 args_derham.starts)
+    return out
+
+
+def eval_1form_spline_mpi(span1: int,
+                          span2: int,
+                          span3: int,
+                          args_derham: 'DerhamArguments',
+                          form_coeffs_1: 'float[:,:,:]',
+                          form_coeffs_2: 'float[:,:,:]',
+                          form_coeffs_3: 'float[:,:,:]',
+                          out: 'float[:]'):
+    '''Single-point evaluation of Derham 1-form spline defined by form_coeffs,
+    given N-spline values (in bn), D-spline values (in bd)
+    and knot span indices span.'''
+
+    out[0] = eval_spline_mpi_kernel(args_derham.pn[0] - 1,
+                                    args_derham.pn[1],
+                                    args_derham.pn[2],
+                                    args_derham.bd1,
+                                    args_derham.bn2,
+                                    args_derham.bn3,
+                                    span1, span2, span3,
+                                    form_coeffs_1,
+                                    args_derham.starts)
+
+    out[1] = eval_spline_mpi_kernel(args_derham.pn[0],
+                                    args_derham.pn[1] - 1,
+                                    args_derham.pn[2],
+                                    args_derham.bn1,
+                                    args_derham.bd2,
+                                    args_derham.bn3,
+                                    span1, span2, span3,
+                                    form_coeffs_2,
+                                    args_derham.starts)
+
+    out[2] = eval_spline_mpi_kernel(args_derham.pn[0],
+                                    args_derham.pn[1],
+                                    args_derham.pn[2] - 1,
+                                    args_derham.bn1,
+                                    args_derham.bn2,
+                                    args_derham.bd3,
+                                    span1, span2, span3,
+                                    form_coeffs_3,
+                                    args_derham.starts)
+
+
+def eval_2form_spline_mpi(span1: int,
+                          span2: int,
+                          span3: int,
+                          args_derham: 'DerhamArguments',
+                          form_coeffs_1: 'float[:,:,:]',
+                          form_coeffs_2: 'float[:,:,:]',
+                          form_coeffs_3: 'float[:,:,:]',
+                          out: 'float[:]'):
+    '''Single-point evaluation of Derham 2-form spline defined by form_coeffs,
+    given N-spline values (in bn), D-spline values (in bd)
+    and knot span indices span.'''
+
+    out[0] = eval_spline_mpi_kernel(args_derham.pn[0],
+                                    args_derham.pn[1] - 1,
+                                    args_derham.pn[2] - 1,
+                                    args_derham.bn1,
+                                    args_derham.bd2,
+                                    args_derham.bd3,
+                                    span1, span2, span3,
+                                    form_coeffs_1,
+                                    args_derham.starts)
+
+    out[1] = eval_spline_mpi_kernel(args_derham.pn[0] - 1,
+                                    args_derham.pn[1],
+                                    args_derham.pn[2] - 1,
+                                    args_derham.bd1,
+                                    args_derham.bn2,
+                                    args_derham.bd3,
+                                    span1, span2, span3,
+                                    form_coeffs_2,
+                                    args_derham.starts)
+
+    out[2] = eval_spline_mpi_kernel(args_derham.pn[0] - 1,
+                                    args_derham.pn[1] - 1,
+                                    args_derham.pn[2],
+                                    args_derham.bd1,
+                                    args_derham.bd2,
+                                    args_derham.bn3,
+                                    span1, span2, span3,
+                                    form_coeffs_3,
+                                    args_derham.starts)
+
+
+def eval_3form_spline_mpi(span1: int,
+                          span2: int,
+                          span3: int,
+                          args_derham: 'DerhamArguments',
+                          form_coeffs: 'float[:,:,:]') -> float:
+    '''Single-point evaluation of Derham 0-form spline defined by form_coeffs,
+    given D-spline values (in bd) and knot span indices span.'''
+
+    out = eval_spline_mpi_kernel(args_derham.pn[0] - 1,
+                                 args_derham.pn[1] - 1,
+                                 args_derham.pn[2] - 1,
+                                 args_derham.bd1,
+                                 args_derham.bd2,
+                                 args_derham.bd3,
+                                 span1, span2, span3,
+                                 form_coeffs,
+                                 args_derham.starts)
+    return out
+
+
+def eval_vectorfield_spline_mpi(span1: int,
+                                span2: int,
+                                span3: int,
+                                args_derham: 'DerhamArguments',
+                                form_coeffs_1: 'float[:,:,:]',
+                                form_coeffs_2: 'float[:,:,:]',
+                                form_coeffs_3: 'float[:,:,:]',
+                                out: 'float[:]'):
+    '''Single-point evaluation of vector-field spline (H^1)^3 defined by form_coeffs,
+    given N-spline values (in bn) and knot span indices span.'''
+
+    out[0] = eval_spline_mpi_kernel(args_derham.pn[0],
+                                    args_derham.pn[1],
+                                    args_derham.pn[2],
+                                    args_derham.bn1,
+                                    args_derham.bn2,
+                                    args_derham.bn3,
+                                    span1, span2, span3,
+                                    form_coeffs_1,
+                                    args_derham.starts)
+
+    out[1] = eval_spline_mpi_kernel(args_derham.pn[0],
+                                    args_derham.pn[1],
+                                    args_derham.pn[2],
+                                    args_derham.bn1,
+                                    args_derham.bn2,
+                                    args_derham.bn3,
+                                    span1, span2, span3,
+                                    form_coeffs_2,
+                                    args_derham.starts)
+
+    out[2] = eval_spline_mpi_kernel(args_derham.pn[0],
+                                    args_derham.pn[1],
+                                    args_derham.pn[2],
+                                    args_derham.bn1,
+                                    args_derham.bn2,
+                                    args_derham.bn3,
+                                    span1, span2, span3,
+                                    form_coeffs_3,
+                                    args_derham.starts)

{struphy-2.3.1 → struphy-2.3.3}/src/struphy/conftest.py

@@ -1,5 +1,6 @@
 def pytest_addoption(parser):
     parser.addoption("--fast", action="store_true")
+    parser.addoption("--with-desc", action="store_true")
 
 
 def pytest_generate_tests(metafunc):
@@ -8,3 +9,7 @@ def pytest_generate_tests(metafunc):
     option_value = metafunc.config.option.fast
     if 'fast' in metafunc.fixturenames and option_value is not None:
         metafunc.parametrize("fast", [option_value])
+        
+    option_value = metafunc.config.option.with_desc
+    if 'with_desc' in metafunc.fixturenames and option_value is not None:
+        metafunc.parametrize("with_desc", [option_value])

{struphy-2.3.1 → struphy-2.3.3}/src/struphy/console/compile.py

@@ -28,7 +28,7 @@ def struphy_compile(language, compiler, omp_pic, omp_feec, delete, status, verbo
 
     dependencies : bool
         Whether to print Struphy kernels (to be compiled) and their dependencies on screen.
-        
+
     yes : bool
         Whether to say yes to prompt when changing the language.
     """
@@ -39,6 +39,7 @@ def struphy_compile(language, compiler, omp_pic, omp_feec, delete, status, verbo
     import pyccel
     import yaml
     import sysconfig
+    import struphy.utils.utils as utils
     import struphy.dependencies as depmod
 
     libpath = struphy.__path__[0]
@@ -49,9 +50,8 @@ def struphy_compile(language, compiler, omp_pic, omp_feec, delete, status, verbo
         raise NameError(
             f'Stuphy installation path MUST NOT contain blank spaces. Please rename "{libpath}".')
 
-    # struphy state
-    with open(os.path.join(libpath, 'state.yml')) as f:
-        state = yaml.load(f, Loader=yaml.FullLoader)
+    # Read struphy state file
+    state = utils.read_state()
 
     # collect kernels
     if 'kernels' not in state:
@@ -91,6 +91,10 @@ def struphy_compile(language, compiler, omp_pic, omp_feec, delete, status, verbo
                         '--status',
                         ], check=True, cwd=libpath)
 
+        print('\nDeleting state.yml ...')
+        os.remove(os.path.join(libpath, 'state.yml'))
+        print('Done.')
+
     elif status:
 
         # update status
@@ -183,7 +187,7 @@ def struphy_compile(language, compiler, omp_pic, omp_feec, delete, status, verbo
             else:
                 yesno = input(
                     f'Kernels compiled in language {state["last_used_language"]} exist, will be deleted, continue (Y/n)?')
-                
+
             if yesno in ('', 'Y', 'y', 'yes'):
                 subprocess.run(['struphy',
                                 'compile',
@@ -261,3 +265,9 @@ def struphy_compile(language, compiler, omp_pic, omp_feec, delete, status, verbo
                        'compile',
                         '--status',
                         ], check=True, cwd=libpath)
+
+        # collect available models
+        print('')
+        subprocess.run(['struphy',
+                        '--refresh-models',
+                        ], check=True, cwd=libpath)