Replace profiling with scope-profiler from pypi

params_LinearMHDDriftkineticCC.py

@@ -0,0 +1,116 @@
+from struphy import main
+from struphy.fields_background import equils
+from struphy.geometry import domains
+from struphy.initial import perturbations
+from struphy.io.options import BaseUnits, DerhamOptions, EnvironmentOptions, FieldsBackground, Time
+from struphy.kinetic_background import maxwellians
+
+# import model, set verbosity
+from struphy.models.hybrid import LinearMHDDriftkineticCC
+from struphy.pic.utilities import (
+    BinningPlot,
+    BoundaryParameters,
+    KernelDensityPlot,
+    LoadingParameters,
+    WeightsParameters,
+)
+from struphy.topology import grids
+
+# environment options
+env = EnvironmentOptions(profiling_activated=True, profiling_trace=True)
+
+# units
+base_units = BaseUnits()
+
+# time stepping
+time_opts = Time()
+
+# geometry
+domain = domains.Cuboid()
+
+# fluid equilibrium (can be used as part of initial conditions)
+equil = equils.HomogenSlab()
+
+# grid
+grid = grids.TensorProductGrid(Nel=(16, 4, 1))
+
+# derham options
+derham_opts = DerhamOptions()
+
+# light-weight model instance
+model = LinearMHDDriftkineticCC()
+
+# species parameters
+model.mhd.set_phys_params()
+model.energetic_ions.set_phys_params()
+
+loading_params = LoadingParameters(ppc=1000)
+weights_params = WeightsParameters()
+boundary_params = BoundaryParameters()
+model.energetic_ions.set_markers(
+    loading_params=loading_params,
+    weights_params=weights_params,
+    boundary_params=boundary_params,
+)
+model.energetic_ions.set_sorting_boxes()
+model.energetic_ions.set_save_data()
+
+# propagator options
+model.propagators.push_bxe.options = model.propagators.push_bxe.Options(
+    b_tilde=model.em_fields.b_field,
+)
+model.propagators.push_parallel.options = model.propagators.push_parallel.Options(
+    b_tilde=model.em_fields.b_field,
+)
+model.propagators.shearalfen_cc5d.options = model.propagators.shearalfen_cc5d.Options(
+    energetic_ions=model.energetic_ions.var,
+)
+model.propagators.magnetosonic.options = model.propagators.magnetosonic.Options(
+    b_field=model.em_fields.b_field,
+)
+model.propagators.cc5d_density.options = model.propagators.cc5d_density.Options(
+    energetic_ions=model.energetic_ions.var,
+    b_tilde=model.em_fields.b_field,
+)
+model.propagators.cc5d_gradb.options = model.propagators.cc5d_gradb.Options(
+    b_tilde=model.em_fields.b_field,
+)
+model.propagators.cc5d_curlb.options = model.propagators.cc5d_curlb.Options(
+    b_tilde=model.em_fields.b_field,
+)
+
+# background, perturbations and initial conditions
+model.mhd.velocity.add_background(FieldsBackground())
+model.mhd.velocity.add_perturbation(perturbations.TorusModesCos(given_in_basis="v", comp=0))
+model.mhd.velocity.add_perturbation(perturbations.TorusModesCos(given_in_basis="v", comp=1))
+model.mhd.velocity.add_perturbation(perturbations.TorusModesCos(given_in_basis="v", comp=2))
+maxwellian_1 = maxwellians.GyroMaxwellian2D(n=(1.0, None), equil=equil)
+maxwellian_2 = maxwellians.GyroMaxwellian2D(n=(0.1, None), equil=equil)
+background = maxwellian_1 + maxwellian_2
+model.energetic_ions.var.add_background(background)
+
+# if .add_initial_condition is not called, the background is the kinetic initial condition
+perturbation = perturbations.TorusModesCos()
+maxwellian_1pt = maxwellians.GyroMaxwellian2D(n=(1.0, perturbation), equil=equil)
+init = maxwellian_1pt + maxwellian_2
+model.energetic_ions.var.add_initial_condition(init)
+
+# optional: exclude variables from saving
+# model.energetic_ions.var.save_data = False
+
+if __name__ == "__main__":
+    # start run
+    verbose = True
+
+    main.run(
+        model,
+        params_path=__file__,
+        env=env,
+        base_units=base_units,
+        time_opts=time_opts,
+        domain=domain,
+        equil=equil,
+        grid=grid,
+        derham_opts=derham_opts,
+        verbose=verbose,
+    )

pyproject.toml

@@ -37,6 +37,7 @@ dependencies = [
     'pytest',
     'pytest-mpi',
     'line_profiler',
+    'scope-profiler==0.1.6',
 ]
 
 [project.license]

src/struphy/io/options.py

@@ -336,6 +336,12 @@ class EnvironmentOptions:
 
     num_clones: int, optional
         Number of domain clones (default=1)
+
+    profiling_activated: bool, optional
+        Activate profiling with scope-profiler (default=False)
+
+    profiling_trace: bool, optional
+        Save time-trace of each profiling region (default=False)
     """
 
     out_folders: str = os.getcwd()
@@ -345,6 +351,8 @@ class EnvironmentOptions:
     save_step: int = 1
     sort_step: int = 0
     num_clones: int = 1
+    profiling_activated: bool = False
+    profiling_trace: bool = False
 
     def __post_init__(self):
         self.path_out: str = os.path.join(self.out_folders, self.sim_folder)

src/struphy/main.py

@@ -14,6 +14,7 @@
 from psydac.ddm.mpi import MockMPI
 from psydac.ddm.mpi import mpi as MPI
 from pyevtk.hl import gridToVTK
+from scope_profiler import ProfileManager
 
 from struphy.fields_background.base import FluidEquilibrium, FluidEquilibriumWithB
 from struphy.fields_background.equils import HomogenSlab
@@ -36,7 +37,6 @@
     post_process_markers,
     post_process_n_sph,
 )
-from struphy.profiling.profiling import ProfileManager
 from struphy.topology import grids
 from struphy.topology.grids import TensorProductGrid
 from struphy.utils.clone_config import CloneConfig
@@ -69,6 +69,12 @@ def run(
         Absolute path to .py parameter file.
     """
 
+    ProfileManager.setup(
+        profiling_activated=env.profiling_activated,
+        time_trace=env.profiling_trace,
+        use_likwid=False,
+    )
+
     if isinstance(MPI, MockMPI):
         comm = None
         rank = 0
@@ -407,6 +413,8 @@ def run(
     if clone_config is not None:
         clone_config.free()
 
+    ProfileManager.finalize()
+
 
 def pproc(
     path: str,
@@ -831,154 +839,3 @@ def load_data(path: str) -> SimData:
                 print(f"      {kkk}")
 
     return simdata
-
-
-if __name__ == "__main__":
-    import argparse
-    import os
-
-    import struphy
-    import struphy.utils.utils as utils
-    from struphy.profiling.profiling import (
-        ProfileManager,
-        ProfilingConfig,
-        pylikwid_markerclose,
-        pylikwid_markerinit,
-    )
-
-    # Read struphy state file
-    state = utils.read_state()
-    o_path = state["o_path"]
-
-    parser = argparse.ArgumentParser(description="Run an Struphy model.")
-
-    # model
-    parser.add_argument(
-        "model",
-        type=str,
-        nargs="?",
-        default=None,
-        metavar="MODEL",
-        help="the name of the model to run (default: None)",
-    )
-
-    # input (absolute path)
-    parser.add_argument(
-        "-i",
-        "--input",
-        type=str,
-        metavar="FILE",
-        help="absolute path of parameter file",
-    )
-
-    # output (absolute path)
-    parser.add_argument(
-        "-o",
-        "--output",
-        type=str,
-        metavar="DIR",
-        help="absolute path of output folder (default=<out_path>/sim_1)",
-        default=os.path.join(o_path, "sim_1"),
-    )
-
-    # restart
-    parser.add_argument(
-        "-r",
-        "--restart",
-        help="restart the simulation in the output folder specified under -o",
-        action="store_true",
-    )
-
-    # max_runtime
-    parser.add_argument(
-        "--max-runtime",
-        type=int,
-        metavar="N",
-        help="maximum wall-clock time of program in minutes (default=300)",
-        default=300,
-    )
-
-    # save step
-    parser.add_argument(
-        "-s",
-        "--save-step",
-        type=int,
-        metavar="N",
-        help="how often to skip data saving (default=1, which means data is saved every time step)",
-        default=1,
-    )
-
-    # sort step
-    parser.add_argument(
-        "--sort-step",
-        type=int,
-        metavar="N",
-        help="sort markers in memory every N time steps (default=0, which means markers are sorted only at the start of simulation)",
-        default=0,
-    )
-
-    parser.add_argument(
-        "--nclones",
-        type=int,
-        metavar="N",
-        help="number of domain clones (default=1)",
-        default=1,
-    )
-
-    # verbosity (screen output)
-    parser.add_argument(
-        "-v",
-        "--verbose",
-        help="supress screen output during time integration",
-        action="store_true",
-    )
-
-    parser.add_argument(
-        "--likwid",
-        help="run with Likwid",
-        action="store_true",
-    )
-
-    parser.add_argument(
-        "--time-trace",
-        help="Measure time traces for each call of the regions measured with ProfileManager",
-        action="store_true",
-    )
-
-    parser.add_argument(
-        "--sample-duration",
-        help="Duration of samples when measuring time traces with ProfileManager",
-        default=1.0,
-    )
-
-    parser.add_argument(
-        "--sample-interval",
-        help="Time between samples when measuring time traces with ProfileManager",
-        default=1.0,
-    )
-
-    args = parser.parse_args()
-    config = ProfilingConfig()
-    config.likwid = args.likwid
-    config.sample_duration = float(args.sample_duration)
-    config.sample_interval = float(args.sample_interval)
-    config.time_trace = args.time_trace
-    config.simulation_label = ""
-    pylikwid_markerinit()
-    with ProfileManager.profile_region("main"):
-        # solve the model
-        run(
-            args.model,
-            args.input,
-            args.output,
-            restart=args.restart,
-            runtime=args.runtime,
-            save_step=args.save_step,
-            verbose=args.verbose,
-            sort_step=args.sort_step,
-            num_clones=args.nclones,
-        )
-    pylikwid_markerclose()
-    if config.time_trace:
-        ProfileManager.print_summary()
-        ProfileManager.save_to_pickle(os.path.join(args.output, "profiling_time_trace.pkl"))

src/struphy/models/base.py

@@ -12,6 +12,7 @@
 from psydac.ddm.mpi import MockMPI
 from psydac.ddm.mpi import mpi as MPI
 from psydac.linalg.stencil import StencilVector
+from scope_profiler import ProfileManager
 
 import struphy
 from struphy.feec.basis_projection_ops import BasisProjectionOperators
@@ -39,7 +40,6 @@
 from struphy.models.variables import FEECVariable, PICVariable, SPHVariable
 from struphy.pic import particles
 from struphy.pic.base import Particles
-from struphy.profiling.profiling import ProfileManager
 from struphy.propagators.base import Propagator
 from struphy.topology.grids import TensorProductGrid
 from struphy.utils.clone_config import CloneConfig
@@ -692,7 +692,7 @@ def integrate(self, dt, split_algo="LieTrotter"):
             for propagator in self.prop_list:
                 prop_name = propagator.__class__.__name__
 
-                with ProfileManager.profile_region(prop_name):
+                with ProfileManager.profile_region("prop: " + prop_name):
                     propagator(dt)
 
         # second order in time
@@ -701,17 +701,17 @@ def integrate(self, dt, split_algo="LieTrotter"):
 
             for propagator in self.prop_list[:-1]:
                 prop_name = type(propagator).__name__
-                with ProfileManager.profile_region(prop_name):
+                with ProfileManager.profile_region("prop: " + prop_name):
                     propagator(dt / 2)
 
             propagator = self.prop_list[-1]
             prop_name = type(propagator).__name__
-            with ProfileManager.profile_region(prop_name):
+            with ProfileManager.profile_region("prop: " + prop_name):
                 propagator(dt)
 
             for propagator in self.prop_list[:-1][::-1]:
                 prop_name = type(propagator).__name__
-                with ProfileManager.profile_region(prop_name):
+                with ProfileManager.profile_region("prop: " + prop_name):
                     propagator(dt / 2)
 
         else: