sort_surf.F File Reference

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

Go to the source code of this file.

Functions/Subroutines
subroutine	sort_surf (igrsurf, ixs, ixc, ixtg, ixq, ixp, ixr, ixt, kxx, nixx)

Function/Subroutine Documentation

sort_surf()

subroutine sort_surf	(	type(surf_), dimension(nsurf), intent(inout)	igrsurf,
		integer, dimension(nixs,numels), intent(in)	ixs,
		integer, dimension(nixc,numelc), intent(in)	ixc,
		integer, dimension(nixtg,numeltg), intent(in)	ixtg,
		integer, dimension(nixq,numelq), intent(in)	ixq,
		integer, dimension(nixp,numelp), intent(in)	ixp,
		integer, dimension(nixr,numelr), intent(in)	ixr,
		integer, dimension(nixt,numelt), intent(in)	ixt,
		integer, dimension(nixx,numelx), intent(in)	kxx,
		integer, intent(in)	nixx )

Parameters

[in]	nixx	array size
[in]	ixs	elem buffer for /BRIC entities
[in]	ixc	elem buffer for /SHELL entities
[in]	ixtg	elem buffer for /SH3N (3d) or /TRIA (2d) entities
[in]	ixq	elem buffer for /QUAD entities
[in]	ixp	elem buffer for /BEAM entities
[in]	ixr	elem buffer for /SPRING entities
[in]	ixt	elem buffer for /TRUSS entities
[in]	kxx	elem buffer for /XELEM entities
[in,out]	igrsurf	data structure for surfaces

Definition at line 30 of file sort_surf.F.

C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
      USE groupdef_mod
      use element_mod , only : nixs,nixq,nixc,nixt,nixp,nixr,nixtg,nixtg
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      "com04_c.inc"
#include      "param_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER,INTENT(IN) :: NIXX !< array size
      INTEGER,INTENT(IN) :: IXS(NIXS,NUMELS)    !< elem buffer for /BRIC entities
      INTEGER,INTENT(IN) :: IXC(NIXC,NUMELC)    !< elem buffer for /SHELL entities
      INTEGER,INTENT(IN) :: IXTG(NIXTG,NUMELTG) !< elem buffer for /SH3N (3d) or /TRIA (2d) entities
      INTEGER,INTENT(IN) :: IXQ(NIXQ,NUMELQ)    !< elem buffer for /QUAD entities
      INTEGER,INTENT(IN) :: IXP(NIXP,NUMELP)    !< elem buffer for /BEAM entities
      INTEGER,INTENT(IN) :: IXR(NIXR,NUMELR)    !< elem buffer for /SPRING entities
      INTEGER,INTENT(IN) :: IXT(NIXT,NUMELT)    !< elem buffer for /TRUSS entities
      INTEGER,INTENT(IN) :: KXX(NIXX,NUMELX)    !< elem buffer for /XELEM entities
      TYPE(SURF_),INTENT(INOUT), DIMENSION(NSURF) :: IGRSURF !< data structure for surfaces
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER I, NN, ELEM, ITYP, K, IT
      INTEGER, DIMENSION(:), ALLOCATABLE :: IBUFSSG_TRI,IWORK,INDEX
      INTEGER, DIMENSION(:,:), ALLOCATABLE :: ITRI
C-----------------------------------------------
C   S o u r c e   L i n e s
C-----------------------------------------------
      ALLOCATE (iwork(80000))
        
      DO k=1,nsurf
        nn  = igrsurf(k)%NSEG
 
        ALLOCATE (ibufssg_tri(nisx*nn))
        ALLOCATE (itri(2,nn))
        ALLOCATE (index(3*nn))
 
        DO i=1,nn
          ibufssg_tri(6*(i-1)+1) = igrsurf(k)%NODES(i,1)
          ibufssg_tri(6*(i-1)+2) = igrsurf(k)%NODES(i,2)
          ibufssg_tri(6*(i-1)+3) = igrsurf(k)%NODES(i,3)
          ibufssg_tri(6*(i-1)+4) = igrsurf(k)%NODES(i,4)
          ibufssg_tri(6*(i-1)+5) = igrsurf(k)%ELTYP(i)
          ibufssg_tri(6*(i-1)+6) = igrsurf(k)%ELEM(i)
 
          elem = igrsurf(k)%ELEM(i)
          ityp = igrsurf(k)%ELTYP(i)
          ! ITYP = 0  - surf of segments
          ! ITYP = 1  - surf of solids
          ! ITYP = 2  - surf of quads
          ! ITYP = 3  - surf of SH4N
          ! ITYP = 4  - line of trusses
          ! ITYP = 5  - line of beams
          ! ITYP = 6  - line of springs
          ! ITYP = 7  - surf of SH3N
          ! ITYP = 8  - line of XELEM (nstrand element)
          ! ITYP = 101 - ISOGEOMETRIC
 
          itri(1,i) = ityp
          itri(2,i) = 0
 
          SELECT CASE (ityp)
            CASE ( 0 ) 
               itri(2,i) = 0
            CASE ( 1 )
               itri(2,i) = ixs(nixs,elem)
            CASE ( 2 )
               itri(2,i) = ixq(nixq,elem)
            CASE ( 3 )
               itri(2,i) = ixc(nixc,elem)
            CASE ( 4 )
               itri(2,i) = ixt(nixt,elem)
            CASE ( 5 )
               itri(2,i) = ixp(nixp,elem)
            CASE ( 6 )
               itri(2,i) = ixr(nixr,elem)
            CASE ( 7 )
               itri(2,i) = ixtg(nixtg,elem)
            CASE ( 8 )
               itri(2,i) = kxx(nixx,elem)
          END SELECT
 
          index(i) = i 
 
        ENDDO ! next nn
 
         CALL my_orders(0,iwork,itri,index,nn,2)
 
         DO i=1,nn
           it = index(i)
           igrsurf(k)%NODES(i,1) = ibufssg_tri(6*(it-1)+1)
           igrsurf(k)%NODES(i,2) = ibufssg_tri(6*(it-1)+2)
           igrsurf(k)%NODES(i,3) = ibufssg_tri(6*(it-1)+3)
           igrsurf(k)%NODES(i,4) = ibufssg_tri(6*(it-1)+4)
           igrsurf(k)%ELTYP(i)  = ibufssg_tri(6*(it-1)+5)
           igrsurf(k)%ELEM(i)  = ibufssg_tri(6*(it-1)+6)
         ENDDO
 
         DEALLOCATE(ibufssg_tri)
         DEALLOCATE(itri)
         DEALLOCATE(index)
 
      ENDDO ! DO K=1,NSURF
!---
      RETURN