MESH
- subroutine restrict_block has been rewritten to use one big array for
storage variables from all children and them restricting this array
and putting resulted variables in a new data block;
BOUNDARY CONDITIONS
- remove the third argument from all calls of the subroutine shrink();
INTERPOLATION
- remove ng argument from subroutines shrink() and shrink_1d();
- small fixes to subroutine magtocen() in the divergence free
correction calculation;
MESH
- fix index calculation and remove the third argument from calling the
subroutine shrink();
BOUNDARY CONDITIONS
- rewrite subroutine bnd_prol() and use expand_mag() in it;
- fix some index calculations in bnd_rest();
INTERPOLATION
- implement new subroutine expand_mag() performing divergence-free
prolongation of the staggered magnetic field;
- implement divergence-free correction in interpolation of cell
centered magnetic field in subroutine magtocen();
MESH
- use new subroutine expand_mag() in block prolongation;
BOUNDARY CONDITIONS
- rewrite bnd_copy() so first the indices are prepared and then there
is one call to fill out the destination array; include the lower
index change for staggered magnetic field components;
- in the subroutine bnd_rest() implement correct restriction of the
staggered magnetic field components; take into account the change
of the lower index;
- in the subroutine bnd_prol() implement correct prolongation of the
staggered magnetic field components; take into account the change of
the lowe index;
- by default use 2 ghost cell and the restriction and expansion to
prevent errors resulting from interpolation;
CONFIGURATION
- enforce a lower limit for number of ghost zones to 6 when MHD=Y and
4 otherwise
INTERPOLATION
- remove unnecessary interpolation methods
- limit 'c' interpolation to the second order only
MESH
- implement divergence-free prolongation and restriction for the
staggered magnetic field components in the block refinement and
derefinement
SCHEME
- implement Flux-CT scheme for the staggered magnetic field
integration;
BLOCK STRUCTURE
- use more space efficient storage of the variables, which means
storing only staggered components of magnetic field; cell-centered
components are calculated only when necessary;
EVOLUTION
- remove loops in the field updates; operations are performed on the
arrays;
BOUNDARY CONDITIONS
- remove loops in the bnd_copy; operations are calculated on the whole
array now;
INTERPOLATION
- subroutine magtocen() has been rewritten to avoid problems with the
array allocation; now as an argument we enter the array of all
variables; subroutine uses indices for the face-centered and
cell-centered magnetic field components internally;
MAKE
- add flag defining Flux-CT scheme;
PROBLEM
- use predefined array variables instead of allocated;
Rewritten boundaries allow for a proper handling boundaries between
blocks at different refinement levels. Prolongation and restriction of
the boundaries are improved now.
Rewritten interpolation for prolongation and restriction.
References to the variable indices are assigned more properly.
MESH REFINEMENT, INITIAL GEOMETRY
- if there is only one block and it is set not to be refined, refine it
anyway to catch situations when the initial resolution is too small
for the problem initiation
MESH STRUCTURE, REFINEMENT
- subroutine prolong_block() has been completely rewritten; now it
supports 2D and 3D boxes, and the calculation of bounds for the
expanded array is automated now
MESH STRUCTURE, DEREFINEMENT
- subroutine restrict_block() has been completely rewritten; now it
supports 2D and 3D boxes, and the calculation of bounds for
source and destination arrays is automated
FIXES
- the field neigh of meta blocks structure must use ndims, nsides, and
nfaces variables
BLOCK STRUCTURE
- use pmeta and pdata names for ponters to meta and data blocks,
respectively; this helps reading the code
HOSTS
- turn on DEBUG
MESH STRUCTURE, MPI
- implement auto balancing, which resends the blocks to the neighboring
processors in order to keep the same number of data blocks on each
processor
MESH STRUCTURE, MPI
- correct the initial division of the geometry, so each process is
attached to the same number of blocks; blocks at the top level are
allowed to be attached to different processors even if they are
children of the same block
MESH STRUCTURE, MPI
- if the child blocks are selected to be derefined and lay on different
processors, move them all to the processor of the parent block
BLOCK STRUCTURE, MPI
- in the best division calculation use the number of data blocs only,
but if the blocks are at the top level and have the same parent
pack then together in the same process
MESH STRUCTURES
- since blocks which are not leafs are not used to calculate the fields
evolution, we don't need to keep their data blocks allocated; these
changes allocated the parent data block only for blocks which are
derefined, and deallocates data block of a block selected for
refinement; in the case of many blocks and many refinement levels
these modifications safe a substantial amount of memory
PROBLEMS
- implement the blast problem in a similar way to the one implemented
in GODUNOV code
- generate initial domain of 2x3 blocks at the lowest level; it should
be generalized to any dimension of blocks
MESH STRUCTURE
- add new variable rdims(1:3) specifying dimensions of the initial
blocks structure at lowest level
- improve calculation of the effective resolution, and spatial
increments
MESH STRUCTURE
- subroutine mesh_update() performs refinement/derefinement of blocks
using new structures of meta and data blocks; it is implemented for
to be MPI friendly as well
- update subroutine derefine_block() to use new structures of meta and
data blocks
- update subroutines restrict_block() and prolong_block() to use new
meta and data structures
BLOCK STRUCTURE: MPI
- divide initial block structure between all processors and remove
non-local data blocks
DATA I/O
- dump the total number of blocks and the number of data blocks
BOUNDARY CONDITIONS
- initial work on the boundary condition for new structure of blocks
MESH STRUCTURE
- with new meta and data block structures the refinement of a block
works correctly now
- increase and decrease the number of blocks while allocated and
dealocated, respectively
REFINEMENT
- move the bounds for the criterion calculation by one cell out of the
domain, so we catch the refinement before it gradients enter the
block
MAINTANCE
- remove junk code from the update_mesh subroutine
The initial block mesh refinement seems to be optimized now. However,
more work in the MPI version is required, e.g. refine blocks on all CPUs
until the number of blocks exceeds some number dependent on the number
of CPUs. From that point refine independently on each CPU.
The initial work on the mesh update has been done too, but the processes
do not exchange block information.
This next approach to select blocks for refinement/derefinement with MPI
seems to be working. Moreover, it is simple and efficient, however,
there might be still some room for improvements.
It seems to be pretty complex. So far I collect blocks selected for
refinement which have neighbors laying on other processors. Using this I
set the neighbors from other processors for refinement if required. The
remaining things are the neighbors update after refinement and MPI
version of derefinement.
The boundary conditions finally works when using MPI with arbitrary
number of processors. This is however a dirty hack. Has to be done in a
better way later, since now it may be very tricky to generalize the code
to 3D.
The next time step should be reduced to the minimum value over all
processes. This has been added in subroutine 'evolution' now.
The block structure contains a new field %pos which specifies the
position of the child block in its parent.
The blocks of initial mesh are now divided between all processes. The
procedure updates also the %cpu field of all neighbors according to the
number of process they are running at.
The subroutine 'deallocate_block' takes care about the plist pointer
now. It also allows for the flexible removal of any block, even from the
middle of the list by updating fields %next and %prev of the previous
and next blocks, respectively.
In addition, we now store the %cpu field of each block in the HDF5 files
too.
The domain initialization is performed in the problem.F90 now. This will
allow a user to initialize his own domain according to the defined
problem. Since the initialization in problem-dependent we don't need the
subroutine allocate_blocks anymore.
A new 'mpitools' module has been added. This module contains subroutines
to initialize, deinitialize and handle MPI communication. This initial
version can now initialize and deinitialize parallelization. It does not
support full parallelization yet.
We use the field 'neigh' instead of the field 'pneigh'. The field
'neigh' is of the type of 'blockref' which simplifies the reference to
the neighbors blocks when using MPI. Each reference contains two fields:
cpu and id. In MPI version we cannot use pointers stored in pneigh, but
using blockref structures we can refer to the blocks belonging to other
processors.
The new type 'blockref' is a reference to a block by two integer
numbers, the first points to the cpu that block is running, and the
second one is the block identificator.
The generation of dx, dy, dz for each level didn't include the base
grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of
minor corrections in different places.