qnorm2t.F File Reference

#include "implicit_f.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	qnorm2t (nel, nft, jale, sym, ixtg, xgrid, wgrid, norm, wfac, surf)

Function/Subroutine Documentation

qnorm2t()

subroutine qnorm2t	(	integer, intent(in)	nel,
		integer, intent(in)	nft,
		integer, intent(in)	jale,
		integer, intent(in)	sym,
		integer, dimension(nixtg, *), intent(in)	ixtg,
		dimension(3, *), intent(in)	xgrid,
		dimension(*), intent(in)	wgrid,
		dimension(3, 3, nel), target	norm,
		dimension(3, 3, nel), intent(out)	wfac,
		dimension(3, nel), intent(out)	surf )

Definition at line 30 of file qnorm2t.F.

C-----------------------------------------------
C     D e s c r i p t i o n
C-----------------------------------------------
C     Computes normal vector to the faces of each element in a group
C     for a 3d solid element (hence Snorm3)
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-----------------------------------------------
!     NIXTG
C-----------------------------------------------
C     D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER, INTENT(IN) :: NEL, NFT, JALE, SYM, IXTG(NIXTG, *)
      my_real, INTENT(IN) :: 
     .     xgrid(3, *), wgrid(*)
      my_real, INTENT(OUT) :: wfac(3, 3, nel), surf(3, nel)
      my_real, INTENT(OUT), TARGET :: norm(3, 3, nel)
C-----------------------------------------------
C     L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER :: II, NODE1, NODE2, NODE3, KFACE
      my_real ::  
     .     x1(3), x2(3), x3(3), xk(3), xf(1:3),
     .     w1(3), w2(3), w3(3)
      my_real, POINTER :: nx, ny, nz
 
      DO ii = 1, nel
         node1 = ixtg(2, ii + nft)
         node2 = ixtg(3, ii + nft)
         node3 = ixtg(4, ii + nft)
         x1(1:3) = xgrid(1:3, node1)
         x2(1:3) = xgrid(1:3, node2)
         x3(1:3) = xgrid(1:3, node3)
         xk(1:3) = third * (x1(1:3) + x2(1:3) + x3(1:3))
         IF (jale /= 0) THEN
C     Node grid velocities
            w1(1:3) = wgrid(3 * (node1 - 1) + 1 : 3 * (node1 - 1) + 3)
            w2(1:3) = wgrid(3 * (node2 - 1) + 1 : 3 * (node2 - 1) + 3)
            w3(1:3) = wgrid(3 * (node3 - 1) + 1 : 3 * (node3 - 1) + 3)
         ELSE                   ! Euler
            w1(1:3) = zero
            w2(1:3) = zero
            w3(1:3) = zero
         ENDIF
C     Face normal
C     Face 1
         kface = 1
         norm(1, kface, ii) = zero
         norm(2, kface, ii) = x2(3) - x1(3)
         norm(3, kface, ii) = -(x2(2) - x1(2))
         nx => norm(1, kface, ii)
         ny => norm(2, kface, ii)
         nz => norm(3, kface, ii)
         surf(kface, ii) = sqrt(ny * ny + nz * nz)
         ny = ny / surf(kface, ii)
         nz = nz / surf(kface, ii)
         IF (sym == 1) THEN
            surf(kface, ii) = surf(kface, ii) * half * (x1(2) + x2(2))
         ENDIF
         xf(1:3) = half * (x1(1:3) + x2(1:3))
         IF (nx * (xf(1) - xk(1)) + ny * (xf(2) - xk(2)) + nz * (xf(3) - xk(3)) <= zero) THEN
            CALL arret(2)
         ENDIF
C     Face 2
         kface = 2
         norm(1, kface, ii) = zero
         norm(2, kface, ii) = x3(3) - x2(3)
         norm(3, kface, ii) = -(x3(2) - x2(2))
         nx => norm(1, kface, ii)
         ny => norm(2, kface, ii)
         nz => norm(3, kface, ii)
         surf(kface, ii) = sqrt(ny * ny + nz * nz)
         ny = ny / surf(kface, ii)
         nz = nz / surf(kface, ii)
         IF (sym == 1) THEN
            surf(kface, ii) = surf(kface, ii) * half * (x2(2) + x3(2))
         ENDIF
         xf(1:3) = half * (x2(1:3) + x3(1:3))
         IF (nx * (xf(1) - xk(1)) + ny * (xf(2) - xk(2)) + nz * (xf(3) - xk(3)) <= zero) THEN
            CALL arret(2)
         ENDIF
C     Face 3
         kface = 3
         norm(1, kface, ii) = zero
         norm(2, kface, ii) = x1(3) - x3(3)
         norm(3, kface, ii) = -(x1(2) - x3(2))
         nx => norm(1, kface, ii)
         ny => norm(2, kface, ii)
         nz => norm(3, kface, ii)
         surf(kface, ii) = sqrt(ny * ny + nz * nz)
         ny = ny / surf(kface, ii)
         nz = nz / surf(kface, ii)
         IF (sym == 1) THEN
            surf(kface, ii) = surf(kface, ii) * half * (x3(2) + x1(2))
         ENDIF
         xf(1:3) = half * (x3(1:3) + x1(1:3))
         IF (nx * (xf(1) - xk(1)) + ny * (xf(2) - xk(2)) + nz * (xf(3) - xk(3)) <= zero) THEN
            CALL arret(2)
         ENDIF
C     Face grid velocity 1
         wfac(1:3, 1, ii) = half * (w1(1:3) + w2(1:3))
C     Face grid velocity 2
         wfac(1:3, 2, ii) = half * (w2(1:3) + w3(1:3))
C     Face grid velocity 3
         wfac(1:3, 3, ii) = half * (w3(1:3) + w1(1:3))
      ENDDO