RFLO_DualTimeStepping.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: integrate the governing equations in time using
!          dual time-stepping; move/regenerate the grid.
!
! Description: none.
!
! Input: dTimeSystem = total solution time
!        regions     = data for all grid regions
!
! Output: regions = flow variables and grid for all grid regions.
!
! Notes: scheme also applicable for small time steps.
!
!******************************************************************************
!
! $Id: RFLO_DualTimeStepping.F90,v 1.30 2008/12/06 08:44:26 mtcampbe Exp $
!
! Copyright: (c) 2003 by the University of Illinois
!
!******************************************************************************

SUBROUTINE rflo_dualtimestepping( dTimeSystem,regions )

  USE moddatatypes
  USE moddatastruct, ONLY : t_region
  USE modglobal, ONLY     : t_global
  USE modinterfaces, ONLY : rflo_movegridblocks, rflo_movegridglobal, &
        rflo_newgrid, rflo_dualtstinit, rflo_dualtstpredict, rflo_dualtststerm,&
        rflo_dualtstshift, explicitmultistage, rflo_calcmassflow, &
        rflo_calcforces, writeprobe, rflo_writegrid, rflo_writesolution, &
        writeconvergence, rflo_residualnorm, rflo_sendboundaryvalues, &
        rflo_calcthrust, writethrust, rflo_computeintegralvalues, &
        rflo_timestepinviscid, rflo_timestepviscous, rflo_minimumtimestep, &
        rungekuttamp, rflo_setmstagecoeffs, rflo_writerandomstate

  USE rflo_modforcesmoments,    ONLY : rflo_computepatchforcemomco, &
                                       rflo_computeintegralforcemomco, &
                                       rflo_writeintegralforcemomco
  USE rflo_modmovegridframe,    ONLY : rflo_movegridframe
  USE rflo_modmovegridelliptglo,ONLY : rflo_movegridelliptglo
  USE rflo_modmovegridelliptfra,ONLY : rflo_movegridelliptfra
  USE rflo_modvolmeshsmoothing, ONLY : rflo_movegridvms
  USE rflo_modpatchaerocoeffs,  ONLY : rflo_writepatchaerocoeffs
  USE rflo_modrestartinfo,      ONLY : rflo_writerestartinfo
#ifdef PLAG
  USE modinterfaceslagrangian, ONLY : plag_writesolution
#endif
#ifdef PEUL
  USE modinterfaceseulerian, ONLY : peul_writesolution
#endif
#ifdef RADI
  USE modinterfacesradiation, ONLY : radi_rflo_writesolution
#endif
#ifdef SPEC
  USE modinterfacesspecies, ONLY : spec_writesolution
#endif
#ifdef TURB
  USE modinterfacesturbulence, ONLY : turb_calcmetrics, &
                                      turb_rflo_writesolution
#endif
#ifdef PERI
  USE peri_modhybriddes, ONLY : peri_comeancorrection 
#endif
#ifdef STATS
  USE modinterfaces, ONLY : rflo_writestat
  USE modstatsroutines, ONLY : getstatistics
  USE rflo_modstatsboundaryconditions, ONLY : rflo_statboundaryconditionsset
#endif
  USE moderror
  USE modmpi
  USE modparameters
  IMPLICIT NONE

! ... parameters
  REAL(RFREAL) :: dtimesystem

  TYPE(t_region), POINTER :: regions(:)

! ... loop variables
  INTEGER :: ireg, subiter

! ... local variables
  INTEGER, SAVE :: iter=0
  INTEGER, ALLOCATABLE :: timescheme(:)

  LOGICAL :: stopexists, finished, ftermnew, residfterm, &
             doprint, dowrite, doprobe, dothrust, movegrid

  REAL(RFREAL), SAVE :: timeprint=0._rfreal, timewrite =0._rfreal, &
                        timeprobe=0._rfreal, timethrust=0._rfreal
  REAL(RFREAL) :: time, subtime, timebc, alphabc, residrat
  REAL(RFREAL), ALLOCATABLE :: cfl(:), smoocf(:)
  REAL(RFREAL), POINTER :: cv(:,:), cvn(:,:), cvn1(:,:), cvn2(:,:)

  TYPE(t_global), POINTER :: global

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

  global => regions(1)%global

  CALL registerfunction( global,'RFLO_DualTimeStepping',&
  'RFLO_DualTimeStepping.F90' )

! initialize parameters -------------------------------------------------------

#ifdef GENX
  IF (global%predCorrIter) THEN
    iter = 0
    global%predCorrIter = .false.
  ENDIF
#endif

  time         = 0._rfreal

  IF (global%dtFixed) THEN
    IF (global%currentTime <= epsilon( 1._rfreal )) THEN  ! more accurate
      global%dtMin = global%dtImposed                     ! but slower
    ENDIF
  ELSE
    global%dtMin = global%dtImposed                       ! for more speed
  ENDIF

  finished       = .false.   ! run not finished yet
  global%stopRun = 0._rfreal

! no multigrid here

  ftermnew   = .false.       ! no new forcing term
  residfterm = .false.       ! do not add forcing term to residual

! got some moving grid?

  movegrid = .false.
  DO ireg=1,global%nRegions
    IF (regions(ireg)%mixtInput%moveGrid) movegrid = .true.
  ENDDO

! initialize solutions --------------------------------------------------------

  IF (iter == 0) THEN

    global%dualTstSource = .false.    ! ordinary Runge-Kutta here

! - solution at level n-2

    CALL rflo_dualtstinit( regions,2 )

! - store scheme, CFL, epsIRS (overwritten for Runge-Kutta!)

    ALLOCATE( timescheme(global%nRegions) )
    ALLOCATE( cfl(global%nRegions) )
    ALLOCATE( smoocf(global%nRegions) )
    DO ireg=1,global%nRegions                            ! commented since all
!      IF (regions(iReg)%procid==global%myProcid .AND. & ! procs need trk from
!          regions(iReg)%active==ACTIVE) THEN            ! ireg=1 (see ExpMS)
        timescheme(ireg) = regions(ireg)%mixtInput%timeScheme
        cfl(ireg)        = regions(ireg)%mixtInput%cfl
        smoocf(ireg)     = regions(ireg)%mixtInput%smoocf
        regions(ireg)%mixtInput%timeScheme = tst_std4rk
        regions(ireg)%mixtInput%cfl        = 3._rfreal
        CALL rflo_setmstagecoeffs( global,regions(ireg)%mixtInput,global%nrkSteps )
!      ENDIF     ! region on this processor and active
    ENDDO       ! iReg

! - solutions at levels n-1 and n

    subtime = 0._rfreal

    DO subiter=1,0,-1
      global%dtMin = 1.e+30_rfreal
      DO ireg=1,global%nRegions
        IF (regions(ireg)%procid==global%myProcid .AND. &   ! region active and
            regions(ireg)%active==active) THEN              ! on my processor
          IF (regions(ireg)%mixtInput%flowModel == flow_euler) THEN
            CALL rflo_timestepinviscid( regions(ireg) )
          ELSE
            CALL rflo_timestepviscous( regions(ireg) )
          ENDIF
        ENDIF     ! region on this processor and active
      ENDDO       ! iReg
      CALL rflo_minimumtimestep( regions )
      IF (time+global%dtMin > dtimesystem) THEN   ! do not run over max. time
        global%dtMin = dtimesystem - time
      ENDIF

      IF (movegrid) CALL rflo_movegridblocks( regions )

      CALL rungekuttamp( regions )
      CALL rflo_dualtstinit( regions,subiter )

      global%currentTime = global%currentTime + global%dtMin
      time               = time + global%dtMin
      subtime            = subtime + global%dtMin
    ENDDO  ! subIter

! - restore scheme, CFL, epsIRS again

    DO ireg=1,global%nRegions
      IF (regions(ireg)%procid==global%myProcid .AND. &  ! region active and
          regions(ireg)%active==active) THEN             ! on my processor
        regions(ireg)%mixtInput%timeScheme = timescheme(ireg)
        regions(ireg)%mixtInput%cfl        = cfl(ireg)
        regions(ireg)%mixtInput%smoocf     = smoocf(ireg)
        CALL rflo_setmstagecoeffs( global,regions(ireg)%mixtInput,global%nrkSteps )
      ENDIF     ! region on this processor and active
    ENDDO       ! iReg
    DEALLOCATE( timescheme )
    DEALLOCATE( cfl        )
    DEALLOCATE( smoocf     )

! - substract subTime from the first implicit time step

    IF (global%dtImposed <= subtime) THEN
      global%dtMin = 0._rfreal
      DO
        global%dtMin = global%dtMin + global%dtImposed
        IF (global%dtMin > subtime) EXIT
      ENDDO
      global%dtMin = global%dtMin - subtime
    ELSE
      global%dtMin = global%dtImposed - subtime
    ENDIF
    global%dualTstSource = .true.

  ENDIF   ! iter=0

! time steps ------------------------------------------------------------------

  DO

    IF (global%dtFixed) THEN

! --- Fixed dt for speed (default)
      IF (iter > 0) global%dtMin = global%dtImposed

    ELSE

! --- Adjustable dt for higher accuracy, but slower
      residrat = global%residual/(global%resInit*global%tolSubIter)
      IF (iter == 0)  THEN
        global%dtMin = 0.01_rfreal * global%dtMin
      ELSEIF (iter == 1) THEN
        IF (global%currentTime < global%dtImposed) & ! even more accrt bt slwer
          global%dtMin = global%dtImposed
      ELSEIF (iter > 1) THEN
        IF (residrat > 1._rfreal) THEN
          global%dtMin = 0.75_rfreal*global%dtMin
        ELSE
          IF (global%dtMin < global%dtImposed) &
            global%dtMin = min( 1.25_rfreal*global%dtMin, global%dtImposed )
        ENDIF  ! residRat
      ENDIF    ! iter

    ENDIF      ! dtFixed

    IF (time+global%dtMin > dtimesystem) THEN   ! do not run over max. time
      global%dtMin = dtimesystem - time
      finished     = .true.
    ENDIF

! - move grid

    IF (movegrid) THEN
      IF (global%moveGridScheme == movegrid_blocks) THEN
        CALL rflo_movegridblocks( regions )
      ELSEIF (global%moveGridScheme == movegrid_global) THEN
        CALL rflo_movegridglobal( regions )
      ELSEIF (global%moveGridScheme == movegrid_frame .OR. &
              global%moveGridScheme == movegrid_foms) THEN
        CALL rflo_movegridframe( regions )
      ELSEIF (global%moveGridScheme == movegrid_elglobal) THEN
        CALL rflo_movegridelliptglo( regions )
      ELSEIF (global%moveGridScheme == movegrid_elframe) THEN
        CALL rflo_movegridelliptfra( regions )
      ELSE
        CALL rflo_movegridvms( regions )
      ENDIF
    ENDIF

! - new grid needed?

    IF (movegrid) THEN
      CALL rflo_newgrid( regions )
    ENDIF

! - recompute metrics of MP modules due to moving grid

    IF (movegrid) THEN
#ifdef TURB
      IF (global%turbActive) CALL turb_calcmetrics( regions, 0 )
#endif
    ENDIF

! - compute source term for implicit scheme; guess start solution

    DO ireg=1,global%nRegions
      IF (regions(ireg)%procid==global%myProcid .AND. &  ! region active and
          regions(ireg)%active==active) THEN             ! on my processor
        CALL rflo_dualtststerm( regions(ireg) )
        IF (global%predictSol .OR. iter==0) &
          CALL rflo_dualtstpredict( regions(ireg) )
      ENDIF     ! region on this processor and active
    ENDDO       ! iReg

! - new solution (do subiterations)

    subiter         = 0
    global%flowType = flow_steady

    DO
      subiter            = subiter + 1
      global%currentIter = subiter
      CALL explicitmultistage( regions,ftermnew,residfterm )
      CALL rflo_residualnorm( regions )
      IF (global%myProcid==masterproc .AND. global%verbLevel>=verbose_high) THEN
        WRITE(stdout,'(A,1X,2I6,1PE13.4,E13.4)') &
          solver_name,iter,subiter,global%residual/global%resInit,global%residual
      ENDIF
      IF (subiter==global%maxSubIter .OR. &
          global%residual/global%resInit<=global%tolSubIter .OR. &
          global%residual<100._rfreal*epsilon(1.0_rfreal)) EXIT
    ENDDO
    IF (global%myProcid == masterproc .AND. global%verbLevel>=verbose_low) THEN
      WRITE(stdout,'(A,1X,I6,1PE13.4,E13.4)') &
        solver_name,subiter,global%residual/global%resInit,global%residual
    ENDIF

    global%flowType = flow_unsteady

! - shift time levels

    DO ireg=1,global%nRegions
      IF (regions(ireg)%procid==global%myProcid .AND. &  ! region active and
          regions(ireg)%active==active) THEN             ! on my processor
        CALL rflo_dualtstshift( regions(ireg) )
      ENDIF     ! region on this processor and active
    ENDDO       ! iReg

#ifdef PERI
! - hybrid (guided) DES

    DO ireg=1,global%nRegions
      IF (regions(ireg)%procid==global%myProcid .AND. &  ! region active and
          regions(ireg)%active==active) THEN             ! on my processor
        IF ( regions(ireg)%periInput%flowKind /= off ) THEN
          CALL peri_comeancorrection( regions(ireg) )
        ENDIF ! flowKind 
      ENDIF   ! region on this processor and active
    ENDDO     ! iReg
#endif

#ifdef STATS
! - get statistics

    CALL getstatistics( regions )
#endif

! - update physical time

    global%currentTime = global%currentTime + global%dtMin
    time = time + global%dtMin
    iter = iter + 1

! - print/write convergence, data, probe or thrust?

    IF (iter == 1) THEN
      timeprint  = global%timeStamp + global%printTime
      timewrite  = global%timeStamp + global%writeTime
      timeprobe  = global%timeStamp + global%probeSaveTime
      timethrust = global%timeStamp + global%thrustSaveTime
    ENDIF

    doprint  = .false.
    dowrite  = .false.
    doprobe  = .false.
    dothrust = .false.
    IF (abs(timeprint-global%currentTime)<global%dtMin/10._rfreal .OR. &
        timeprint<global%currentTime .OR. iter==1) THEN
      doprint = .true.
      IF (iter > 1) timeprint = timeprint + global%printTime
    ENDIF
    IF (abs(timewrite-global%currentTime)<global%dtMin/10._rfreal .OR. &
        timewrite<global%currentTime) THEN
      dowrite   = .true.
      timewrite = timewrite + global%writeTime
    ENDIF
    IF (abs(timeprobe-global%currentTime)<global%dtMin/10._rfreal .OR. &
        timeprobe<global%currentTime .OR. iter==1) THEN
      doprobe = .true.
      IF (iter > 1) timeprobe = timeprobe + global%probeSaveTime
    ENDIF
    IF (abs(timethrust-global%currentTime)<global%dtMin/10._rfreal .OR. &
        timethrust<global%currentTime .OR. iter==1) THEN
      dothrust = .true.
      IF (iter > 1) timethrust = timethrust + global%thrustSaveTime
    ENDIF

! - check for stop file

#ifndef GENX
    INQUIRE(file="STOP",exist=stopexists)
    IF (stopexists) global%stopRun = 1.1_rfreal
#endif

! - check for end of time stepping

    IF (time >= dtimesystem) finished = .true.

! - compute forces, mass flow & thrust;
! - store probe data, thrust and flow solution

    global%forceX      = 0._rfreal
    global%forceY      = 0._rfreal
    global%forceZ      = 0._rfreal
    global%massIn      = 0._rfreal
    global%massOut     = 0._rfreal
    global%thrustMom   = 0._rfreal
    global%thrustPress = 0._rfreal

    DO ireg=1,global%nRegions
      IF (regions(ireg)%procid==global%myProcid .AND. &  ! region active and
          regions(ireg)%active==active) THEN             ! on my processor

! ----- store probe, aero-coeffs. and thrust data
#ifdef GENX
        IF (global%nProbes>0 .AND. doprobe) &
          CALL writeprobe( regions,ireg )

        IF (global%aeroCoeffs==active .AND. doprobe) &
          CALL rflo_computepatchforcemomco( regions(ireg) )

        IF (global%thrustType/=thrust_none .AND. dothrust) &
          CALL rflo_calcthrust( regions(ireg) )
#else
        IF (global%nProbes>0 .AND. (doprobe.OR.finished)) &
          CALL writeprobe( regions,ireg )

        IF (global%aeroCoeffs==active .AND. (doprobe.OR.finished)) &
          CALL rflo_computepatchforcemomco( regions(ireg) )

        IF (global%thrustType/=thrust_none .AND. (dothrust.OR.finished)) &
          CALL rflo_calcthrust( regions(ireg) )
#endif

! ----- get forces, mass flow
        IF (doprint .OR. finished) THEN
          CALL rflo_calcmassflow( regions(ireg) )
          CALL rflo_calcforces( regions(ireg) )
        ENDIF
      ENDIF     ! region on this processor and active
    ENDDO       ! iReg

! - compute and write global aero-coeffs. to file
#ifdef GENX
    IF (global%aeroCoeffs==active .AND. doprobe) THEN
      CALL rflo_computeintegralforcemomco( global )
      CALL rflo_writeintegralforcemomco( global )
    ENDIF
#else
    IF (global%aeroCoeffs==active .AND. (doprobe.OR.finished)) THEN
      CALL rflo_computeintegralforcemomco( global )
      CALL rflo_writeintegralforcemomco( global )
    ENDIF
#endif

! - write thrust to file
#ifdef GENX
    IF (global%thrustType/=thrust_none .AND. dothrust) &
      CALL writethrust( global )
#else
    IF (global%thrustType/=thrust_none .AND. (dothrust.OR.finished)) &
      CALL writethrust( global )
    IF (movegrid) CALL rflo_computeintegralvalues( regions )
#endif

! - write convergence history (file & screen)

    IF (doprint .OR. finished) THEN
#ifdef MASS
      CALL rflo_computeintegralvalues( regions )
      WRITE(stdout,*) 'Total mass = ',global%totalMass
#endif
      CALL writeconvergence( global )
#ifndef GENX
      IF (global%stopRun > 1._rfreal) THEN
        finished = .true.
      ENDIF
#endif
    ENDIF

#ifndef GENX
! - store flow field (and grid if moving)

    IF (dowrite .OR. finished) THEN
      IF (movegrid) THEN
        IF (global%myProcid==masterproc .AND. &
            global%verbLevel/=verbose_none) THEN
          WRITE(stdout,'(/,A)') solver_name//' Saving grid ...'
        ENDIF
        CALL rflo_writegrid( regions )
      ENDIF
      IF (global%myProcid==masterproc .AND. &
          global%verbLevel/=verbose_none) THEN
        WRITE(stdout,'(/,A)') solver_name//' Saving flow solution ...'
      ENDIF
      IF (global%myProcid==masterproc .AND. &
          global%verbLevel>=verbose_high) THEN
        WRITE(stdout,'(A)')   solver_name//'   - mixture'
      ENDIF
      CALL rflo_writesolution( regions )
      CALL rflo_writerandomstate( regions )

      IF (global%aeroCoeffs == active) THEN
        IF (global%myProcid==masterproc .AND. &
            global%verbLevel>=verbose_high) THEN
          WRITE(stdout,'(A)') solver_name//'   - patch ac'
        ENDIF
        CALL rflo_writepatchaerocoeffs( regions )
      ENDIF
#ifdef STATS
      IF (global%doStat==active) THEN
        IF (global%myProcid==masterproc .AND. &
            global%verbLevel/=verbose_none) THEN
          WRITE(stdout,'(/,A)') solver_name,' Saving statistics ...'
        ENDIF
        CALL rflo_statboundaryconditionsset( regions )
        CALL rflo_writestat( regions )
      ENDIF
#endif
#ifdef PLAG
      CALL plag_writesolution( regions )
#endif
#ifdef PEUL
      CALL peul_writesolution( regions )
#endif
#ifdef RADI
      IF (global%radiActive) THEN
        IF (global%myProcid==masterproc .AND. &
            global%verbLevel/=verbose_none) THEN
          WRITE(stdout,'(/,A)') solver_name,' Saving radiation solution ...'
        ENDIF
        CALL radi_rflo_writesolution( regions )
      ENDIF
#endif
#ifdef SPEC
      CALL spec_writesolution( regions )
#endif
#ifdef TURB
      IF (global%turbActive) THEN
        IF (global%myProcid==masterproc .AND. &
            global%verbLevel/=verbose_none) THEN
          WRITE(stdout,'(/,A)') solver_name,' Saving turbulence solution ...'
        ENDIF
        CALL turb_rflo_writesolution( regions )
      ENDIF
#endif
      CALL rflo_writerestartinfo( global )

    ENDIF ! doWrite
#endif

! - run finished?

    IF (finished) THEN
      DO ireg=1,global%nRegions
        IF (regions(ireg)%procid==global%myProcid .AND. &  ! region active and
            regions(ireg)%active==active) THEN             ! on my processor
          CALL rflo_sendboundaryvalues( regions(ireg),.false. )
        ENDIF     ! region on this processor and active
      ENDDO       ! iReg
      global%timeStamp = global%currentTime
      EXIT
    ENDIF

  ENDDO  ! loop over physical time

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

  CALL deregisterfunction( global )

END SUBROUTINE rflo_dualtimestepping

!******************************************************************************
!
! RCS Revision history:
!
! $Log: RFLO_DualTimeStepping.F90,v $
! Revision 1.30  2008/12/06 08:44:26  mtcampbe
! Updated license.
!
! Revision 1.29  2008/11/19 22:17:37  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.28  2006/05/09 23:32:06  wasistho
! added fixed-or-free dt options in implicit dtst
!
! Revision 1.27  2006/05/05 17:35:27  wasistho
! commented back region-split for parallel, all procs need trk
!
! Revision 1.26  2006/04/15 00:23:28  wasistho
! set constant dt as default timestepping
!
! Revision 1.25  2006/03/24 23:29:01  wasistho
! added forceMomentCoeffs computation and output
!
! Revision 1.24  2006/03/22 03:03:32  wasistho
! added call to RFLO_WritePatchAeroCoeffs
!
! Revision 1.23  2006/03/06 08:07:45  wasistho
! set to more agressive stepping
!
! Revision 1.22  2006/03/02 01:26:40  wasistho
! split movegrid_epde to elglobal and elframe
!
! Revision 1.21  2006/02/11 03:55:58  wasistho
! added MOVEGRID_EPDE
!
! Revision 1.20  2006/02/01 20:10:13  wasistho
! added WriteRestartInfo
!
! Revision 1.19  2006/01/28 03:12:45  wasistho
! set adjustable timestep to more accurate option
!
! Revision 1.18  2006/01/27 07:32:04  wasistho
! adjustable timestep for stability
!
! Revision 1.17  2006/01/26 08:25:23  wasistho
! bug fixed: invert the dtMin adjuster
!
! Revision 1.16  2006/01/26 08:10:58  wasistho
! relate dtMin to previous residual
!
! Revision 1.15  2006/01/13 00:08:28  wasistho
! bound global%dtMin within max.time
!
! Revision 1.14  2005/11/07 19:49:11  wasistho
! added MOVEGRID_FOMS
!
! Revision 1.13  2005/06/16 03:52:40  wasistho
! activated RFLO_ModStatsBc
!
! Revision 1.12  2005/06/02 03:21:25  wasistho
! shuffle MoveGridVms with MoveGridFrame
!
! Revision 1.11  2005/05/28 08:08:28  wasistho
! added moveGridFrame
!
! Revision 1.10  2005/05/21 07:08:18  wasistho
! backout RFLO_ModStatsBoundaryConditions temporarily
!
! Revision 1.9  2005/05/21 01:43:54  wasistho
! added rflo_StatBcSet
!
! Revision 1.8  2005/05/21 00:18:52  wasistho
! added moveGridVms
!
! Revision 1.7  2005/04/17 05:09:50  wasistho
! mv guided DES treatment to before statistics
!
! Revision 1.6  2005/03/10 02:03:23  wasistho
! test calling PERI_coMeanCorrection from DualTsT i.o.EMS
!
! Revision 1.5  2005/02/26 04:05:38  wasistho
! added RFLO_ComputeIntegralValues
!
! Revision 1.4  2004/12/28 20:27:12  wasistho
! moved statistics routines into module ModStatsRoutines
!
! Revision 1.3  2004/12/15 09:20:14  wasistho
! fixed dual tst for Rocstar
!
! Revision 1.2  2004/12/09 22:16:55  wasistho
! added data turbulence Metric computation
!
! Revision 1.1  2004/11/29 20:51:39  wasistho
! lower to upper case
!
! Revision 1.17  2004/11/29 17:15:38  wasistho
! use ModInterfacesStatistics
!
! Revision 1.16  2004/11/17 16:30:25  haselbac
! Adapted interface of RFLO_SetMStageCoeffs
!
! Revision 1.15  2004/09/23 03:50:04  wasistho
! changed RADI_WriteSol.. to RADI_RFLO_WriteSol..
!
! Revision 1.14  2004/03/11 03:31:33  wasistho
! changed rocturb nomenclature
!
! Revision 1.13  2004/02/11 03:28:09  wasistho
! get rid of argument numVar in TURB_WriteSolution
!
! Revision 1.12  2004/02/07 01:12:56  wasistho
! modified TURB_WriteSolution
!
! Revision 1.11  2003/11/21 22:35:51  fnajjar
! Update Random Number Generator
!
! Revision 1.10  2003/11/20 16:40:39  mdbrandy
! Backing out RocfluidMP changes from 11-17-03
!
! Revision 1.6  2003/09/26 21:44:28  fnajjar
! Modified ModInterfaces calls to proper physical modules
!
! Revision 1.5  2003/08/28 20:35:46  wasistho
! excluced ModInterfacesTurbulence,Radiation,Periodic from ModInterfaces
!
! Revision 1.4  2003/08/15 21:15:17  jblazek
! Corrected bug in output of thrust in case of GENX.
!
! Revision 1.3  2003/08/11 21:51:18  jblazek
! Added basic global grid smoothing scheme.
!
! Revision 1.2  2003/07/08 21:21:37  jblazek
! Modified start up procedure for dual-time stepping.
!
! Revision 1.1  2003/07/03 21:48:45  jblazek
! Implemented dual-time stepping.
!
!******************************************************************************