RFLO_EdgeDeformation.F90

Go to the documentation of this file.

! *********************************************************************
! * Rocstar Simulation Suite                                          *
! * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
! *                                                                   *
! * Illinois Rocstar LLC                                              *
! * Champaign, IL                                                     *
! * www.illinoisrocstar.com                                           *
! * sales@illinoisrocstar.com                                         *
! *                                                                   *
! * License: See LICENSE file in top level of distribution package or *
! * http://opensource.org/licenses/NCSA                               *
! *********************************************************************
! *********************************************************************
! * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
! * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
! * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
! * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
! * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
! * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
! * Arising FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
! * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
! *********************************************************************
!******************************************************************************
!
! Purpose: calculate node displacements on those edges whose end points have
!          moved, but the associated boundaries were not updated yet (finest
!          grid only).
!
! Description: points along an edge are shifted using 1-D linear transfinite
!              interpolation (TFI).
!
! Input: region     = grid dimensions
!        boundMoved = flag for boundaries of a region which have moved
!        arcLen12   = arclength between i=const. boundaries for each j, k
!        arcLen34   = arclength between j=const. boundaries for each k, i
!        arcLen56   = arclength between k=const. boundaries for each i, j
!        xyzOld     = grid from previous time step.
!
! Output: edgeMoved = flag if discretization at an edge was changed
!         dNode     = updated deformations at edges.
!
! Notes: variable dNode contains the whole 3-D field.
!
!******************************************************************************
!
! $Id: RFLO_EdgeDeformation.F90,v 1.4 2008/12/06 08:44:06 mtcampbe Exp $
!
! Copyright: (c) 2001 by the University of Illinois
!
!******************************************************************************

SUBROUTINE rflo_edgedeformation( region,boundMoved,edgeMoved, &
                                 arclen12,arclen34,arclen56,xyzold,dnode )

  USE moddatatypes
  USE moddatastruct, ONLY : t_region
  USE modinterfaces, ONLY : rflo_getnodeoffset, rflo_getdimensphysnodes, &
                            rflo_tfint1d
  USE moderror
  USE modparameters
  IMPLICIT NONE

#include "Indexing.h"

! ... parameters
  LOGICAL :: boundmoved(6), edgemoved(12)

  REAL(RFREAL), POINTER :: arclen12(:,:), arclen34(:,:), arclen56(:,:)
  REAL(RFREAL), POINTER :: dnode(:,:), xyzold(:,:)

  TYPE(t_region) :: region

! ... loop variables
  INTEGER :: iedge, ind

! ... local variables
  INTEGER :: ilev, ipnbeg, ipnend, jpnbeg, jpnend, kpnbeg, kpnend, l1c, l2c
  INTEGER :: indbeg, indend, ijkn, ijkn1, ijknbeg, ijknend, inoff, ijnoff
  INTEGER :: switch(12,9)

  REAL(RFREAL) :: arclen, ds, s, dn(3), dnbeg(3), dnend(3)

!******************************************************************************

  CALL registerfunction( region%global,'RFLO_EdgeDeformation',&
  'RFLO_EdgeDeformation.F90' )

! get dimensions --------------------------------------------------------------

  ilev = 1
  CALL rflo_getdimensphysnodes( region,ilev,ipnbeg,ipnend, &
                                jpnbeg,jpnend,kpnbeg,kpnend )
  CALL rflo_getnodeoffset( region,ilev,inoff,ijnoff )

! set edge switch -------------------------------------------------------------
! switch(:,1) = begins at boundary
! switch(:,2) = ends on boundary
! switch(:,3) = right boundary
! switch(:,4) = left boundary
! switch(:,5) = direction (from-to boundary)
! switch(:,6) = start index
! switch(:,7) = end index
! switch(:,8) = constant index in 1st direction
! switch(:,9) = constant index in 2nd direction

  switch( 1,:) = (/5, 6, 1, 3, 56, kpnbeg, kpnend, ipnbeg, jpnbeg/)
  switch( 2,:) = (/3, 4, 1, 6, 34, jpnbeg, jpnend, kpnend, ipnbeg/)
  switch( 3,:) = (/5, 6, 1, 4, 56, kpnbeg, kpnend, ipnbeg, jpnend/)
  switch( 4,:) = (/3, 4, 1, 5, 34, jpnbeg, jpnend, kpnbeg, ipnbeg/)
  switch( 5,:) = (/5, 6, 2, 3, 56, kpnbeg, kpnend, ipnend, jpnbeg/)
  switch( 6,:) = (/3, 4, 2, 6, 34, jpnbeg, jpnend, kpnend, ipnend/)
  switch( 7,:) = (/5, 6, 2, 4, 56, kpnbeg, kpnend, ipnend, jpnend/)
  switch( 8,:) = (/3, 4, 2, 5, 34, jpnbeg, jpnend, kpnbeg, ipnend/)
  switch( 9,:) = (/1, 2, 3, 5, 12, ipnbeg, ipnend, jpnbeg, kpnbeg/)
  switch(10,:) = (/1, 2, 3, 6, 12, ipnbeg, ipnend, jpnbeg, kpnend/)
  switch(11,:) = (/1, 2, 4, 5, 12, ipnbeg, ipnend, jpnend, kpnbeg/)
  switch(12,:) = (/1, 2, 4, 6, 12, ipnbeg, ipnend, jpnend, kpnend/)

! edge movement flag ----------------------------------------------------------

  edgemoved(:) = .false.

  IF (boundmoved(1)) THEN
    edgemoved( 1) = .true.; edgemoved( 2) = .true.
    edgemoved( 3) = .true.; edgemoved( 4) = .true.
  ENDIF
  IF (boundmoved(2)) THEN
    edgemoved( 5) = .true.; edgemoved( 6) = .true.
    edgemoved( 7) = .true.; edgemoved( 8) = .true.
  ENDIF
  IF (boundmoved(3)) THEN
    edgemoved( 1) = .true.; edgemoved( 5) = .true.
    edgemoved( 9) = .true.; edgemoved(10) = .true.
  ENDIF
  IF (boundmoved(4)) THEN
    edgemoved( 3) = .true.; edgemoved( 7) = .true.
    edgemoved(11) = .true.; edgemoved(12) = .true.
  ENDIF
  IF (boundmoved(5)) THEN
    edgemoved( 4) = .true.; edgemoved( 8) = .true.
    edgemoved( 9) = .true.; edgemoved(11) = .true.
  ENDIF
  IF (boundmoved(6)) THEN
    edgemoved( 2) = .true.; edgemoved( 6) = .true.
    edgemoved(10) = .true.; edgemoved(12) = .true.
  ENDIF

! loop over all 12 edges ------------------------------------------------------

  DO iedge=1,12
    IF ((boundmoved(switch(iedge,1)) .OR. boundmoved(switch(iedge,2))) .AND. &
        ((.NOT.boundmoved(switch(iedge,3))) .OR. &
         (.NOT.boundmoved(switch(iedge,4)))) .AND. &
         (.NOT.edgemoved(iedge))) THEN

      edgemoved(iedge) = .true.

      ds     = 0._rfreal
      indbeg = switch(iedge,6)
      indend = switch(iedge,7)
      l1c    = switch(iedge,8)
      l2c    = switch(iedge,9)
      DO ind=indbeg+1,indend-1
        IF (switch(iedge,5) == 12) THEN
          ijkn     = indijk(ind   ,l1c,l2c,inoff,ijnoff)
          ijkn1    = indijk(ind-1 ,l1c,l2c,inoff,ijnoff)
          ijknbeg  = indijk(indbeg,l1c,l2c,inoff,ijnoff)
          ijknend  = indijk(indend,l1c,l2c,inoff,ijnoff)
          arclen   = arclen12(l1c,l2c)
          dnbeg(:) = dnode(:,ijknbeg)
          dnend(:) = dnode(:,ijknend)
        ELSE IF (switch(iedge,5) == 34) THEN
          ijkn     = indijk(l2c,ind   ,l1c,inoff,ijnoff)
          ijkn1    = indijk(l2c,ind-1 ,l1c,inoff,ijnoff)
          ijknbeg  = indijk(l2c,indbeg,l1c,inoff,ijnoff)
          ijknend  = indijk(l2c,indend,l1c,inoff,ijnoff)
          arclen   = arclen34(l1c,l2c)
          dnbeg(:) = dnode(:,ijknbeg)
          dnend(:) = dnode(:,ijknend)
        ELSE IF (switch(iedge,5) == 56) THEN
          ijkn     = indijk(l1c,l2c,ind   ,inoff,ijnoff)
          ijkn1    = indijk(l1c,l2c,ind-1 ,inoff,ijnoff)
          ijknbeg  = indijk(l1c,l2c,indbeg,inoff,ijnoff)
          ijknend  = indijk(l1c,l2c,indend,inoff,ijnoff)
          arclen   = arclen56(l1c,l2c)
          dnbeg(:) = dnode(:,ijknbeg)
          dnend(:) = dnode(:,ijknend)
        ENDIF
        ds = ds + sqrt((xyzold(xcoord,ijkn)-xyzold(xcoord,ijkn1))**2 + &
                       (xyzold(ycoord,ijkn)-xyzold(ycoord,ijkn1))**2 + &
                       (xyzold(zcoord,ijkn)-xyzold(zcoord,ijkn1))**2)
        s  = ds/arclen

        CALL rflo_tfint1d( s,dnbeg,dnend,dn )
        dnode(:,ijkn) = dn(:)
      ENDDO   ! i

    ENDIF     ! boundMoved
  ENDDO       ! iEdge

! finalize --------------------------------------------------------------------

  CALL deregisterfunction( region%global )

END SUBROUTINE rflo_edgedeformation

!******************************************************************************
!
! RCS Revision history:
!
! $Log: RFLO_EdgeDeformation.F90,v $
! Revision 1.4  2008/12/06 08:44:06  mtcampbe
! Updated license.
!
! Revision 1.3  2008/11/19 22:17:20  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.2  2005/05/27 01:53:41  wasistho
! added rflo_gridremesh
!
! Revision 1.1  2004/11/29 21:25:16  wasistho
! lower to upper case
!
! Revision 1.7  2003/11/20 16:40:34  mdbrandy
! Backing out RocfluidMP changes from 11-17-03
!
! Revision 1.4  2003/05/15 02:57:01  jblazek
! Inlined index function.
!
! Revision 1.3  2003/03/14 22:05:10  jblazek
! Improved mesh motion algorithm - node movement exchaged between blocks.
!
! Revision 1.2  2002/09/05 17:40:19  jblazek
! Variable global moved into regions().
!
! Revision 1.1  2002/08/15 19:48:05  jblazek
! Implemented grid deformation capability.
!
!******************************************************************************