qnorm2.F File Reference

#include "implicit_f.inc"

Go to the source code of this file.

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

Function/Subroutine Documentation

qnorm2()

subroutine qnorm2	(	integer, intent(in)	nel,
		integer, intent(in)	nft,
		integer, intent(in)	jale,
		integer, intent(in)	sym,
		integer, dimension(nixq, *), intent(in)	ixq,
		dimension(3, *), intent(in)	xgrid,
		dimension(*), intent(in)	wgrid,
		dimension(3, 4, nel), target	norm,
		dimension(3, 4, nel), intent(out)	wfac,
		dimension(4, nel), intent(out)	surf )

Definition at line 28 of file qnorm2.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-----------------------------------------------
!     NIXQ
C-----------------------------------------------
C     D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER, INTENT(IN) :: NEL, NFT, JALE, SYM, IXQ(NIXQ, *)
      my_real, INTENT(IN) :: 
     .     xgrid(3, *), wgrid(*)
      my_real, INTENT(OUT) :: wfac(3, 4, nel), surf(4, nel)
      my_real, INTENT(OUT), TARGET :: norm(3, 4, nel)
C-----------------------------------------------
C     L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER :: II, NODE1, NODE2, NODE3, NODE4, KFACE
      my_real ::  
     .     x1(3), x2(3), x3(3), x4(3), 
     .     w1(3), w2(3), w3(3), w4(3)
      my_real, POINTER :: ny, nz
 
 
      DO ii = 1, nel
         node1 = ixq(2, ii + nft)
         node2 = ixq(3, ii + nft)
         node3 = ixq(4, ii + nft)
         node4 = ixq(5, ii + nft)
         x1(1:3) = xgrid(1:3, node1)
         x2(1:3) = xgrid(1:3, node2)
         x3(1:3) = xgrid(1:3, node3)
         x4(1:3) = xgrid(1:3, node4)
         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)
            w4(1:3) = wgrid(3 * (node4 - 1) + 1 : 3 * (node4 - 1) + 3)
         ELSE                   ! Euler
            w1(1:3) = zero
            w2(1:3) = zero
            w3(1:3) = zero
            w4(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))
         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
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))
         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
C     Face 3
         kface = 3
         norm(1, kface, ii) = zero
         norm(2, kface, ii) = x4(3) - x3(3)
         norm(3, kface, ii) = -(x4(2) - x3(2))
         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) + x4(2))
         ENDIF
C     Face 4
         kface = 4
         norm(1, kface, ii) = zero
         norm(2, kface, ii) = x1(3) - x4(3) 
         norm(3, kface, ii) = -(x1(2) - x4(2))
         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 * (x4(2) + x1(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) + w4(1:3))
C     Face grid velocity 4
         wfac(1:3, 4, ii) = half * (w4(1:3) + w1(1:3))
      ENDDO