TURB_coRansWallDistOVFlu.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: compute distance of each cell centers to the nearest no-slip wall
!
! Description: distance to nearest wall (walldist) using this direct method
!              is computed by collecting coordinates of no-slip wall patches 
!              in all regions and stored in a buffer. The wall distance is 
!              the minimum of the distance between the coordinates in the 
!              buffer and each cell centroid. In this way, global wall distance 
!              is obtained, assuming open view (OV) from cell centers to 
!              the nearest wall.
!
! Input: region = data of current region.
!
! Output: region%levels%turb%lens = turbulence length scale.
!
! Notes: this method is computationally intensive, not suitable for moving
!        grid. More efficient method is provided by other routines.        
!
!******************************************************************************
!
! $Id: TURB_coRansWallDistOVFlu.F90,v 1.7 2009/08/26 12:28:53 mtcampbe Exp $
!
! Copyright: (c) 2003 by the University of Illinois
!
!******************************************************************************

SUBROUTINE turb_coranswalldistov( regions )

  USE moddatatypes
  USE moddatastruct, ONLY : t_region
  USE modglobal, ONLY     : t_global
  USE turb_modinterfaces, ONLY : turb_ranswalldistovpatch
  USE moderror
  USE modmpi
  USE modparameters
  USE turb_modparameters
  IMPLICIT NONE

! ... parameters
  TYPE(t_region), POINTER :: regions(:)

! ... loop variables
  INTEGER :: ireg, ic, n, ipatch

! ... local variables
  TYPE(t_global), POINTER :: global

#ifdef MPI
  INTEGER :: status(mpi_status_size)
#endif
  INTEGER :: iregglob, ncount, icount, accwalldim
  INTEGER, POINTER :: walldim(:)
  REAL(RFREAL) :: onethird, distance, xdist, ydist, zdist, loclens, cdes
  REAL(RFREAL), POINTER :: xyz(:,:), cofg(:,:), lens(:)

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

  global => regions(1)%global
  CALL registerfunction( global,'TURB_CoRansWallDistOV',&
  'TURB_coRansWallDistOVFlu.F90' )

  IF (global%turbWallDim == 0) goto 888

! allocation and initialisation -----------------------------------------------

  ALLOCATE( walldim(global%nRegions) )  ! wall dimension/region, all processors

  IF (.NOT. (global%turbWorkUnused .eqv. .true.)) &
  CALL errorstop( global,err_turb_workspace,__line__ ) 
  global%turbWorkDim = ndir*global%turbWallDim
  ALLOCATE( global%turbWork1D(global%turbWorkDim) )

  global%turbWorkUnused = .false. 
  onethird   = 1._rfreal/3._rfreal
  walldim(:) = 0
  ncount     = 0
  icount     = 0
  accwalldim = 0
  global%turbWorkDim = 0

! search for ns patch and store wall xyz in global%turbWork1D

  DO ireg=1,global%nRegionsLocal
    iregglob = regions(ireg)%iRegionGlobal

    DO ipatch=1,regions(ireg)%grid%nPatches
      CALL turb_ranswalldistovpatch( regions(ireg), &
                                     regions(ireg)%patches(ipatch) )
    ENDDO ! iPatch
    walldim(iregglob) = global%turbWorkDim - accwalldim
    accwalldim        = accwalldim + walldim(iregglob)

#ifdef MPI
! - distribut wall dimension acquired from each region/processor to all procs.

!c    CALL MPI_BCAST( wallDim(iRegGlob),1,MPI_INTEGER,regions(iReg)%procId, &
!c                    global%mpiComm,global%mpierr )
    IF (global%mpierr /=0 ) CALL errorstop( global,err_mpi_trouble,__line__ )

! - screen output check
!    write(*,*)global%myProcid,iReg,global%turbWorkDim,wallDim(iReg), &
!          NDIR*global%turbWallDim

! - collect wall coordinates (xyz) from all processors to Master processor

    IF (global%myProcid == masterproc) THEN

      IF (walldim(iregglob) > 0) THEN
!c        IF (regions(iReg)%procid /= global%myProcid) THEN

!c          CALL MPI_RECV( global%turbWork1D(1+ncount),wallDim(iRegGlob), &
!c                         MPI_RFREAL,regions(iReg)%procId,iRegGlob, &
!c                         global%mpiComm,status,global%mpierr )
          IF (global%mpierr /=0 ) CALL errorstop( global,err_mpi_trouble,__line__ )

!c        ENDIF

        ncount = ncount + walldim(iregglob)

! ----- screen output check        
!        write(*,*) 'ncount',ireg,ncount

      ENDIF
    ELSE   
      IF (walldim(iregglob) > 0) THEN

! ----- screen output check
!       write(*,*)'send=',ireg

        CALL mpi_send( global%turbWork1D(1+icount),walldim(iregglob),mpi_rfreal, &
                       masterproc,iregglob,global%mpiComm,status,global%mpierr )
        IF (global%mpierr /=0 ) CALL errorstop( global,err_mpi_trouble,__line__ )

        icount = icount + walldim(iregglob)

      ENDIF ! wallDim
    ENDIF   ! myProcId
#endif
  ENDDO     ! iReg

! check consistency of total wall dimension

  IF (global%myProcid == masterproc) THEN 
#ifdef MPI
    global%turbWorkDim = ncount
#endif
    IF (global%turbWorkDim /= ndir*global%turbWallDim) &
    CALL errorstop( global,err_turb_ransinput,__line__, &
                 'work array dim. is not consistent with wall array dim.')
  ENDIF

! distribute wall coordinates from Master processor to all

#ifdef MPI
  CALL mpi_bcast( global%turbWork1D,ndir*global%turbWallDim,mpi_rfreal, &
                  masterproc,global%mpiComm,global%mpierr )
  IF (global%mpierr /=0 ) CALL errorstop( global,err_mpi_trouble,__line__ )
#endif

888  CONTINUE

! compute turbulence length scale for RaNS and modified if DES is selected

  DO ireg=1,global%nRegionsLocal

    cdes = regions(ireg)%turbInput%cDes

    xyz  => regions(ireg)%grid%xyz
    cofg => regions(ireg)%grid%cofg
    lens => regions(ireg)%turb%lens 
    lens =  global%refLength

! - RaNS wall distance providing no-slip wall exist

    DO ic = 1,regions(ireg)%grid%nCellsTot
      lens(ic) = 1.e+32_rfreal
      DO n = 1,ndir*global%turbWallDim,ndir
        xdist     = cofg(xcoord,ic)-global%turbWork1D(n)
        ydist     = cofg(ycoord,ic)-global%turbWork1D(n+1)
        zdist     = cofg(zcoord,ic)-global%turbWork1D(n+2)
        distance  = sqrt( xdist**2 + ydist**2 + zdist**2 )
        lens(ic)  = min( lens(ic),distance )
      ENDDO ! n

! --- screen output check
!     IF(i==30 .and.k==2) write(*,*)ireg,j,lens(iC)
    ENDDO   ! iC

! - DES length scale and flows without no-slip walls

    IF ((regions(ireg)%mixtInput%turbModel == turb_model_dessa) .OR. &
        (regions(ireg)%mixtInput%turbModel == turb_model_hdessa) .OR. &
        (global%turbWallDim == 0)) THEN
      DO ic = 1,regions(ireg)%grid%nCellsTot
        loclens  = regions(ireg)%grid%vol(ic)**onethird  ! waiting for 
                                                         ! Andreas` c2e
        lens(ic) = min( lens(ic),cdes*loclens )
      ENDDO ! iC
    ENDIF   ! DES or no-nswall

  ENDDO     ! iReg

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

  DEALLOCATE( global%turbWork1D, walldim )
  global%turbWorkUnused = .true.

  CALL deregisterfunction( global )

END SUBROUTINE turb_coranswalldistov

!******************************************************************************
!
! RCS Revision history:
!
! $Log: TURB_coRansWallDistOVFlu.F90,v $
! Revision 1.7  2009/08/26 12:28:53  mtcampbe
! Ported to Hera.   Fixed logical expression syntax errors.  Replaced all
! IF (logical_variable)  with IF (logical_variable .eqv. .true.) as
! consistent with the specification.  Also changed: IF( ASSOCIATED(expr) )
! to IF ( ASSOCIATED(expr) .eqv. .true. ).   Intel compilers produce code
! which silently fails for some mal-formed expressions, so these changes
! are a net which should ensure that they are evaluated as intended.
!
! Revision 1.6  2008/12/06 08:44:43  mtcampbe
! Updated license.
!
! Revision 1.5  2008/11/19 22:17:55  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.4  2005/03/09 06:36:15  wasistho
! incorporated HDESSA
!
! Revision 1.3  2005/01/12 01:13:12  wasistho
! removed single quote signs since SUN has trouble with it
!
! Revision 1.2  2004/05/28 01:55:38  wasistho
! commented MPI lines temporarily to compile RFLU with MPI
!
! Revision 1.1  2004/03/25 04:42:57  wasistho
! prepared for RFLU
!
!
!
!******************************************************************************