inter_box_creation.F File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	inter_box_creation (nb_cell_x, nb_cell_y, nb_cell_z, box_limit)

Function/Subroutine Documentation

inter_box_creation()

subroutine inter_box_creation	(	integer, intent(inout)	nb_cell_x,
		integer, intent(inout)	nb_cell_y,
		integer, intent(inout)	nb_cell_z,
		intent(inout)	box_limit )

Parameters

[in,out]	nb_cell_x	number of cell in the x direction
[in,out]	nb_cell_y	number of cell in the y direction
[in,out]	nb_cell_z	number of cell in the z direction

Definition at line 31 of file inter_box_creation.F.

!$COMMENT
!       INTER_BOX_CREATION description :
!       creation of the global box
!
!       INTER_BOX_CREATION organization :
!           * compute the size dx/dy/dz in each direction
!           * choose the largest size
!           * compute the cell's size
!           * compute the number of cell for each direction
!$ENDCOMMENT
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
        USE inter_sorting_mod , ONLY : nb_box_coarse_grid,nb_box_limit
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
#include      "comlock.inc"
C-----------------------------------------------
C   C o m m o n   B l o c k s
C-----------------------------------------------
#include      "spmd_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
        integer, intent(inout) :: nb_cell_x !< number of cell in the x direction
        integer, intent(inout) :: nb_cell_y !< number of cell in the y direction
        integer, intent(inout) :: nb_cell_z !< number of cell in the z direction
        my_real, dimension(6), intent(inout) :: box_limit !< upper & lower bound of the box
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        INTEGER :: LEADING_DIMENSION
        my_real :: dx_box,dy_box,dz_box
        my_real :: ratio,size_cell,dist_max
!   ----------------------------------------
 
        !   ------------------
        !   Create the box : 
        !   number of cell = [ tota_number_of_node / ( dx*dy + dx*dz+dy*dz ) ]**(1/2) * dx or dy or dz
        !   1 < number of cell < 128 
        
        !   find the leading direction
        dx_box = abs(box_limit(1) - box_limit(4))
        dy_box = abs(box_limit(2) - box_limit(5))
        dz_box = abs(box_limit(3) - box_limit(6))
        
        dist_max = max(dx_box,dy_box,dz_box)
        IF(dist_max==dx_box) leading_dimension = 1
        IF(dist_max==dy_box) leading_dimension = 2
        IF(dist_max==dz_box) leading_dimension = 3
        
        !   compute the number of cell in the leading direction, then compute the number of cell in the other direction
        ratio = sqrt( numnodg / (dx_box*dy_box+dx_box*dz_box+dy_box*dz_box))
        IF(leading_dimension==1) THEN
            nb_cell_x = nint( ratio * dx_box )
            nb_cell_x = max(nb_cell_x,nb_box_coarse_grid)     
            nb_cell_x = nb_cell_x - modulo(nb_cell_x,4)           
            nb_cell_x = min(nb_cell_x,nb_box_limit)
            nb_cell_x = max(nb_cell_x,nb_box_coarse_grid)
 
            size_cell = dx_box / nb_cell_x
 
            nb_cell_y = nint( dy_box / size_cell )
            nb_cell_y = max(nb_cell_y,nb_box_coarse_grid)
            nb_cell_y = nb_cell_y - modulo(nb_cell_y,4)                 
            nb_cell_y = min(nb_cell_y,nb_box_limit)
            nb_cell_y = max(nb_cell_y,nb_box_coarse_grid)
 
            nb_cell_z = nint( dz_box / size_cell )
            nb_cell_z = max(nb_cell_z,nb_box_coarse_grid)
            nb_cell_z = nb_cell_z - modulo(nb_cell_z,4)
            nb_cell_z = min(nb_cell_z,nb_box_limit)
            nb_cell_z = max(nb_cell_z,nb_box_coarse_grid)
        ELSEIF(leading_dimension==2) THEN
            nb_cell_y = nint( ratio * dy_box )
            nb_cell_y = max(nb_cell_y,nb_box_coarse_grid)         
            nb_cell_y = nb_cell_y - modulo(nb_cell_y,4)   
            nb_cell_y = min(nb_cell_y,nb_box_limit)
            nb_cell_y = max(nb_cell_y,nb_box_coarse_grid)
 
            size_cell = dy_box / nb_cell_y
 
            nb_cell_x = nint( dx_box / size_cell )
            nb_cell_x = max(nb_cell_x,nb_box_coarse_grid)
            nb_cell_x = nb_cell_x - modulo(nb_cell_x,4)    
            nb_cell_x = min(nb_cell_x,nb_box_limit)
            nb_cell_x = max(nb_cell_x,nb_box_coarse_grid)
 
            nb_cell_z = nint( dz_box / size_cell )
            nb_cell_z = max(nb_cell_z,nb_box_coarse_grid)
            nb_cell_z = nb_cell_z - modulo(nb_cell_z,4)
            nb_cell_z = min(nb_cell_z,nb_box_limit)
            nb_cell_z = max(nb_cell_z,nb_box_coarse_grid)
        ELSEIF(leading_dimension==3) THEN
            nb_cell_z = nint( ratio * dz_box )
            nb_cell_z = max(nb_cell_z,nb_box_coarse_grid)
            nb_cell_z = nb_cell_z - modulo(nb_cell_z,4)  
            nb_cell_z = min(nb_cell_z,nb_box_limit)
            nb_cell_z = max(nb_cell_z,nb_box_coarse_grid)
 
            size_cell = dz_box / nb_cell_z
 
            nb_cell_y = nint( dy_box / size_cell )
            nb_cell_y = max(nb_cell_y,nb_box_coarse_grid)
            nb_cell_y = nb_cell_y - modulo(nb_cell_y,4)  
            nb_cell_y = min(nb_cell_y,nb_box_limit)
            nb_cell_y = max(nb_cell_y,nb_box_coarse_grid)
 
            nb_cell_x = nint( dx_box / size_cell )
            nb_cell_x = max(nb_cell_x,nb_box_coarse_grid)
            nb_cell_x = nb_cell_x - modulo(nb_cell_x,4)  
            nb_cell_x = min(nb_cell_x,nb_box_limit)
            nb_cell_x = max(nb_cell_x,nb_box_coarse_grid)
        ENDIF
        !   ------------------
 
        RETURN