doc/examples/simul_ns3d_forced_isotropic.py and co

doc/examples/simul_ns3d_forced_isotropic.py

@@ -0,0 +1,64 @@
+import os
+
+from fluiddyn.util.mpi import printby0
+
+from fluidsim.solvers.ns3d.solver import Simul
+
+if "FLUIDSIM_TESTS_EXAMPLES" in os.environ:
+    t_end = 1.0
+    nx = 24
+else:
+    t_end = 10.0
+    nx = 96
+
+params = Simul.create_default_params()
+
+params.output.sub_directory = "examples"
+
+ny = nz = nx
+Lx = 3
+params.oper.nx = nx
+params.oper.ny = ny
+params.oper.nz = nz
+params.oper.Lx = Lx
+params.oper.Ly = Ly = Lx / nx * ny
+params.oper.Lz = Lz = Lx / nx * nz
+
+params.time_stepping.USE_T_END = True
+params.time_stepping.t_end = t_end
+
+n = 8
+C = 1.0
+dx = Lx / nx
+B = 1
+D = 1
+eps = 1e-2 * B ** (3 / 2) * D ** (1 / 2)
+params.nu_8 = (dx / C) ** ((3 * n - 2) / 3) * eps ** (1 / 3)
+
+printby0(f"nu_8 = {params.nu_8:.3e}")
+
+params.init_fields.type = "noise"
+params.init_fields.noise.length = 1.0
+params.init_fields.noise.velo_max = 0.1
+
+params.forcing.enable = True
+params.forcing.type = "tcrandom"
+params.forcing.normalized.constant_rate_of = None
+params.forcing.nkmax_forcing = 3
+params.forcing.nkmax_forcing = 4
+# solenoidal field (toroidal + poloidal)
+params.forcing.key_forced = ["vt_fft", "vp_fft"]
+# forcing rate per key forced (so that energy forcing rate is 1)
+params.forcing.forcing_rate = 0.5
+
+params.output.periods_print.print_stdout = 1e-1
+
+params.output.periods_save.phys_fields = 0.5
+params.output.periods_save.spatial_means = 0.1
+params.output.periods_save.spectra = 0.1
+params.output.periods_save.spect_energy_budg = 0.1
+
+params.output.spectra.kzkh_periodicity = 1
+
+sim = Simul(params)
+sim.time_stepping.start()

fluidsim/base/forcing/specific.py

@@ -189,9 +189,7 @@ def __init__(self, sim):
             self.key_forced = self._key_forced_default
 
         try:
-            fft_size = 2 * fftw_grid_size(
-                int(round(params.forcing.nkmax_forcing))
-            )
+            fft_size = 2 * fftw_grid_size(int(round(params.forcing.nkmax_forcing)))
         except ImportError:
             warn("To use smaller forcing arrays: pip install pulp")
             i = 0
@@ -209,8 +207,7 @@ def __init__(self, sim):
             self.COND_NO_F = self._compute_cond_no_forcing()
 
             self.nb_forced_modes = (
-                self.COND_NO_F.size
-                - np.array(self.COND_NO_F, dtype=np.int32).sum()
+                self.COND_NO_F.size - np.array(self.COND_NO_F, dtype=np.int32).sum()
             )
             if not self.nb_forced_modes:
                 raise ValueError("0 modes forced.")
@@ -225,18 +222,14 @@ def __init__(self, sim):
                     "sim.forcing.forcing_maker.plot_forcing_region()"
                 )
 
-            self.ind_forcing = (
-                np.logical_not(self.COND_NO_F).flatten().nonzero()[0]
-            )
+            self.ind_forcing = np.logical_not(self.COND_NO_F).flatten().nonzero()[0]
 
             self.fstate_coarse = sim.state.__class__(sim, oper=self.oper_coarse)
         else:
             self.shapeK_loc_coarse = None
 
         if mpi.nb_proc > 1:
-            self.shapeK_loc_coarse = mpi.comm.bcast(
-                self.shapeK_loc_coarse, root=0
-            )
+            self.shapeK_loc_coarse = mpi.comm.bcast(self.shapeK_loc_coarse, root=0)
 
     def _create_params_coarse(self, fft_size):
         params_coarse = deepcopy(self.sim.params)
@@ -310,9 +303,7 @@ def verify_injection_rate_coarse(self, var_fft=None):
         """Verify injection rate."""
         if var_fft is None:
             var_fft = self.sim.state.state_spect.get_var(self.key_forced)
-            var_fft = self.oper.coarse_seq_from_fft_loc(
-                var_fft, self.shapeK_loc_coarse
-            )
+            var_fft = self.oper.coarse_seq_from_fft_loc(var_fft, self.shapeK_loc_coarse)
 
         if mpi.rank == 0:
             f_fft = self.fstate_coarse.get_var(self.key_forced)
@@ -486,14 +477,12 @@ def compute(self):
                 a_fft = self.sim.state.get_var(key_forced)
 
             try:
-                a_fft = self.oper.coarse_seq_from_fft_loc(
-                    a_fft, self.shapeK_loc_coarse
-                )
-            except IndexError:
+                a_fft = self.oper.coarse_seq_from_fft_loc(a_fft, self.shapeK_loc_coarse)
+            except IndexError as error:
                 raise ValueError(
                     f"rank={self.oper.rank}; {self.shapeK_loc_coarse = }; "
                     f"{self.oper.shapeK_loc = }"
-                )
+                ) from error
 
             if mpi.rank == 0:
                 fa_fft = self.forcingc_raw_each_time(a_fft)

fluidsim/util/scripts/turb_trandom_anisotropic.py

@@ -497,7 +497,7 @@ def main(args=None, **defaults):
 
 # To visualize with fluidsim:
 
-cd {sim.output.path_run}; fluidsim-ipy-load
+fluidsim-ipy-load {sim.output.path_run}
 
 # in IPython:
 

lib/fluidsim_core/scripts/restart.py

@@ -112,7 +112,7 @@ def restart(self, args=None, **defaults):
         """
         # To visualize with IPython:
 
-        cd {path_run}; fluidsim-ipy-load
+        fluidsim-ipy-load {path_run}
     """
     )