ale_box_creation.F

Go to the documentation of this file.

Copyright>        OpenRadioss
Copyright>        Copyright (C) 1986-2025 Altair Engineering Inc.
Copyright>
Copyright>        This program is free software: you can redistribute it and/or modify
Copyright>        it under the terms of the GNU Affero General Public License as published by
Copyright>        the Free Software Foundation, either version 3 of the License, or
Copyright>        (at your option) any later version.
Copyright>
Copyright>        This program is distributed in the hope that it will be useful,
Copyright>        but WITHOUT ANY WARRANTY; without even the implied warranty of
Copyright>        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Copyright>        GNU Affero General Public License for more details.
Copyright>
Copyright>        You should have received a copy of the GNU Affero General Public License
Copyright>        along with this program.  If not, see <https://www.gnu.org/licenses/>.
Copyright>
Copyright>
Copyright>        Commercial Alternative: Altair Radioss Software
Copyright>
Copyright>        As an alternative to this open-source version, Altair also offers Altair Radioss
Copyright>        software under a commercial license.  Contact Altair to discuss further if the
Copyright>        commercial version may interest you: https://www.altair.com/radioss/.
!||====================================================================
!||    ale_box_creation   ../starter/source/initial_conditions/inivol/ale_box_creation.F
!||--- called by ------------------------------------------------------
!||    init_inivol        ../starter/source/initial_conditions/inivol/init_inivol.F90
!||====================================================================
        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)
!$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
        END SUBROUTINE ale_box_creation