struphy 2.3.1__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: struphy
-Version: 2.3.1
+Version: 2.3.2
 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
@@ -32,7 +32,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML==6.0.1
 Requires-Dist: argcomplete==3.4.0
-Requires-Dist: desc-opt==0.11.1
+Requires-Dist: desc-opt==0.12.0
 Requires-Dist: docutils==0.21.2
 Requires-Dist: gvec-to-python==1.2.2
 Requires-Dist: h5py==3.11.0
@@ -47,7 +47,7 @@ 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: pyccel==1.12.1
 Requires-Dist: pydata-sphinx-theme==0.15.3
 Requires-Dist: pytest==8.2.2
 Requires-Dist: pytest-monitor==1.6.6

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "struphy"
-version = "2.3.1"
+version = "2.3.2"
 readme = "README.md"
 requires-python = ">=3.10, <3.12"
 license = {file = "LICENSE"}
@@ -21,7 +21,7 @@ classifiers = [
 dependencies = [
     'PyYAML==6.0.1',
     'argcomplete==3.4.0',
-    'desc-opt==0.11.1',
+    'desc-opt==0.12.0',
     'docutils==0.21.2',
     'gvec-to-python==1.2.2',
     'h5py==3.11.0',
@@ -36,7 +36,7 @@ dependencies = [
     'netCDF4==1.6.5',
     'notebook==7.2.1',
     'numpy==1.24.4',
-    'pyccel==1.12.0',
+    'pyccel==1.12.1',
     'pydata-sphinx-theme==0.15.3',
     'pytest==8.2.2',
     'pytest-monitor==1.6.6',

{struphy-2.3.1 → struphy-2.3.2}/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.2}/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.2}/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.
     """
@@ -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)

{struphy-2.3.1 → struphy-2.3.2}/src/struphy/console/main.py

@@ -13,10 +13,9 @@ def struphy():
     Struphy main executable. Performs argument parsing and sub-command call.
     '''
 
-    import inspect
+    import pickle
     import argparse
     import yaml
-    from struphy.models import fluid, kinetic, hybrid, toy
     from struphy.console.compile import struphy_compile
     from struphy.console.run import struphy_run
     from struphy.console.units import struphy_units
@@ -91,67 +90,15 @@ def struphy():
     batch_files = recursive_get_files(
         b_path, contains=('.sh'), out=[], prefix=[])
 
-    # collect available model, contains=('.yml', '.yaml')s
-    list_fluid = []
-    fluid_string = ''
-    for name, obj in inspect.getmembers(fluid):
-        if inspect.isclass(obj):
-            if name not in {'StruphyModel', }:
-                list_fluid += [name]
-                fluid_string += '"' + name + '"\n'
-
-    list_kinetic = []
-    kinetic_string = ''
-    for name, obj in inspect.getmembers(kinetic):
-        if inspect.isclass(obj):
-            if name not in {'StruphyModel', }:
-                list_kinetic += [name]
-                kinetic_string += '"' + name + '"\n'
-
-    list_hybrid = []
-    hybrid_string = ''
-    for name, obj in inspect.getmembers(hybrid):
-        if inspect.isclass(obj):
-            if name not in {'StruphyModel', }:
-                list_hybrid += [name]
-                hybrid_string += '"' + name + '"\n'
-
-    list_toy = []
-    toy_string = ''
-    for name, obj in inspect.getmembers(toy):
-        if inspect.isclass(obj):
-            if name not in {'StruphyModel', }:
-                list_toy += [name]
-                toy_string += '"' + name + '"\n'
-
-    list_models = list_fluid + list_kinetic + list_hybrid + list_toy
-
-    # fluid message
-    fluid_message = 'Fluid models:\n'
-    fluid_message += '-------------\n'
-    fluid_message += fluid_string
-
-    # kinetic message
-    kinetic_message = 'Kinetic models:\n'
-    kinetic_message += '---------------\n'
-    kinetic_message += kinetic_string
-
-    # hybrid message
-    hybrid_message = 'Hybrid models:\n'
-    hybrid_message += '--------------\n'
-    hybrid_message += hybrid_string
-
-    # toy message
-    toy_message = 'Toy models:\n'
-    toy_message += '-----------\n'
-    toy_message += toy_string
-
-    # model message
-    model_message = 'run one of the following models:\n'
-    model_message += '\n' + fluid_message
-    model_message += '\n' + kinetic_message
-    model_message += '\n' + hybrid_message
-    model_message += '\n' + toy_message
+    try:
+        with open(os.path.join(libpath, 'models', 'models_list'), "rb") as fp:
+            list_models = pickle.load(fp)
+        with open(os.path.join(libpath, 'models', 'models_message'), "rb") as fp:
+            model_message, fluid_message, kinetic_message, hybrid_message, toy_message = pickle.load(
+                fp)
+    except:
+        list_models = []
+        model_message = ''
 
     # 0. basic options
     parser.add_argument('-v', '--version', action='version',
@@ -168,6 +115,9 @@ def struphy():
                         help='display available hybrid models')
     parser.add_argument('--toy', action='store_true',
                         help='display available toy models')
+    parser.add_argument('--refresh-models',
+                        help='refresh list of available model names',
+                        action='store_true',)
     parser.add_argument('--set-i',
                         type=str,
                         metavar='PATH',
@@ -364,6 +314,24 @@ def struphy():
     parser_params.add_argument('-y', '--yes',
                                help='Say yes on prompt to overwrite .yml FILE',
                                action='store_true')
+    
+    parser_run.add_argument('--likwid',
+                            help='run with Likwid',
+                            action='store_true',)
+    
+    parser_run.add_argument('-li', '--likwid-inp',
+                            type=str,
+                            metavar='FILE',
+                            help='likwid parameter file (.yml) in current I/O path',)
+
+    parser_run.add_argument('--likwid-input-abs',
+                            type=str,
+                            metavar='FILE',
+                            help='likwid parameter file (.yml), absolute path',)
+    parser_run.add_argument('-lr', '--likwid-repetitions',
+                            type=int,
+                            help='number of repetitions of the same simulation',
+                            default=1,)
 
     # 5. "profile" sub-command
     parser_profile = subparsers.add_parser(
@@ -432,6 +400,10 @@ def struphy():
                               help='divide each grid cell by N for field evaluation (default=1)',
                               default=1)
 
+    parser_pproc.add_argument('--physical',
+                              help='in addition to logical components, evaluates push-forwarded physical (xyz) components',
+                              action='store_true')
+
     # 7. "test" sub-command
     parser_test = subparsers.add_parser('test',
                                         formatter_class=lambda prog: argparse.RawTextHelpFormatter(
@@ -442,11 +414,17 @@ def struphy():
     parser_test.add_argument('group',
                              type=str,
                              choices=list_models +
-                             ['models'] + ['unit'] +
-                             ['tutorials'] + ['timings'],
+                             ['models'] +
+                             ['unit'] +
+                             ['tutorials'] +
+                             ['timings'] +
+                             ['fluid'] +
+                             ['kinetic'] +
+                             ['hybrid'] +
+                             ['toy'],
                              metavar='GROUP',
                              help='can be either:\na) a model name (tests on 1 MPI process in "Cuboid", "HollowTorus" and "Tokamak" geometries) \
-                                \nb) "models" for quick testing of all models \
+                                \nb) "models" for quick testing of all models (or "fluid", "kinetic", "hybrid", "toy" for testing just a sub-group) \
                                 \nc) "unit" for performing unit tests \
                                 \nd) "tutorials" for notebook tutorials, see `https://struphy.pages.mpcdf.de/struphy/sections/tutorials.html`_ \
                                 \ne) "timings" for creating .html and .json files of test metrics (include --verbose to print metrics to screen)',)
@@ -461,6 +439,10 @@ def struphy():
                              help='test model(s) just in slab geometry (Cuboid)',
                              action='store_true')
 
+    parser_test.add_argument('--with-desc',
+                             help='include DESC equilibrium in tests (mem consuming)',
+                             action='store_true')
+
     parser_test.add_argument('-v', '--verbose',
                              help='print timings to screen',
                              action='store_true')
@@ -614,6 +596,88 @@ def struphy():
         subprocess.run(['struphy', '--set-b', b_path])
 
         exit()
+        
+    if args.refresh_models:
+        
+        print('Collecting available models ...')
+        
+        import inspect
+        from struphy.models import fluid, kinetic, hybrid, toy
+        import pickle
+
+        list_fluid = []
+        fluid_string = ''
+        for name, obj in inspect.getmembers(fluid):
+            if inspect.isclass(obj):
+                if name not in {'StruphyModel', 'Propagator'}:
+                    list_fluid += [name]
+                    fluid_string += '"' + name + '"\n'
+
+        list_kinetic = []
+        kinetic_string = ''
+        for name, obj in inspect.getmembers(kinetic):
+            if inspect.isclass(obj):
+                if name not in {'StruphyModel', 'Propagator'}:
+                    list_kinetic += [name]
+                    kinetic_string += '"' + name + '"\n'
+
+        list_hybrid = []
+        hybrid_string = ''
+        for name, obj in inspect.getmembers(hybrid):
+            if inspect.isclass(obj):
+                if name not in {'StruphyModel', 'Propagator'}:
+                    list_hybrid += [name]
+                    hybrid_string += '"' + name + '"\n'
+
+        list_toy = []
+        toy_string = ''
+        for name, obj in inspect.getmembers(toy):
+            if inspect.isclass(obj):
+                if name not in {'StruphyModel', 'Propagator'}:
+                    list_toy += [name]
+                    toy_string += '"' + name + '"\n'
+
+        list_models = list_fluid + list_kinetic + list_hybrid + list_toy
+
+        with open(os.path.join(libpath, 'models', 'models_list'), "wb") as fp:
+            pickle.dump(list_models, fp)
+
+        # fluid message
+        fluid_message = 'Fluid models:\n'
+        fluid_message += '-------------\n'
+        fluid_message += fluid_string
+
+        # kinetic message
+        kinetic_message = 'Kinetic models:\n'
+        kinetic_message += '---------------\n'
+        kinetic_message += kinetic_string
+
+        # hybrid message
+        hybrid_message = 'Hybrid models:\n'
+        hybrid_message += '--------------\n'
+        hybrid_message += hybrid_string
+
+        # toy message
+        toy_message = 'Toy models:\n'
+        toy_message += '-----------\n'
+        toy_message += toy_string
+
+        # model message
+        model_message = 'run one of the following models:\n'
+        model_message += '\n' + fluid_message
+        model_message += '\n' + kinetic_message
+        model_message += '\n' + hybrid_message
+        model_message += '\n' + toy_message
+
+        with open(os.path.join(libpath, 'models', 'models_message'), "wb") as fp:
+            pickle.dump([model_message,
+                         fluid_message,
+                         kinetic_message,
+                         hybrid_message,
+                         toy_message], fp)
+            
+        print('Done.')    
+        exit()
 
     # load sub-command function (see functions below)
     func = locals()['struphy_' + args.command]
@@ -630,6 +694,7 @@ def struphy():
     kwargs.pop('set_o')
     kwargs.pop('set_b')
     kwargs.pop('set_iob')
+    kwargs.pop('refresh_models')
 
     # start sub-command function with all parameters of that function
     # for k, v in kwargs.items():

{struphy-2.3.1 → struphy-2.3.2}/src/struphy/console/pproc.py

@@ -1,4 +1,4 @@
-def struphy_pproc(dirr, dir_abs=None, step=1, celldivide=1):
+def struphy_pproc(dirr, dir_abs=None, step=1, celldivide=1, physical=False):
     """
     Post process data from finished Struphy runs.
 
@@ -15,6 +15,9 @@ def struphy_pproc(dirr, dir_abs=None, step=1, celldivide=1):
 
     celldivide : int, optional
         Number of grid point in each cell used to create vtk files (default=1).
+
+    physical : bool
+        Wether to do post-processing into push-forwarded physical (xyz) components of fields.
     """
     import subprocess
     import os
@@ -34,13 +37,18 @@ def struphy_pproc(dirr, dir_abs=None, step=1, celldivide=1):
 
     print(f'Post processing data in {dir_abs}')
 
+    command = ['python3',
+               'post_processing/pproc_struphy.py',
+               dir_abs,
+               '-s',
+               str(step),
+               '--celldivide',
+               str(celldivide)]
+    
+    if physical:
+        command += ['--physical']
+
     # loop over output folders and call post-processing .py file
-    subprocess.run(['python3',
-                    'post_processing/pproc_struphy.py',
-                    dir_abs,
-                    '-s',
-                    str(step),
-                    '--celldivide',
-                    str(celldivide)],
+    subprocess.run(command,
                    cwd=libpath,
                    check=True)