ale_element_size_computation.F File Reference

Go to the source code of this file.

Functions/Subroutines
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)

Function/Subroutine Documentation

ale_element_size_computation()

subroutine ale_element_size_computation	(	integer, intent(in)	nparg,
		integer, intent(in)	ngroup,
		integer, intent(in)	numels,
		integer, intent(in)	numeltg,
		integer, intent(in)	numelq,
		integer, intent(in)	numnod,
		integer, intent(in)	n2d,
		integer, dimension(nparg,ngroup), intent(in)	iparg,
		integer, dimension(nixs,numels), intent(in), target	ixs,
		integer, dimension(nixq,numelq), intent(in), target	ixq,
		integer, dimension(nixtg,numeltg), intent(in), target	ixtg,
		intent(inout)	element_size,
		intent(inout)	min_max_position,
		intent(in)	x,
		integer, intent(inout)	ale_element_number,
		integer, intent(inout)	ale_node_number,
		integer, dimension(numnod), intent(inout)	list_ale_node )

Definition at line 29 of file ale_element_size_computation.F.

!$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