w_anim_ply.F File Reference

#include "implicit_f.inc"
#include "param_c.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	w_anim_ply (ixc, numelc_l, nodlocal, numnod_l, cel, cep, proc)

Function/Subroutine Documentation

w_anim_ply()

subroutine w_anim_ply	(	integer, dimension(nixc,*)	ixc,
		integer	numelc_l,
		integer, dimension(*)	nodlocal,
		integer	numnod_l,
		integer, dimension(*)	cel,
		integer, dimension(*)	cep,
		integer	proc )

Definition at line 33 of file w_anim_ply.F.

      USE plyxfem_mod
      use element_mod , only : nixc
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      "param_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER IXC(NIXC,*),NUMELC_L, NODLOCAL(*),
     *        NUMNOD_L,CEL(*),CEP(*),PROC
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER I, K, ELEM, ND, NDSZ_L, ELSZ_L, ELPL, NCOUNT, EMPL
      INTEGER, DIMENSION(:), ALLOCATABLE :: ELNUM,ELEMIPT,ELEMXFEMID,
     *                                      NODNUM,NODEXTN,
     .                                      NODTAG,ELEMTAG,PLYSIZNG
      INTEGER GET_PLY_NOD
      EXTERNAL get_ply_nod
C-----------------------------------------------
!     1d array
      ALLOCATE( nodtag(numnod_l),elemtag(numelc_l) )
      ALLOCATE( plysizng(nplymax) )
! ----------------------------------
 
      CALL write_i_c(nplypart,1)
      CALL write_i_c(indx_ply,nplypart)
 
      DO k=1,nplymax
        nodtag=0
        elemtag=0
 
        plysizng(k)=plynod(k)%PLYNUMNODS
C First part, on 1 fold we tag the elements and
C the nodes of the proc
        DO i=1,plyshell(k)%PLYNUMSHELL
           elem = plyshell(k)%SHID(i)
           IF (cep(elem)==proc)THEN
             elemtag(cel(elem))=i
             nd = ixc(2,elem)
             nodtag(nodlocal(nd))=nd
             nd = ixc(3,elem)
             nodtag(nodlocal(nd))=nd
             nd = ixc(4,elem)
             nodtag(nodlocal(nd))=nd
             nd = ixc(5,elem)
             nodtag(nodlocal(nd))=nd
           ENDIF
        ENDDO
C They are counted to prepare the tables to be sent to
C L engine
        elsz_l=0
        ndsz_l =0
        DO i=1,numelc_l
          IF (elemtag(i)  > 0) elsz_l=elsz_l+1
        ENDDO
        DO i=1,numnod_l
          IF (nodtag(i) > 0) ndsz_l=ndsz_l+1
        ENDDO
 
C we prepare the tables to send
        elpl = 0
        ALLOCATE ( elnum(elsz_l),elemipt(elsz_l),elemxfemid(elsz_l) )
 
C Local tables elements
        DO i=1,numelc_l
          IF (elemtag(i)  > 0) THEN
             elpl=elpl+1
             nd = elemtag(i)
C
             elnum(elpl)      = i
             elemipt(elpl)    = plyshell(k)%SHELLIPT(nd)
             elemxfemid(elpl) = plyshell(k)%SHELLID(nd)
          ENDIF
        ENDDO
C XFEM local node paintings
        ncount = 0
        ALLOCATE ( nodnum(ndsz_l), nodextn(ndsz_l) )
        DO i=1,numnod_l
          IF (nodtag(i) > 0) THEN
            ncount = ncount + 1
            nd=nodtag(i)
C
            empl = get_ply_nod(k,nd)
            nodnum(ncount) = i
            nodextn(ncount) = plynod(k)%PLYNODID(empl)
          ENDIF
        ENDDO
C Writing by fold of the tables
C Ply shells
        CALL write_i_c(elsz_l    , 1     )
        CALL write_i_c(elnum     , elsz_l)
        CALL write_i_c(elemipt   , elsz_l)
        CALL write_i_c(elemxfemid, elsz_l)
C ply nodes
        CALL write_i_c(ndsz_l    , 1     )
        CALL write_i_c(nodnum    , ndsz_l)
        CALL write_i_c(nodextn   , ndsz_l)
 
C
        DEALLOCATE ( nodextn,nodnum,elnum,elemipt,elemxfemid)
      ENDDO
 
        CALL write_i_c(plysizng,nplymax)
C id ply pid     
        CALL write_i_c(idpid_ply,nplypart)    
! ----------------------------------    
!     1d array
      DEALLOCATE( nodtag,elemtag )
      DEALLOCATE( plysizng )
! ----------------------------------   
      RETURN