split_seg_ielem.F File Reference

#include "implicit_f.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	split_seg_ielem (ielem_m, proc_mvoisin, mvoisin, nrtm, nrtm_l, tag_seg, cep, cel, idel_solid, intercep, proc, numels, numelq, numelc, numelt, numelp, numelr, numeltg)

Function/Subroutine Documentation

split_seg_ielem()

subroutine split_seg_ielem	(	integer, dimension(2,nrtm), intent(in)	ielem_m,
		integer, dimension(4,nrtm), intent(inout)	proc_mvoisin,
		integer, dimension(4,nrtm), intent(in)	mvoisin,
		integer, intent(in)	nrtm,
		integer, intent(in)	nrtm_l,
		integer, dimension(nrtm_l), intent(in)	tag_seg,
		integer, dimension(*), intent(in)	cep,
		integer, dimension(*), intent(in)	cel,
		integer, intent(in)	idel_solid,
		type(intersurfp)	intercep,
		integer, intent(in)	proc,
		integer, intent(in)	numels,
		integer, intent(in)	numelq,
		integer, intent(in)	numelc,
		integer, intent(in)	numelt,
		integer, intent(in)	numelp,
		integer, intent(in)	numelr,
		integer, intent(in)	numeltg )

Parameters

[in]	nrtm	number of main segments (global)
[in]	nrtm_l	number of main segments (local)
[in]	proc	current proc
[in]	numels	number of solid elements (global)
[in]	numelq	number of quad elements (global)
[in]	numelc	number of shell elements (global)
[in]	numelt	number of truss elements (global)
[in]	numelp	number of beam elements (global)
[in]	numelr	number of spring elements (global)
[in]	numeltg	number of shell3n elements (global)
[in]	idel_solid	solid eroosion flag
[in]	ielem_m	elements connected to main segments
[in]	tag_seg	local seg to global segment
[in]	cel	arrays of proc of elements and local number of element
[in]	mvoisin	neighbhoors of main segments
[in,out]	proc_mvoisin	procs of neighbhoors of main segments : to be built
	intercep	procs of main segments

Definition at line 31 of file split_seg_ielem.F.

c
c split & write segments array (type INTEGER) with local value
c
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
      USE intbufdef_mod 
      USE front_mod
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER  , INTENT(IN) :: NRTM !< number of main segments (global)
      INTEGER  , INTENT(IN) :: NRTM_L !< number of main segments (local)
      INTEGER  , INTENT(IN) ::  PROC        !< current proc
      INTEGER  , INTENT(IN) ::  NUMELS      !< number of solid elements (global)
      INTEGER  , INTENT(IN) ::  NUMELQ      !< number of quad elements (global)
      INTEGER  , INTENT(IN) ::  NUMELC      !< number of shell elements (global)
      INTEGER  , INTENT(IN) ::  NUMELT      !< number of truss elements (global)
      INTEGER  , INTENT(IN) ::  NUMELP      !< number of beam elements (global)
      INTEGER  , INTENT(IN) ::  NUMELR      !< number of spring elements (global)
      INTEGER  , INTENT(IN) ::  NUMELTG      !< number of shell3n elements (global)
 
      INTEGER  , INTENT(IN) :: IDEL_SOLID   !< solid eroosion flag
      INTEGER  , INTENT(IN) :: IELEM_M(2,NRTM) !< elements connected to main segments 
      INTEGER  , INTENT(IN) :: TAG_SEG(NRTM_L)   !< local seg to global segment
      INTEGER  , INTENT(IN) :: CEP(*),CEL(*)     !< arrays of proc of elements and local number of element
      INTEGER  , INTENT(IN) :: MVOISIN(4,NRTM)   !< neighbhoors of main segments 
      INTEGER  , INTENT(INOUT) :: PROC_MVOISIN(4,NRTM) !< procs of neighbhoors of main segments : to be built
      TYPE(INTERSURFP)     :: INTERCEP !< procs of main segments
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER I,J,K,GLOB,IE1,IEL1,IE2,IEL2,N
      INTEGER :: OFFSET_SHELL,OFFSET_SHELL3N
      INTEGER, DIMENSION(:),ALLOCATABLE :: IBUF1,IBUF3
C ----------------------------------------
      ALLOCATE(ibuf1(2*nrtm_l))
      ibuf1(1:2*nrtm_l) = 0
      ALLOCATE(ibuf3(4*nrtm_l))
      IF(idel_solid > 0) THEN
        ibuf3(1:4*nrtm_l) = 0
      ELSE
        ibuf3(1:4*nrtm_l) = 0 !should always be allocated
      ENDIF
      offset_shell=numels+numelq
      offset_shell3n=offset_shell+numelc+numelt+numelp+numelr
      ! ---------------------
      ! loop over the segment of the current proc
      ! a segment can be connected to :
      !  * a solid --> no offset
      !  * a shell --> offset = global number of solid+quad, ielem_ m = local shell id + offset
      !  * a shell 3n --> offset = global number of solid+quad+shell+truss+beam+spring ielem_ m = local shell3n id + offset
      DO i=1, nrtm_l
        k=tag_seg(i) ! get the segment id
        ie1 = ielem_m(1,k) ! get the element id (element of the segment)
        ! ----------------
        iel1 = 0
        ! convert the global element id to local element id (local to the processor)
        IF(ie1 <= numels) THEN ! segment is connected to a solid
           iel1 = cel(ie1)
        ELSEIF(offset_shell<ie1.AND.ie1<=offset_shell+numelc) THEN  ! segment is connected to a shell
          iel1 = offset_shell+cel(ie1)
        ELSEIF(offset_shell3n<ie1.AND.ie1<=offset_shell3n+numeltg) THEN ! segment is connected to a shell3n
          iel1 = offset_shell3n+cel(ie1)
        ENDIF
        ! ----------------
        ie2 = ielem_m(2,k)
        iel2 = 0
        IF(ie2 > 0) THEN
          iel2 = cel(ie2)
        ENDIF
        IF(cep(ie1)==proc ) THEN
          ibuf1(2*(i-1)+1) =iel1
          IF(ie2 >0) THEN
            IF(cep(ie2)==proc ) THEN
              ibuf1(2*(i-1)+2) =iel2
            ELSE  
              ibuf1(2*(i-1)+2) =-ie2
            ENDIF            
          ENDIF        
        ENDIF 
      ENDDO
      ! ---------------------
      DO i = 1, nrtm        
        DO j = 1,4
          k = mvoisin(j,i)
          IF(k /= 0) proc_mvoisin(j,i) = intercep%P(k)
        ENDDO
      ENDDO
      DO i = 1, nrtm_l         
        k=tag_seg(i)
        DO j = 1,4
          n = mvoisin(j,k)
          IF(n /= 0) ibuf3(4*(i-1)+j) = proc_mvoisin(j,k)
        ENDDO
      ENDDO
      
      CALL write_i_c(ibuf1,2*nrtm_l)
      CALL write_i_c(ibuf3,4*nrtm_l)
 
      DEALLOCATE(ibuf1)
      DEALLOCATE(ibuf3)
 
      RETURN