looping

Provides convenience macros for shared-memory-parallel loops

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.

Construct a string composed of the dimension names given in the Tuple dims, separated by underscores

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.

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!.

Find the ranges for loop variables that optimize load balance for a certain block_size

Get local range of indices when splitting a loop over processes in a sub-block

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

Find possible divisions of each number less than or equal to block_size into n factors.

Find possible divisions of subblocksize into n factors

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.

Run a block of code on only anysv-subblock-rank-0 of each group of processes operating on an 'anysv' shared-memory subblock

Run a block of code on only anyzv-subblock-rank-0 of each group of processes operating on an 'anyzv' shared-memory subblock

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Loop over (:r,) dimensions

Loop over (:r, :vpa) dimensions

Loop over (:r, :vperp) dimensions

Loop over (:r, :vperp, :vpa) dimensions

Loop over (:r, :vr) dimensions

Loop over (:r, :vr, :vz) dimensions

Loop over (:r, :vz) dimensions

Loop over (:r, :vzeta) dimensions

Loop over (:r, :vzeta, :vr) dimensions

Loop over (:r, :vzeta, :vr, :vz) dimensions

Loop over (:r, :vzeta, :vz) dimensions

Loop over (:r, :z) dimensions

Loop over (:r, :z, :vpa) dimensions

Loop over (:r, :z, :vperp) dimensions

Loop over (:r, :z, :vperp, :vpa) dimensions

Loop over (:r, :z, :vr) dimensions

Loop over (:r, :z, :vr, :vz) dimensions

Loop over (:r, :z, :vz) dimensions

Loop over (:r, :z, :vzeta) dimensions

Loop over (:r, :z, :vzeta, :vr) dimensions

Loop over (:r, :z, :vzeta, :vr, :vz) dimensions

Loop over (:r, :z, :vzeta, :vz) dimensions

Loop over (:s,) dimensions

Loop over (:s, :r) dimensions

Loop over (:s, :r, :vpa) dimensions

Loop over (:s, :r, :vperp) dimensions

Loop over (:s, :r, :vperp, :vpa) dimensions

Loop over (:s, :r, :z) dimensions

Loop over (:s, :r, :z, :vpa) dimensions

Loop over (:s, :r, :z, :vperp) dimensions

Loop over (:s, :r, :z, :vperp, :vpa) dimensions

Loop over (:s, :vpa) dimensions

Loop over (:s, :vperp) dimensions

Loop over (:s, :vperp, :vpa) dimensions

Loop over (:s, :z) dimensions

Loop over (:s, :z, :vpa) dimensions

Loop over (:s, :z, :vperp) dimensions

Loop over (:s, :z, :vperp, :vpa) dimensions

Loop over (:sn,) dimensions

Loop over (:sn, :r) dimensions

Loop over (:sn, :r, :vr) dimensions

Loop over (:sn, :r, :vr, :vz) dimensions

Loop over (:sn, :r, :vz) dimensions

Loop over (:sn, :r, :vzeta) dimensions

Loop over (:sn, :r, :vzeta, :vr) dimensions

Loop over (:sn, :r, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :r, :vzeta, :vz) dimensions

Loop over (:sn, :r, :z) dimensions

Loop over (:sn, :r, :z, :vr) dimensions

Loop over (:sn, :r, :z, :vr, :vz) dimensions

Loop over (:sn, :r, :z, :vz) dimensions

Loop over (:sn, :r, :z, :vzeta) dimensions

Loop over (:sn, :r, :z, :vzeta, :vr) dimensions

Loop over (:sn, :r, :z, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :r, :z, :vzeta, :vz) dimensions

Loop over (:sn, :vr) dimensions

Loop over (:sn, :vr, :vz) dimensions

Loop over (:sn, :vz) dimensions

Loop over (:sn, :vzeta) dimensions

Loop over (:sn, :vzeta, :vr) dimensions

Loop over (:sn, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :vzeta, :vz) dimensions

Loop over (:sn, :z) dimensions

Loop over (:sn, :z, :vr) dimensions

Loop over (:sn, :z, :vr, :vz) dimensions

Loop over (:sn, :z, :vz) dimensions

Loop over (:sn, :z, :vzeta) dimensions

Loop over (:sn, :z, :vzeta, :vr) dimensions

Loop over (:sn, :z, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :z, :vzeta, :vz) dimensions

Loop over (:vpa,) dimensions

Loop over (:vperp,) dimensions

Loop over (:vperp, :vpa) dimensions

Loop over (:vr,) dimensions

Loop over (:vr, :vz) dimensions

Loop over (:vz,) dimensions

Loop over (:vzeta,) dimensions

Loop over (:vzeta, :vr) dimensions

Loop over (:vzeta, :vr, :vz) dimensions

Loop over (:vzeta, :vz) dimensions

Loop over (:z,) dimensions

Loop over (:z, :vpa) dimensions

Loop over (:z, :vperp) dimensions

Loop over (:z, :vperp, :vpa) dimensions

Loop over (:z, :vr) dimensions

Loop over (:z, :vr, :vz) dimensions

Loop over (:z, :vz) dimensions

Loop over (:z, :vzeta) dimensions

Loop over (:z, :vzeta, :vr) dimensions

Loop over (:z, :vzeta, :vr, :vz) dimensions

Loop over (:z, :vzeta, :vz) dimensions

Run a block of code on only rank-0 of each group of processes operating on a shared-memory block