looping
moment_kinetics.looping — Module
Provides convenience macros for shared-memory-parallel loops
moment_kinetics.looping.debug_setup_loop_ranges_split_one_combination! — Method
For debugging the shared-memory parallelism, create ranges where only the loops for a single combinations of variables (given by combination_to_split) are parallelised, and which dimensions are parallelised can be set with the dims_to_split... arguments.
Arguments
Keyword arguments dim=n are required for each dim in all_dimensions where n is an integer giving the size of the dimension.
this_block_rank and this_block_size are overridable so that this function can be tested when running in serial.
moment_kinetics.looping.dims_string — Method
Construct a string composed of the dimension names given in the Tuple dims, separated by underscores
moment_kinetics.looping.get_best_anysv_split — Method
Find the numbers of processes for each dimension that optimize load balance for 'anysv' type loops for a certain block_size.
The 'anysv' parallelisation patterns are designed for use in the collision operator. They all share the same parallelisation in spatial dimensions so that the region type can be switched between 'anysv' types within a loop over spatial dimensions (@looprz). It is only defined for ions, not for neutrals.
Parts of the collision operator cannot conveniently be parallelised over velocity dimensions, so this function aims to assign as much parallelism as possible to the spatial dimensions.
moment_kinetics.looping.get_best_anyzv_split — Method
Find the numbers of processes for each dimension that optimize load balance for 'anyzv' type loops for a certain block_size.
The 'anyzv' parallelisation patterns are designed for use in the kinetic electron implicit solve. They all share the same parallelisation in the r-dimension so that the region type can be switched between 'anyzv' types within a loop over r (@loop_r).
The matrix-solve needed for the kinetic electron preconditioner is a bottleneck and requires a relatively large amount of communication so probably does not scale perfectly. To maximise parallelism, parallelise the r-dimension as much as possible before parallelising z/vperp/vpa.
This region type excludes the final point in the r-dimension, assuming that it will be filled in by a boundary condition or call to moment_kinetics.communication.halo_swap!.
moment_kinetics.looping.get_best_ranges — Method
Find the ranges for loop variables that optimize load balance for a certain block_size
moment_kinetics.looping.get_local_range — Method
Get local range of indices when splitting a loop over processes in a sub-block
moment_kinetics.looping.get_max_work — Method
Calculate the maximum number of grid points on any process
This is a measure of the maximum amount of work to do on a single process. Minimising this will make the parallelisation as efficient as possible.
Arguments
nprocslist : Vector{mkint} Number of processes for each dimension sizes : Vector{mk_int} Size of each dimension
moment_kinetics.looping.get_splits — Method
Find possible divisions of each number less than or equal to block_size into n factors.
moment_kinetics.looping.get_subblock_splits — Method
Find possible divisions of subblocksize into n factors
moment_kinetics.looping.setup_loop_ranges! — Method
Create ranges for loops with different combinations of variables
Arguments
Keyword arguments dim=n are required for each dim in [:s, :r, :z, :vperp, :vpa, :sn, :vzeta, :vr, :vz] where n is an integer giving the size of the dimension.
moment_kinetics.looping.@anysv_serial_region — Macro
Run a block of code on only anysv-subblock-rank-0 of each group of processes operating on an 'anysv' shared-memory subblock
moment_kinetics.looping.@anyzv_serial_region — Macro
Run a block of code on only anyzv-subblock-rank-0 of each group of processes operating on an 'anyzv' shared-memory subblock
moment_kinetics.looping.@begin_anysv_region — Macro
Begin 'anysv' sub-region in which () species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_s_region — Macro
Begin 'anysv' sub-region in which (:s,) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_s_vpa_region — Macro
Begin 'anysv' sub-region in which (:s, :vpa) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_s_vperp_region — Macro
Begin 'anysv' sub-region in which (:s, :vperp) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_s_vperp_vpa_region — Macro
Begin 'anysv' sub-region in which (:s, :vperp, :vpa) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_vpa_region — Macro
Begin 'anysv' sub-region in which (:vpa,) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_vperp_region — Macro
Begin 'anysv' sub-region in which (:vperp,) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anysv_vperp_vpa_region — Macro
Begin 'anysv' sub-region in which (:vperp, :vpa) species/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanysv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anysv_subblock_synchronize() to synchronize the processes operating on an 'anysv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_region — Macro
Begin 'anyzv' sub-region in which () z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_vpa_region — Macro
Begin 'anyzv' sub-region in which (:vpa,) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_vperp_region — Macro
Begin 'anyzv' sub-region in which (:vperp,) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_vperp_vpa_region — Macro
Begin 'anyzv' sub-region in which (:vperp, :vpa) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_z_region — Macro
Begin 'anyzv' sub-region in which (:z,) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_z_vpa_region — Macro
Begin 'anyzv' sub-region in which (:z, :vpa) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_z_vperp_region — Macro
Begin 'anyzv' sub-region in which (:z, :vperp) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_anyzv_z_vperp_vpa_region — Macro
Begin 'anyzv' sub-region in which (:z, :vperp, :vpa) z/velocity space dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @beginanyzv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _anyzv_subblock_synchronize() to synchronize the processes operating on an 'anyzv' shared-memory sub-block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_anyzv_region — Macro
Begin region in which r-dimension and z/velocity dimensions are parallelized by being split between processes, and which z/velocity dimensions are parallelized can be switched within the outer loop over r. This parallelization scheme is intended for use in the kinetic electron implicit solve.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.
moment_kinetics.looping.@begin_r_region — Macro
Begin region in which (:r,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vpa_region — Macro
Begin region in which (:r, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vperp_region — Macro
Begin region in which (:r, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vperp_vpa_region — Macro
Begin region in which (:r, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vr_region — Macro
Begin region in which (:r, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vr_vz_region — Macro
Begin region in which (:r, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vz_region — Macro
Begin region in which (:r, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vzeta_region — Macro
Begin region in which (:r, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vzeta_vr_region — Macro
Begin region in which (:r, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vzeta_vr_vz_region — Macro
Begin region in which (:r, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_vzeta_vz_region — Macro
Begin region in which (:r, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_anysv_region — Macro
Begin region in which (:r,:z) dimensions and species/velocity dimensions are parallelized by being split between processes, and which species/velocity dimensions are parallelized can be switched within the outer loop over (:r,:z). This parallelization scheme is intended for use in the collision operator.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.
moment_kinetics.looping.@begin_r_z_region — Macro
Begin region in which (:r, :z) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vpa_region — Macro
Begin region in which (:r, :z, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vperp_region — Macro
Begin region in which (:r, :z, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vperp_vpa_region — Macro
Begin region in which (:r, :z, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vr_region — Macro
Begin region in which (:r, :z, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vr_vz_region — Macro
Begin region in which (:r, :z, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vz_region — Macro
Begin region in which (:r, :z, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vzeta_region — Macro
Begin region in which (:r, :z, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vzeta_vr_region — Macro
Begin region in which (:r, :z, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vzeta_vr_vz_region — Macro
Begin region in which (:r, :z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_r_z_vzeta_vz_region — Macro
Begin region in which (:r, :z, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_region — Macro
Begin region in which (:s, :r) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_vpa_region — Macro
Begin region in which (:s, :r, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_vperp_region — Macro
Begin region in which (:s, :r, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_vperp_vpa_region — Macro
Begin region in which (:s, :r, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_z_region — Macro
Begin region in which (:s, :r, :z) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_z_vpa_region — Macro
Begin region in which (:s, :r, :z, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_z_vperp_region — Macro
Begin region in which (:s, :r, :z, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_r_z_vperp_vpa_region — Macro
Begin region in which (:s, :r, :z, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_region — Macro
Begin region in which (:s,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_vpa_region — Macro
Begin region in which (:s, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_vperp_region — Macro
Begin region in which (:s, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_vperp_vpa_region — Macro
Begin region in which (:s, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_z_region — Macro
Begin region in which (:s, :z) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_z_vpa_region — Macro
Begin region in which (:s, :z, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_z_vperp_region — Macro
Begin region in which (:s, :z, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_s_z_vperp_vpa_region — Macro
Begin region in which (:s, :z, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_serial_region — Macro
Begin region in which only rank-0 in each group of processes operating on a shared-memory block operates on shared-memory arrays.
Returns immediately if loopranges[] is already set for a serial region. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_region — Macro
Begin region in which (:sn, :r) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vr_region — Macro
Begin region in which (:sn, :r, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vr_vz_region — Macro
Begin region in which (:sn, :r, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vz_region — Macro
Begin region in which (:sn, :r, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vzeta_region — Macro
Begin region in which (:sn, :r, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vzeta_vr_region — Macro
Begin region in which (:sn, :r, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vzeta_vr_vz_region — Macro
Begin region in which (:sn, :r, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_vzeta_vz_region — Macro
Begin region in which (:sn, :r, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_region — Macro
Begin region in which (:sn, :r, :z) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vr_region — Macro
Begin region in which (:sn, :r, :z, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vr_vz_region — Macro
Begin region in which (:sn, :r, :z, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vz_region — Macro
Begin region in which (:sn, :r, :z, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vzeta_region — Macro
Begin region in which (:sn, :r, :z, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vzeta_vr_region — Macro
Begin region in which (:sn, :r, :z, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vzeta_vr_vz_region — Macro
Begin region in which (:sn, :r, :z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_r_z_vzeta_vz_region — Macro
Begin region in which (:sn, :r, :z, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_region — Macro
Begin region in which (:sn,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vr_region — Macro
Begin region in which (:sn, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vr_vz_region — Macro
Begin region in which (:sn, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vz_region — Macro
Begin region in which (:sn, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vzeta_region — Macro
Begin region in which (:sn, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vzeta_vr_region — Macro
Begin region in which (:sn, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vzeta_vr_vz_region — Macro
Begin region in which (:sn, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_vzeta_vz_region — Macro
Begin region in which (:sn, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_region — Macro
Begin region in which (:sn, :z) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vr_region — Macro
Begin region in which (:sn, :z, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vr_vz_region — Macro
Begin region in which (:sn, :z, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vz_region — Macro
Begin region in which (:sn, :z, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vzeta_region — Macro
Begin region in which (:sn, :z, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vzeta_vr_region — Macro
Begin region in which (:sn, :z, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vzeta_vr_vz_region — Macro
Begin region in which (:sn, :z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_sn_z_vzeta_vz_region — Macro
Begin region in which (:sn, :z, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vpa_region — Macro
Begin region in which (:vpa,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vperp_region — Macro
Begin region in which (:vperp,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vperp_vpa_region — Macro
Begin region in which (:vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vr_region — Macro
Begin region in which (:vr,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vr_vz_region — Macro
Begin region in which (:vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vz_region — Macro
Begin region in which (:vz,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vzeta_region — Macro
Begin region in which (:vzeta,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vzeta_vr_region — Macro
Begin region in which (:vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vzeta_vr_vz_region — Macro
Begin region in which (:vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_vzeta_vz_region — Macro
Begin region in which (:vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_region — Macro
Begin region in which (:z,) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vpa_region — Macro
Begin region in which (:z, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vperp_region — Macro
Begin region in which (:z, :vperp) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vperp_vpa_region — Macro
Begin region in which (:z, :vperp, :vpa) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vr_region — Macro
Begin region in which (:z, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vr_vz_region — Macro
Begin region in which (:z, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vz_region — Macro
Begin region in which (:z, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vzeta_region — Macro
Begin region in which (:z, :vzeta) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vzeta_vr_region — Macro
Begin region in which (:z, :vzeta, :vr) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vzeta_vr_vz_region — Macro
Begin region in which (:z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@begin_z_vzeta_vz_region — Macro
Begin region in which (:z, :vzeta, :vz) dimensions are parallelized by being split between processes.
Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the @begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).
Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless true is passed as the no_synchronize argument.
moment_kinetics.looping.@loop_r — Macro
Loop over (:r,) dimensions
moment_kinetics.looping.@loop_r_vpa — Macro
Loop over (:r, :vpa) dimensions
moment_kinetics.looping.@loop_r_vperp — Macro
Loop over (:r, :vperp) dimensions
moment_kinetics.looping.@loop_r_vperp_vpa — Macro
Loop over (:r, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_r_vr — Macro
Loop over (:r, :vr) dimensions
moment_kinetics.looping.@loop_r_vr_vz — Macro
Loop over (:r, :vr, :vz) dimensions
moment_kinetics.looping.@loop_r_vz — Macro
Loop over (:r, :vz) dimensions
moment_kinetics.looping.@loop_r_vzeta — Macro
Loop over (:r, :vzeta) dimensions
moment_kinetics.looping.@loop_r_vzeta_vr — Macro
Loop over (:r, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_r_vzeta_vr_vz — Macro
Loop over (:r, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_r_vzeta_vz — Macro
Loop over (:r, :vzeta, :vz) dimensions
moment_kinetics.looping.@loop_r_z — Macro
Loop over (:r, :z) dimensions
moment_kinetics.looping.@loop_r_z_vpa — Macro
Loop over (:r, :z, :vpa) dimensions
moment_kinetics.looping.@loop_r_z_vperp — Macro
Loop over (:r, :z, :vperp) dimensions
moment_kinetics.looping.@loop_r_z_vperp_vpa — Macro
Loop over (:r, :z, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_r_z_vr — Macro
Loop over (:r, :z, :vr) dimensions
moment_kinetics.looping.@loop_r_z_vr_vz — Macro
Loop over (:r, :z, :vr, :vz) dimensions
moment_kinetics.looping.@loop_r_z_vz — Macro
Loop over (:r, :z, :vz) dimensions
moment_kinetics.looping.@loop_r_z_vzeta — Macro
Loop over (:r, :z, :vzeta) dimensions
moment_kinetics.looping.@loop_r_z_vzeta_vr — Macro
Loop over (:r, :z, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_r_z_vzeta_vr_vz — Macro
Loop over (:r, :z, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_r_z_vzeta_vz — Macro
Loop over (:r, :z, :vzeta, :vz) dimensions
moment_kinetics.looping.@loop_s — Macro
Loop over (:s,) dimensions
moment_kinetics.looping.@loop_s_r — Macro
Loop over (:s, :r) dimensions
moment_kinetics.looping.@loop_s_r_vpa — Macro
Loop over (:s, :r, :vpa) dimensions
moment_kinetics.looping.@loop_s_r_vperp — Macro
Loop over (:s, :r, :vperp) dimensions
moment_kinetics.looping.@loop_s_r_vperp_vpa — Macro
Loop over (:s, :r, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_s_r_z — Macro
Loop over (:s, :r, :z) dimensions
moment_kinetics.looping.@loop_s_r_z_vpa — Macro
Loop over (:s, :r, :z, :vpa) dimensions
moment_kinetics.looping.@loop_s_r_z_vperp — Macro
Loop over (:s, :r, :z, :vperp) dimensions
moment_kinetics.looping.@loop_s_r_z_vperp_vpa — Macro
Loop over (:s, :r, :z, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_s_vpa — Macro
Loop over (:s, :vpa) dimensions
moment_kinetics.looping.@loop_s_vperp — Macro
Loop over (:s, :vperp) dimensions
moment_kinetics.looping.@loop_s_vperp_vpa — Macro
Loop over (:s, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_s_z — Macro
Loop over (:s, :z) dimensions
moment_kinetics.looping.@loop_s_z_vpa — Macro
Loop over (:s, :z, :vpa) dimensions
moment_kinetics.looping.@loop_s_z_vperp — Macro
Loop over (:s, :z, :vperp) dimensions
moment_kinetics.looping.@loop_s_z_vperp_vpa — Macro
Loop over (:s, :z, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_sn — Macro
Loop over (:sn,) dimensions
moment_kinetics.looping.@loop_sn_r — Macro
Loop over (:sn, :r) dimensions
moment_kinetics.looping.@loop_sn_r_vr — Macro
Loop over (:sn, :r, :vr) dimensions
moment_kinetics.looping.@loop_sn_r_vr_vz — Macro
Loop over (:sn, :r, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_vz — Macro
Loop over (:sn, :r, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_vzeta — Macro
Loop over (:sn, :r, :vzeta) dimensions
moment_kinetics.looping.@loop_sn_r_vzeta_vr — Macro
Loop over (:sn, :r, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_sn_r_vzeta_vr_vz — Macro
Loop over (:sn, :r, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_vzeta_vz — Macro
Loop over (:sn, :r, :vzeta, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_z — Macro
Loop over (:sn, :r, :z) dimensions
moment_kinetics.looping.@loop_sn_r_z_vr — Macro
Loop over (:sn, :r, :z, :vr) dimensions
moment_kinetics.looping.@loop_sn_r_z_vr_vz — Macro
Loop over (:sn, :r, :z, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_z_vz — Macro
Loop over (:sn, :r, :z, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_z_vzeta — Macro
Loop over (:sn, :r, :z, :vzeta) dimensions
moment_kinetics.looping.@loop_sn_r_z_vzeta_vr — Macro
Loop over (:sn, :r, :z, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_sn_r_z_vzeta_vr_vz — Macro
Loop over (:sn, :r, :z, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_r_z_vzeta_vz — Macro
Loop over (:sn, :r, :z, :vzeta, :vz) dimensions
moment_kinetics.looping.@loop_sn_vr — Macro
Loop over (:sn, :vr) dimensions
moment_kinetics.looping.@loop_sn_vr_vz — Macro
Loop over (:sn, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_vz — Macro
Loop over (:sn, :vz) dimensions
moment_kinetics.looping.@loop_sn_vzeta — Macro
Loop over (:sn, :vzeta) dimensions
moment_kinetics.looping.@loop_sn_vzeta_vr — Macro
Loop over (:sn, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_sn_vzeta_vr_vz — Macro
Loop over (:sn, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_vzeta_vz — Macro
Loop over (:sn, :vzeta, :vz) dimensions
moment_kinetics.looping.@loop_sn_z — Macro
Loop over (:sn, :z) dimensions
moment_kinetics.looping.@loop_sn_z_vr — Macro
Loop over (:sn, :z, :vr) dimensions
moment_kinetics.looping.@loop_sn_z_vr_vz — Macro
Loop over (:sn, :z, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_z_vz — Macro
Loop over (:sn, :z, :vz) dimensions
moment_kinetics.looping.@loop_sn_z_vzeta — Macro
Loop over (:sn, :z, :vzeta) dimensions
moment_kinetics.looping.@loop_sn_z_vzeta_vr — Macro
Loop over (:sn, :z, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_sn_z_vzeta_vr_vz — Macro
Loop over (:sn, :z, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_sn_z_vzeta_vz — Macro
Loop over (:sn, :z, :vzeta, :vz) dimensions
moment_kinetics.looping.@loop_vpa — Macro
Loop over (:vpa,) dimensions
moment_kinetics.looping.@loop_vperp — Macro
Loop over (:vperp,) dimensions
moment_kinetics.looping.@loop_vperp_vpa — Macro
Loop over (:vperp, :vpa) dimensions
moment_kinetics.looping.@loop_vr — Macro
Loop over (:vr,) dimensions
moment_kinetics.looping.@loop_vr_vz — Macro
Loop over (:vr, :vz) dimensions
moment_kinetics.looping.@loop_vz — Macro
Loop over (:vz,) dimensions
moment_kinetics.looping.@loop_vzeta — Macro
Loop over (:vzeta,) dimensions
moment_kinetics.looping.@loop_vzeta_vr — Macro
Loop over (:vzeta, :vr) dimensions
moment_kinetics.looping.@loop_vzeta_vr_vz — Macro
Loop over (:vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_vzeta_vz — Macro
Loop over (:vzeta, :vz) dimensions
moment_kinetics.looping.@loop_z — Macro
Loop over (:z,) dimensions
moment_kinetics.looping.@loop_z_vpa — Macro
Loop over (:z, :vpa) dimensions
moment_kinetics.looping.@loop_z_vperp — Macro
Loop over (:z, :vperp) dimensions
moment_kinetics.looping.@loop_z_vperp_vpa — Macro
Loop over (:z, :vperp, :vpa) dimensions
moment_kinetics.looping.@loop_z_vr — Macro
Loop over (:z, :vr) dimensions
moment_kinetics.looping.@loop_z_vr_vz — Macro
Loop over (:z, :vr, :vz) dimensions
moment_kinetics.looping.@loop_z_vz — Macro
Loop over (:z, :vz) dimensions
moment_kinetics.looping.@loop_z_vzeta — Macro
Loop over (:z, :vzeta) dimensions
moment_kinetics.looping.@loop_z_vzeta_vr — Macro
Loop over (:z, :vzeta, :vr) dimensions
moment_kinetics.looping.@loop_z_vzeta_vr_vz — Macro
Loop over (:z, :vzeta, :vr, :vz) dimensions
moment_kinetics.looping.@loop_z_vzeta_vz — Macro
Loop over (:z, :vzeta, :vz) dimensions
moment_kinetics.looping.@serial_region — Macro
Run a block of code on only rank-0 of each group of processes operating on a shared-memory block