split_cfd_solide.F File Reference

#include "implicit_f.inc"
#include "com01_c.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	split_cfd_solide (numels, ale_connectivity, ixs, ale_elm, size_ale_elm)
subroutine	deallocate_split_cfd_solide (ale_elm)

Function/Subroutine Documentation

deallocate_split_cfd_solide()

subroutine deallocate_split_cfd_solide

(

type(split_cfd_type), dimension(nspmd), intent(inout)

ale_elm

)

Definition at line 151 of file split_cfd_solide.F.

!$COMMENT
!       DEALLOCATE_SPLIT_CFD_SOLIDE description :
!              DEALLOCATE_SPLIT_CFD_SOLIDE deallocates the
!               ALE_ELM array
!       DEALLOCATE_SPLIT_CFD_SOLIDE organization :
!               - loop over NSPMD + deallocation
!$ENDCOMMENT
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
        USE split_cfd_mod
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-----------------------------------------------
#include      "com01_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
        TYPE(split_cfd_type), DIMENSION(NSPMD), INTENT(INOUT) :: ALE_ELM 
!       -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*
!       ALE_ELM : split_cfd_type ; dimension=NSPMD ; solid element ID used 
!                 during the domain splitting (ALE part)
!       -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        INTEGER :: ISPMD
C ----------------------------------------
        DO ispmd=1,nspmd
                IF( ALLOCATED(ale_elm(ispmd)%SOL_ID) ) DEALLOCATE( ale_elm(ispmd)%SOL_ID )
        ENDDO
        RETURN

split_cfd_solide()

subroutine split_cfd_solide	(	integer, intent(in)	numels,
		type(t_ale_connectivity), intent(inout)	ale_connectivity,
		integer, dimension(nixs,*), intent(in)	ixs,
		type(split_cfd_type), dimension(nspmd), intent(inout)	ale_elm,
		integer, dimension(nspmd)	size_ale_elm )

Definition at line 33 of file split_cfd_solide.F.

!$COMMENT
!       SPLIT_CFD_SOLIDE description :
!              SPLIT_CFD_SOLIDE retains all the useful solid elements
!              for the splitting in DDSPLIT for each domain in order to 
!              avoid a quadratic loop in DDSPLIT
!       SPLIT_CFD_SOLIDE organization :
!               - first allocation of ALE_ELM%SOL_ID array
!               - for each solid element, if a neighbouring element 
!                 is useful for the splitting, catch the processor list
!               - fill the ALE_ELM array and if the ALE_ELM size is not
!                 sufficient, then increase the size
!$ENDCOMMENT
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
        USE split_cfd_mod
        USE ale_connectivity_mod
        use element_mod , only : nixs
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-----------------------------------------------
#include      "com01_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
        INTEGER, INTENT(IN) :: NUMELS
        INTEGER, DIMENSION(NIXS,*), INTENT(IN) :: IXS    
        INTEGER, DIMENSION(NSPMD) :: SIZE_ALE_ELM  
        TYPE(split_cfd_type), DIMENSION(NSPMD), INTENT(INOUT) :: ALE_ELM
        TYPE(t_ale_connectivity), INTENT(INOUT) :: ALE_CONNECTIVITY
!       -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*
!       NUMELS   : integer ; number of solid element
!       NIXS     : integer ; dimension of IXS array
 
!       IXS      : integer ; dimension=NIXS,NUMELS ; property of solid element
!       SIZE_ALE_ELM : integer ; dimension=NSPMD ; size of ALE_ELM%SOL_ID array
!       ALE_ELM : split_cfd_type ; dimension=NSPMD ; solid element ID used 
!                 during the domain splitting (ALE part)
!       -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        LOGICAL, DIMENSION(NSPMD) :: BOOL
        INTEGER :: I,J,K,L,N,NS,IAD1,LGTH
        INTEGER :: SOLV,ISPMD,NBR_PROC,NEW_SIZE_II,MIN_SIZE
        INTEGER, DIMENSION(NSPMD) :: ID_SPMD,II
        INTEGER, DIMENSION(:), ALLOCATABLE :: TMP   
C ----------------------------------------
 
        !       -----------------------------
        !       allocation of ALE_ELM (overestimation of the size)
        size_ale_elm(1:nspmd) = numels/nspmd+1
        DO ispmd=1,nspmd
                ALLOCATE( ale_elm(ispmd)%SOL_ID(size_ale_elm(ispmd)) )
        ENDDO
        !       -----------------------------
        ii(1:nspmd) = 0
        DO i=1,numels
                !       -----------------------------
                ! check if a neighbouring element is used
                bool(1:nspmd)=.false.
                iad1 = ale_connectivity%ee_connect%iad_connect(i)
                lgth = ale_connectivity%ee_connect%iad_connect(i+1)-ale_connectivity%ee_connect%iad_connect(i)
                DO j=1,8
                  ns = ixs(j+1,i)
                  DO k=1,lgth
                    solv = ale_connectivity%ee_connect%connected(iad1 + k - 1)
                    IF (solv>0) THEN
                      DO l=1,8
                        n = ixs(l+1,solv)
                        CALL plist_ifront(id_spmd,n,nbr_proc)
                        DO ispmd=1,nbr_proc
                          bool(id_spmd(ispmd)) = .true.
                        ENDDO
                      ENDDO
                    ENDIF
                  ENDDO
                ENDDO
                !       -----------------------------
                !       fill the ALE_ELM array / increase the size
                DO ispmd=1,nspmd
                  IF( bool(ispmd) ) THEN
                    ii(ispmd) = ii(ispmd) + 1
                    IF( ii(ispmd)>size_ale_elm(ispmd) ) THEN
                      !       need to check the size for small test, ie. when NUMELS < NSPMS
                      min_size=max(1,5* numels/ ( 4*nspmd ))
                      new_size_ii = size_ale_elm(ispmd) + min_size
                      ALLOCATE( tmp( new_size_ii ) )
                      tmp(1:size_ale_elm(ispmd)) = ale_elm(ispmd)%SOL_ID( 1:size_ale_elm(ispmd) )
                      CALL move_alloc(from=tmp,to=ale_elm(ispmd)%SOL_ID)
                      size_ale_elm(ispmd) = new_size_ii
                    ENDIF
                    ale_elm(ispmd)%SOL_ID(ii(ispmd)) = i
                  ENDIF
                ENDDO
                !       -----------------------------
        ENDDO
        !       -----------------------------
 
        size_ale_elm(1:nspmd) = ii(1:nspmd)
 
        RETURN