ale_element_size_computation.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_element_size_computation   ../starter/source/initial_conditions/inivol/ale_element_size_computation.F
!||--- called by ------------------------------------------------------
!||    init_inivol                    ../starter/source/initial_conditions/inivol/init_inivol.F90
!||--- uses       -----------------------------------------------------
!||====================================================================
        SUBROUTINE ale_element_size_computation(NPARG, NGROUP, NUMELS,NUMELTG,NUMELQ,NUMNOD,N2D,
     .                                          IPARG,IXS,IXQ,IXTG,
     .                                          ELEMENT_SIZE,MIN_MAX_POSITION,X,
     .                                          ALE_ELEMENT_NUMBER,ALE_NODE_NUMBER,LIST_ALE_NODE)
!$COMMENT
!       ALE_ELEMENT_SIZE_COMPUTATION description
!       ALE_ELEMENT_SIZE_COMPUTATION computes the maximum element size 
!       and the min / max position of nodes
!       the maximum element size & min / max position are used to defined the grid
!       
!       ALE_ELEMENT_SIZE_COMPUTATION organization :
!       - loop over the element group
!           - for each ALE element group, loop over the NEL elements
!               - compute the maximum element size 
!               - compute the min/max node's positions & save the ale node id
!$ENDCOMMENT
        use element_mod , only :nixs,nixq,nixtg
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include "implicit_f.inc"
C-----------------------------------------------
C   G l o b a l   P a r a m e t e r s
C-----------------------------------------------
#include "mvsiz_p.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
        INTEGER,INTENT(IN) :: NPARG, NGROUP, NUMELS,NUMELTG,NUMELQ,NUMNOD,N2D
        INTEGER, INTENT(INOUT) :: ALE_ELEMENT_NUMBER ! number of ale element with material 51 or 151
        INTEGER, INTENT(INOUT) :: ALE_NODE_NUMBER ! number of ale node
        INTEGER, DIMENSION(NUMNOD), INTENT(INOUT) :: LIST_ALE_NODE ! list of ale node
        INTEGER, DIMENSION(NPARG,NGROUP), INTENT(IN) ::  IPARG  ! group data
        INTEGER, DIMENSION(NIXS,NUMELS),INTENT(IN), TARGET :: IXS ! solid data
        INTEGER, DIMENSION(NIXQ,NUMELQ),INTENT(IN), TARGET :: IXQ ! quad data
        INTEGER, DIMENSION(NIXTG,NUMELTG),INTENT(IN), TARGET :: IXTG ! triangle data
        my_real, INTENT(INOUT) :: element_size ! max element size
        my_real, DIMENSION(6), INTENT(INOUT) :: min_max_position ! min/max position
        my_real, DIMENSION(3,NUMNOD), INTENT(IN) :: x ! position
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        INTEGER :: I,J,K,NG
        INTEGER :: MTN,NEL,NFT,ITY,ISOLNOD,INIVOL
        INTEGER :: NODE_NUMBER,FIRST
        INTEGER, DIMENSION(:,:), POINTER :: IX
        INTEGER, DIMENSION(:), ALLOCATABLE :: TAG_ARRAY
        my_real :: local_size
        my_real, DIMENSION(3) :: max_node,min_node,distance
        integer, target :: nothing(1,1) !< dummy for indirection
C-----------------------------------------------
        ALLOCATE(tag_array(numnod))
        tag_array(1:numnod) = 0
        ix => nothing
        element_size = -one
        min_max_position(1:3) = ep30
        min_max_position(4:6) = -ep30
        ale_element_number = 0
        ale_node_number = 0
        ! -----------------------
        ! loop over the solid / quad / triangle elements with 51/151 material
        DO ng=1,ngroup
            mtn = iparg(1,ng)   ! material law
            nel = iparg(2,ng)   ! number of element 
            nft = iparg(3,ng)   ! adress of first element
            ity = iparg(5,ng)   ! type of element 
            isolnod = iparg(28,ng)
            inivol = iparg(53,ng)
            IF(inivol <= 0) cycle
            IF(mtn /= 51 .AND. mtn /= 151) cycle
            IF(n2d == 0 .AND. ity /= 1)THEN
              cycle
            ELSEIF(n2d > 0 .AND. ity/=7 .AND. ity /= 2)THEN
              cycle
            ENDIF
            ! total number of ale element with material 51 or 151
            ale_element_number = ale_element_number + nel
 
            ! ---------------
            ! depending on the king of element
            IF(ity == 1) THEN
                first = 1
                node_number = 8
                ix => ixs(1:node_number+1,nft+1:nft+nel)
            ELSEIF(ity == 2) THEN
                first = 2
                node_number = 4
                ix => ixq(1:node_number+1,nft+1:nft+nel)
            ELSEIF(ity == 7) THEN
                first = 2
                node_number = 3
                ix => ixtg(1:node_number+1,nft+1:nft+nel)
            ELSE
                first = -huge(first)
                node_number = -huge(node_number)
                ix => null()
            ENDIF
            ! ---------------
 
            ! ---------------
            ! loop over the elements of the group to compute 
            ! the max element size and the min/max position
            DO j=1,nel
              max_node(1:3) = -ep20
              min_node(1:3) =  ep20
              ! ---------------
              ! max element size
              DO i=1,node_number
                max_node(first:3) = max(max_node(first:3),x(first:3,ix(1+i,j)) )
                min_node(first:3) = min(min_node(first:3),x(first:3,ix(1+i,j)) )
              ENDDO
              distance(first:3) = (abs(max_node(first:3)-min_node(first:3)))**2
              local_size = sqrt( sum(distance(first:3)) )
              element_size = max(element_size,local_size)
              ! --------------
              ! ---------------
              ! min / max position & save the ALE node id
              DO k=first,3
                ! min / max position
                DO i=1,node_number
                  min_max_position(k) = min(min_max_position(k),x(k,ix(1+i,j)))
                  min_max_position(3+k) = max(min_max_position(3+k),x(k,ix(1+i,j)))
                  IF(tag_array(ix(1+i,j))==0) THEN
                    tag_array(ix(1+i,j)) = 1
                    ale_node_number = ale_node_number + 1
                    list_ale_node(ale_node_number) = ix(1+i,j)
                  ENDIF
                ENDDO
              ENDDO
              ! ---------------
            ENDDO
            ! ---------------
        ENDDO
 
        DEALLOCATE(tag_array)
        ! -----------------------
 
        RETURN
        END SUBROUTINE ale_element_size_computation