ale_box_creation.F File Reference

#include "implicit_f.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	ale_box_creation (nb_box_limit, nb_cell_x, nb_cell_y, nb_cell_z, ale_element_number, element_size, min_max_position, leading_dimension, size_cell)

Function/Subroutine Documentation

ale_box_creation()

subroutine ale_box_creation	(	integer, intent(in)	nb_box_limit,
		integer, intent(inout)	nb_cell_x,
		integer, intent(inout)	nb_cell_y,
		integer, intent(inout)	nb_cell_z,
		integer, intent(in)	ale_element_number,
		intent(inout)	element_size,
		intent(inout)	min_max_position,
		integer, intent(inout)	leading_dimension,
		intent(inout)	size_cell )

Definition at line 28 of file ale_box_creation.F.

!$COMMENT
!       ALE_BOX_CREATION description
!       creation of a grid with (NB_CELL_X,NB_CELL_Y,NB_CELL_Z) cells
!       
!       ALE_BOX_CREATION organization :
!       - a direction is chosen 
!       - the number of cell in this direction is computed
!       - then the number of cell in other directions are computed
!$ENDCOMMENT
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include "implicit_f.inc"
C-----------------------------------------------
C   C o m m o n   B l o c k s
C-----------------------------------------------
 
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
        INTEGER, INTENT(IN) :: NB_BOX_LIMIT
        INTEGER, INTENT(INOUT) :: NB_CELL_X,NB_CELL_Y,NB_CELL_Z
        INTEGER, INTENT(IN) :: ALE_ELEMENT_NUMBER ! number of ale element with material 51 or 151
        my_real, INTENT(INOUT) :: element_size ! max element size
        my_real, DIMENSION(6), INTENT(INOUT) :: min_max_position ! min/max position
        INTEGER, INTENT(INOUT) :: LEADING_DIMENSION
        my_real, DIMENSION(3), INTENT(INOUT) :: size_cell ! cell's size in x/y/z direction
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        my_real :: dx_box,dy_box,dz_box
        my_real :: ratio,dist_max,local_size_cell
C-----------------------------------------------
        element_size = sqrt(three) * element_size
        leading_dimension = 0
        min_max_position(1:3) = min_max_position(1:3) - em10
        min_max_position(4:6) = min_max_position(4:6) + em10
        !   find the leading direction
        dx_box = abs(min_max_position(1) - min_max_position(4))
        dy_box = abs(min_max_position(2) - min_max_position(5))
        dz_box = abs(min_max_position(3) - min_max_position(6))
        
        IF(dx_box == 2*ep30)dx_box=zero ! y,z plane
        IF(dy_box == 2*ep30)dy_box=zero ! x,z plane
        IF(dz_box == 2*ep30)dz_box=zero ! x,y plane        
                
        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( ale_element_number / (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 = min(nb_cell_x,nb_box_limit)
 
            local_size_cell = dx_box / nb_cell_x
            IF(local_size_cell<element_size) THEN 
                local_size_cell = element_size
                nb_cell_x = nint( dx_box / local_size_cell )             
                nb_cell_x = min(nb_cell_x,nb_box_limit)
            ENDIF
            nb_cell_y = nint( dy_box / local_size_cell )             
            nb_cell_y = min(nb_cell_y,nb_box_limit)
 
            nb_cell_z = nint( dz_box / local_size_cell )
            nb_cell_z = min(nb_cell_z,nb_box_limit)
        ELSEIF(leading_dimension==2) THEN
            nb_cell_y = nint( ratio * dy_box )
            nb_cell_y = min(nb_cell_y,nb_box_limit)
 
            local_size_cell = dy_box / nb_cell_y
            IF(local_size_cell<element_size) THEN 
                local_size_cell = element_size
                nb_cell_y = nint( dy_box / local_size_cell )             
                nb_cell_y = min(nb_cell_y,nb_box_limit)
            ENDIF
            nb_cell_x = nint( dx_box / local_size_cell )
            nb_cell_x = min(nb_cell_x,nb_box_limit)
 
            nb_cell_z = nint( dz_box / local_size_cell )
            nb_cell_z = min(nb_cell_z,nb_box_limit)
        ELSE !IF(LEADING_DIMENSION==3) THEN
            nb_cell_z = nint( ratio * dz_box )
            nb_cell_z = min(nb_cell_z,nb_box_limit)
 
            local_size_cell = dz_box / nb_cell_z
            IF(local_size_cell<element_size) THEN 
                local_size_cell = element_size
                nb_cell_z = nint( dz_box / local_size_cell )             
                nb_cell_z = min(nb_cell_z,nb_box_limit)
            ENDIF
            nb_cell_y = nint( dy_box / local_size_cell )
            nb_cell_y = min(nb_cell_y,nb_box_limit)
 
            nb_cell_x = nint( dx_box / local_size_cell )
            nb_cell_x = min(nb_cell_x,nb_box_limit)
        ENDIF
        ! -----------------------
 
        ! -----------------------
        ! ensure that nb_cell_... is higher than 0 (2D case)
        nb_cell_x = max(1,nb_cell_x)
        nb_cell_y = max(1,nb_cell_y)
        nb_cell_z = max(1,nb_cell_z)
 
        size_cell(1) = dx_box / local_size_cell
        size_cell(2) = dy_box / local_size_cell
        size_cell(3) = dz_box / local_size_cell
        ! -----------------------
 
        RETURN