!----------------------------------------------------------------- ! tree module module tree use paramesh_dimensions private public :: maxblocks_tr public :: nchild, nfaces, mchild, mfaces, mdim, mflags public :: nboundaries, mboundaries ! Block limit to be used in manipulating tree when modifying the grid. integer, parameter :: maxblocks_tr=4*maxblocks ! Number of children of a node integer, parameter :: nchild=2**ndim ! Number of faces on a grid block integer, parameter :: nfaces=2*ndim ! Parameters used to define array sizes integer, parameter :: mdim=3,mchild=2**mdim,mfaces=2*mdim ! Parameters used to declare the number of block marker flags needed integer, parameter :: mflags=1 !<<<< USER EDIT ! Parameters used to declare the number of boundary regions where boundary ! conditions are to be applied integer, parameter :: nboundaries=2*ndim !<<<< USER EDIT integer, parameter :: mboundaries=2*mdim public :: neigh,child,which_child public :: parent,lrefine,lnblocks,new_lnblocks public :: nodetype,empty,bflags,newchild,derefine,refine public :: stay,work_block,coord,bsize,bnd_box public :: grid_xmin,grid_xmax,grid_ymin,grid_ymax public :: grid_zmin,grid_zmax public :: lrefine_max,lrefine_min ! Variables for storing tree datastructure integer, save :: neigh(2,mfaces,maxblocks_tr) integer, save :: child(2,mchild,maxblocks_tr) integer, save :: which_child(maxblocks_tr) integer, save :: parent(2,maxblocks_tr),lrefine(maxblocks_tr) integer, save :: lnblocks,new_lnblocks integer, save :: nodetype(maxblocks_tr) integer, save :: empty(maxblocks_tr),bflags(mflags,maxblocks_tr) logical, save :: newchild(maxblocks_tr) logical, save :: derefine(maxblocks_tr),refine(maxblocks_tr) logical, save :: stay(maxblocks_tr) real, save :: work_block(maxblocks_tr) real, save :: coord(mdim,maxblocks_tr) real, save :: bsize(mdim,maxblocks_tr) real, save :: bnd_box(2,mdim,maxblocks_tr) real,save :: grid_xmin,grid_xmax real,save :: grid_ymin,grid_ymax real,save :: grid_zmin,grid_zmax integer, save :: lrefine_max,lrefine_min ! flag to record grid change public :: grid_changed integer, save :: grid_changed ! added for surrblks calculation with mpi public :: boundary_box,boundary_index real, save :: boundary_box(2,mdim,mboundaries) integer, save :: boundary_index(mboundaries) ! added for use with mpi block buffering public :: strt_buffer,last_buffer public :: strt_buffer_tree,last_buffer_tree public :: laddress,surr_blks integer, save :: strt_buffer,last_buffer integer, save :: strt_buffer_tree,last_buffer_tree integer, save :: laddress(1:2,1:maxblocks_alloc) integer, save :: surr_blks(2,3,1+2*k2d,1+2*k3d,maxblocks_alloc) !-------------------------------------------- ! ! A convention is established for numbering the neighbors (or faces ! of a block. The first neighbor is at lower x coordinate, the ! second at higher x, the third at lower y, fourth at higher y, fifth ! at lower z and the sixth at higher z. ! ! The convention by which the children of a block are numbered is the ! same as the fortran array ordering, so that the first child is ! at lower x, y and z coordinate, the second child is at upper x ! but lower y and z, the third is at lower x, upper y and lower z, ! and so on. ! ! When a block has a refined neighbor we will need to know which children ! of this neighbor are to provide guard cell information. The id's of the ! correct children are stored in kchild using the conventions described ! above. For example, if we are working on the 3rd neighbor of the ! current block and it is at finer refinement level, then we must access ! the children designated by kchild(:,3), in this case children 1, 2, 5 ! and 6. !-------------------------------------------- ! ! ! Description: ! This is the include file for a quad or oct-tree data structure,

! implemented on a parallel computer.

!

! The tree organizes a set of up to maxblocks_tr grids on each processor.

! All the grids are assumed to be cartesian with a uniform size. Each

! grid has a level of refinement associated with it. The set of level 0

! grids cover the computational domain without overlap. Each grid

! can be the parent of 2**d offspring grids which completely cover

! the sub-domain of their parents, where d is the physical dimension

! of the simulation. The linear resolution varies by a factor of 2

! between successive levels of refinement. At no point do we allow the

! resolution to jump by more than one level of refinement.

!

!

! In the following list the index i ranges from 1 to maxblocks.

!

! neigh(2,mfaces,i) local and processor ids of block i's neighbors,

! at i's refinement level. If a neighbor does

! not exist both values are set to -1, unless

! that face is at an external domain boundary

! where non-periodic boundary conditions are to

! be applied, in which case these are set to -20

! or less, depending on the boundary conditions

! to be applied on the boundary in question.

! child(2,mchild,i) local and processor ids of block i's children

! parent(2,i) local and processor ids of block i's parent

! coord(mdim,i) array storing x,y and z coordinates of the

! center of block i.

! bnd_box(2,mdim,i) bounding box information for block i. The

! lower edge of block i along the j-th coordinate

! axis is at bnd_box(1,j,i) and the upper edge

! at bnd_box(2,j,i).

! bsize(mdim,i) size of block i in the x, y and z directions.

! lrefine(i) refinement level of block i.

! nodetype(i) defines the node type, if 1 then the node is a

! leaf node, if 2 then the node is a parent but

! with at least 1 leaf child, otherwise it is

! set to 3 and it does not have any up-to-date

! data.

! empty(i) used to designate empty blocks, for example

! when an obstacle is inserted inside the

! computational domain. normal blocks have

! empty=0, empty blocks have empty=1.

!

! bflags(mflags,i) an array of integer flags which can be used

! to control computation on the grid blocks

! and which are inherited by children from

! their parents.

!

! which_child(i) an integer identifying which part of the

! parents volume this child corresponds to.

! new_child(i) if true then child has just been produced by

! a refinement step, otherwise false.

! lnblocks number of blocks on the local processor

! new_lnblocks the new number of blocks on the local

! processor after a refinement or derefinement

! step.

! refine(i) refinement flag. If set to .true. block i

! will be refined during the next call to

! REFINE_DEREFINE.

! derefine(i) derefinement flag. If set to .true. block i

! will be derefined during the next call to

! REFINE_DEREFINE, provided this blocks parent

! is not marked for refinement.

! stay(i) indicates block i refinement level unchanged.

! work_block() stores workload weighting associated with block i

!

!

!-----------------------------------------------------------------

end module tree