alemuscl_upwind2.F File Reference

#include "implicit_f.inc"
#include "spmd_c.inc"
#include "vect01_c.inc"
#include "com04_c.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	alemuscl_upwind2 (flux, ale_connect, x, ixq, flux_vois, n4_vois, itab, nv46, itrimat, segvar)

Function/Subroutine Documentation

alemuscl_upwind2()

subroutine alemuscl_upwind2	(	dimension(nv46, *), intent(out)	flux,
		type(t_ale_connectivity), intent(in)	ale_connect,
		dimension(3, numnod), intent(in)	x,
		integer, dimension(nixq, numelq), intent(in)	ixq,
		dimension(numelq+nqvois, nv46), intent(out)	flux_vois,
		integer, dimension(numelq+nqvois,8), intent(out)	n4_vois,
		integer, dimension(numnod), intent(in)	itab,
		integer, intent(in)	nv46,
		integer, intent(in)	itrimat,
		type(t_segvar), intent(in)	segvar )

Definition at line 34 of file alemuscl_upwind2.F.

C-----------------------------------------------
C   D e s c r i p t i o n
C   This subroutines performs the following steps:
C     1 - compute a gradient for volume fraction ALPH
C         (calls GRADIENT_RECONSTRUCTION)
C     2 - reconstruct a value for volume fraction on each edge of the mesh
C         based on an affine approximation
C     3 - upwind this value on the edge and store it in the flux
C-----------------------------------------------
      USE i22bufbric_mod
      USE i22tri_mod
      USE alemuscl_mod , only:alemuscl_buffer
      USE segvar_mod
      USE ale_connectivity_mod
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 "spmd_c.inc"
#include "vect01_c.inc"
#include "com04_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER, INTENT(IN) :: NV46
      my_real, INTENT(OUT) :: flux(nv46, *)
      my_real, INTENT(IN) :: x(3, numnod)
      INTEGER, INTENT(IN) :: IXQ(NIXQ, NUMELQ)
      my_real, INTENT(OUT) :: flux_vois(numelq+nqvois, nv46)
      INTEGER, INTENT(OUT) :: N4_VOIS(NUMELQ+NQVOIS,8)
      INTEGER, INTENT(IN) :: ITAB(NUMNOD)
      INTEGER, INTENT(IN) :: ITRIMAT
      TYPE(t_segvar),INTENT(IN) :: SEGVAR
      TYPE(t_ale_connectivity), INTENT(IN) :: ALE_CONNECT
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER :: I, II, KK, JJ, IAD2, IAD3
      INTEGER :: NEIGHBOOR_LIST(NV46), FACE_NEIGHBOOR(NV46)
      my_real :: alphak
      my_real :: yk, zk
      my_real :: yf, zf
      INTEGER :: FACE_TO_NODE_LOCAL_ID(4, 2), NODEID1, NODEID2
C-----------------------------------------------
C   S o u r c e   L i n e s
C-----------------------------------------------
!!! Once for all, associate node local id to a face number
!!! Face 1
      face_to_node_local_id(1, 1) = 1 ; face_to_node_local_id(1, 2) = 2
!!! Face 2
      face_to_node_local_id(2, 1) = 2 ; face_to_node_local_id(2, 2) = 3
!!! Face 3
      face_to_node_local_id(3, 1) = 3 ; face_to_node_local_id(3, 2) = 4
!!! Face 4
      face_to_node_local_id(4, 1) = 4 ; face_to_node_local_id(4, 2) = 1
!!! First of all, compute gradient for alpha
      DO i = lft, llt
        ii = i + nft
        iad2 = ale_connect%ee_connect%iad_connect(ii)
        !!! Element centroid
        yk = alemuscl_buffer%ELCENTER(ii,2) ; 
        zk = alemuscl_buffer%ELCENTER(ii,3)
        !!! Neighbors
        DO kk = 1, nv46
          !!! Only for outgoing fluxes
          IF (flux(kk, ii) > zero) THEN
            !!! Storing neighbor indexes
            neighboor_list(kk) = ale_connect%ee_connect%connected(iad2 + kk - 1)
            face_neighboor(kk) = kk
            IF (neighboor_list(kk) <= 0) THEN
              IF(neighboor_list(kk)==0)neighboor_list(kk) = ii
              !case <0 is for eBCS. -NEIGHBOR_LIST is then the segment number
            ELSEIF (neighboor_list(kk) <= numelq) THEN
              iad3 = ale_connect%ee_connect%iad_connect(neighboor_list(kk))
              !!! Store the face number to which II and NEIGHBOR_LIST(KK) are adjacent
              DO jj = 1, nv46
                IF (ale_connect%ee_connect%connected(iad3 + jj - 1) == ii) THEN
                  face_neighboor(kk) = jj
                ENDIF
              ENDDO  ! JJ = 1, NV46
            ENDIF
 
            nodeid1 = ixq(1 + face_to_node_local_id(kk, 1), ii)
            nodeid2 = ixq(1 + face_to_node_local_id(kk, 2), ii)
 
            yf = half * (x(2, nodeid1) + x(2, nodeid2))
            zf = half * (x(3, nodeid1) + x(3, nodeid2))
 
            !!! Reconstruct second order value for ALPHA(II) on the face
            alphak = alemuscl_buffer%VOLUME_FRACTION(ii,itrimat)
     .           + alemuscl_buffer%GRAD(ii,2,itrimat) * (yf - yk)
     .           + alemuscl_buffer%GRAD(ii,3,itrimat) * (zf - zk)
 
            !!! Partial volume flux is then computed as:
            flux(kk, ii) = alphak * flux(kk, ii)
            IF (neighboor_list(kk) > 0)THEN
              IF (neighboor_list(kk) <= numelq) THEN
                !!! The opposite of the flux goes to the neighbor
                flux(face_neighboor(kk), neighboor_list(kk)) = -flux(kk, ii)
              ELSE
                !!! cf. ALE51_ANTIDIFF3
                flux_vois(ii, kk) = flux(kk, ii)
                n4_vois(ii, 1) = itab(ixq(2, ii))
                n4_vois(ii, 2) = itab(ixq(3, ii))
                n4_vois(ii, 3) = itab(ixq(4, ii))
                n4_vois(ii, 4) = itab(ixq(5, ii))
              ENDIF
            ENDIF
          ENDIF  ! (FLUX(KK, II) > ZERO)
        ENDDO  ! KK = 1, NV46
      ENDDO  ! I = LFT, LLT
 
C-----------------------------------------------
C         flux entrant par EBCS
C-----------------------------------------------
      IF(nsegflu > 0)THEN
        DO i = lft, llt
          ii = i + nft
          iad2 = ale_connect%ee_connect%iad_connect(ii)
          DO kk=1,4
            IF(flux(kk,ii) < zero .AND. ale_connect%ee_connect%connected(iad2 + kk - 1) < 0)THEN
              flux(kk,ii) = segvar%PHASE_ALPHA(itrimat,-ale_connect%ee_connect%connected(iad2 + kk - 1))*flux(kk,ii)
            ENDIF
          ENDDO
        ENDDO
      ENDIF
 
C-----------------------------------------------