RFLU_InitFlowSolver.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: Main initialization routine of Rocflu-MP.
!
! Description: None.
!
! Input: None.
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************
!
! $Id: RFLU_InitFlowSolver.F90,v 1.123 2008/12/06 08:44:30 mtcampbe Exp $
! Copyright: (c) 2001-2006 by the University of Illinois
!
! ******************************************************************************

#ifdef GENX
SUBROUTINE rflu_initflowsolver(globalGenx,initialTime,communicator,genxHandle, &
                               surfwinnameinput,volwinnameinput,handleobtain)
#else
SUBROUTINE rflu_initflowsolver(casename,verbLevel,global,levels)
#endif

  USE moddatatypes
#ifdef GENX
  USE modrocstar, ONLY: t_globalgenx
#endif  
  USE modbndpatch, ONLY: t_patch
  USE moddatastruct, ONLY: t_level,t_region
  USE modmixture, ONLY: t_mixt_input  
  USE modglobal, ONLY: t_global
  USE modgrid, ONLY: t_grid
  USE modbndpatch, ONLY: t_patch
  USE moderror
  USE modmpi
  USE modparameters  
     
  USE rflu_modbfacegradaccesslist
  USE rflu_modboundlists   
  USE rflu_modboundxvutils
  USE rflu_modnscbc, ONLY: rflu_nscbc_decidehavenscbc
  USE rflu_modcellmapping
  USE rflu_modcommlists
  USE rflu_moddimensionality  
  USE rflu_moddimensions
  USE rflu_modedgelist   
  USE rflu_modfacelist
  USE rflu_modforcesmoments
  USE rflu_modgeometry
  USE rflu_modgridspeedutils
  USE rflu_modincelltest
  USE rflu_modinterpolation
  USE rflu_modmpi
  USE rflu_modoles
  USE rflu_modpatchcoeffs
  USE rflu_modpatchutils
  USE rflu_modprobes
  USE rflu_modreadbcinputfile
  USE rflu_modreadwritebcdatafile
  USE rflu_modreadwriteflow   
  USE rflu_modreadwritegrid 
  USE rflu_modreadwritegridspeeds
  USE rflu_modregionmapping
  USE rflu_modrenumberings
  USE rflu_modstencilsbfaces
  USE rflu_modstencilscells
  USE rflu_modstencilsfaces
  USE rflu_modstencilsutils
  USE rflu_modsymmetryperiodic, ONLY: rflu_sype_havesypepatches, & 
                                      rflu_sype_readtransforms
  USE rflu_modvertexlists
  USE rflu_modweights
    
#ifdef GENX
  USE rflu_modrocstaradmin
  USE rflu_modrocstario, ONLY: rflu_genx_getdatainterf, & 
                            rflu_genx_getdimensionsderived,&
                            rflu_genx_getglobaldata
#endif  
    
#ifdef PETSC
  USE rflu_modpetscadmin
!  USE RFLU_ModPETScPoisson
  USE rflu_modpetscnewtonkrylov
#endif
  
#ifdef PLAG
  USE plag_modsurfstats, ONLY: plag_createsurfstats, & 
                               plag_readsurfstatswrapper
#endif    
    
  USE rflu_modrelatedpatches, ONLY: rflu_relp_transformwrapper
    
  USE modinterfaces, ONLY: rflu_allocatememorytbc, &
                           rflu_allocatememorywrapper, &
                           rflu_builddatastruct, & 
                           rflu_computeintegrals1245oles, &
                           rflu_computeintegralvalues, &
                           rflu_creategrid, &
                           rflu_decideneedbgradface, &
                           rflu_getuserinput, & 
                           rflu_initglobal, &
                           rflu_movegridwrapper, &
                           rflu_openconverfile, &
                           rflu_openstatsfileoles, &
                           rflu_opentotalmassfile, &
                           rflu_printflowinfo, &
                           rflu_printgridinfo, & 
                           rflu_printheader, &
                           rflu_randominit, &
                           rflu_readintegrals1245oles, &
                           rflu_readrestartinfo, &
                           rflu_readtbcinputfile, &
                           rflu_setmoduletype, & 
                           rflu_setmovegridoptions, & 
                           rflu_setrestarttimeflag, &
                           rflu_setvarscontwrapper, &
                           rflu_setvarsdiscwrapper, & 
                           rflu_setvarinfowrapper, & 
                           rflu_setvarswrapper, & 
                           rflu_writeintegrals1245oles, &
                           rflu_writeversionstring, &
                           writetotalmass
                                                
#ifdef GENX
  USE modinterfaces, ONLY: rflu_checkcouplinginput, &
                           rflu_getboundaryvalues, &
                           rflu_putboundaryvalues
  USE rflu_modrocstartools, ONLY: rflu_genx_initbflag
#endif
#ifdef STATS
  USE modstatsroutines, ONLY: statmapping, initstatistics
#endif
  
  IMPLICIT NONE

#ifdef GENX
  include 'roccomf90.h'
#endif

! ******************************************************************************
! Arguments
! ******************************************************************************

#ifdef GENX
  CHARACTER(*), INTENT(IN) :: surfwinnameinput,volwinnameinput
  INTEGER, INTENT(IN) :: communicator,genxhandle,handleobtain
  DOUBLE PRECISION, INTENT(IN) :: initialtime
  TYPE(t_globalgenx), POINTER :: globalgenx
#else
  CHARACTER(CHRLEN), INTENT(IN) :: casename
  INTEGER, INTENT(IN) :: verblevel
  TYPE(t_global), POINTER :: global
#endif
  TYPE(t_level), POINTER :: levels(:)  
  
! ******************************************************************************
! Locals
! ******************************************************************************

  CHARACTER(CHRLEN) :: rcsidentstring,msg
  LOGICAL :: fileexists,movegrid
  INTEGER :: errorflag,ipatch,ireg
  REAL(RFREAL) :: currenttime
  TYPE(t_grid) :: grid
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_level), POINTER :: plevel
  TYPE(t_mixt_input), POINTER :: pmixtinput  
  TYPE(t_patch), POINTER :: ppatch
  TYPE(t_region), POINTER :: pregion

#ifdef GENX
  INTEGER :: verblevel
  CHARACTER(CHRLEN) :: casename
  TYPE(t_global), POINTER :: global  
#endif 

! ******************************************************************************
! Start, initialize some variables
! ******************************************************************************

  rcsidentstring = '$RCSfile: RFLU_InitFlowSolver.F90,v $ $Revision: 1.123 $'
 
  movegrid = .false.
 
! ******************************************************************************
! Set global pointer and initialize global type, register function
! ****************************************************************************** 
 
#ifdef GENX
  global => globalgenx%global 
     
  CALL rflu_initglobal(" ",verbose_low,communicator,global)
  CALL rflu_genx_readctrlfile(global)
  CALL rflu_genx_storecommunicator(global,communicator)

! ******************************************************************************
! Initialize MPI - ROCSTAR
! ****************************************************************************** 

  CALL mpi_comm_size(global%mpiComm,global%nProcAlloc,errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN 
    CALL errorstop(global,err_mpi_output,__line__)
  END IF ! global%error
    
  CALL mpi_comm_rank(global%mpiComm,global%myProcid,errorflag)  
  global%error = errorflag
  IF ( global%error /= err_none ) THEN 
    CALL errorstop(global,err_mpi_output,__line__)
  END IF ! global%error

  CALL rflu_genx_storenameshandles(global,surfwinnameinput,volwinnameinput, & 
                                   handleobtain)

  CALL com_set_verbose(global%verbLevelCOM)

  global%timeStamp   = initialtime
  global%currentTime = initialtime
#else
  CALL rflu_initglobal(casename,verblevel,mpi_comm_world,global)

! ******************************************************************************
! Initialize MPI Native
! ****************************************************************************** 

  CALL mpi_init(errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN 
    CALL errorstop(global,err_mpi_output,__line__)
  END IF ! global%error
  
  CALL mpi_comm_size(global%mpiComm,global%nProcAlloc,errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN 
    CALL errorstop(global,err_mpi_output,__line__)
  END IF ! global%error
    
  CALL mpi_comm_rank(global%mpiComm,global%myProcid,errorflag)  
  global%error = errorflag
  IF ( global%error /= err_none ) THEN 
    CALL errorstop(global,err_mpi_output,__line__)
  END IF ! global%error

#endif

  CALL rflu_setmoduletype(global,module_type_solver)

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

#ifndef GENX
#ifdef ROCPROF
! ******************************************************************************
! Initialize Rocprof. NOTE done here so everything can be profiled and also bcos
! RFLU_SetVars is called here.
! ****************************************************************************** 

  CALL rocprof_init("Rocflu",global%myProcid)
#endif
#endif

! ******************************************************************************
! Print header and check for stop file 
! ******************************************************************************

  IF ( global%myProcid == masterproc ) THEN 
    CALL rflu_writeversionstring(global)
  
    IF ( global%verbLevel /= verbose_none ) THEN
      CALL rflu_printheader(global)
    END IF ! global%verbLevel
  END IF ! global

  IF ( global%myProcid == masterproc ) THEN 
    INQUIRE(file="STOP",exist=fileexists)
    IF ( fileexists .EQV. .true. ) THEN
      CALL errorstop(global,err_stopfile_found,__line__)
    END IF ! fileExists
  END IF ! global%myProcid  

! ******************************************************************************
! Read processor mapping file, prepare data structure, set level pointer
! ******************************************************************************
 
  CALL rflu_readregionmappingfile(global,mapfile_readmode_peek,global%myProcId)
  CALL rflu_createregionmapping(global,maptype_reg)
  CALL rflu_readregionmappingfile(global,mapfile_readmode_all,global%myProcId)
  
  IF ( global%nRegions == 1 ) THEN 
    CALL rflu_imposeregionmappingserial(global)
  END IF ! global

  IF ( global%nProcs /= global%nProcAlloc ) THEN 
    CALL errorstop(global,err_proc_mismatch,__line__)
  END IF ! global%nProcs
  
  CALL rflu_builddatastruct(global,levels)
  CALL rflu_applyregionmapping(global,levels)
  CALL rflu_destroyregionmapping(global,maptype_reg)
    
#ifdef GENX    
  globalgenx%levels => levels
  plevel => globalgenx%levels(1) ! single-level grids for now      
#else
  plevel => levels(1) ! single-level grids for now   
#endif

#ifdef GENX
! ******************************************************************************
! Create windows and new attributes. NOTE must only be done once for every 
! process.
! ******************************************************************************
  
  pregion => plevel%regions(1)
  CALL rflu_genx_createwindows(pregion,communicator)
  CALL rflu_genx_createattrwrapper(pregion)
  
! ******************************************************************************
! Load modules
! ******************************************************************************

  CALL rocmop_load_module(trim(global%winName)//'-MOP')  
#endif           
           
! ******************************************************************************
! Read user input
! ******************************************************************************

  CALL rflu_getuserinput(plevel%regions)

! ******************************************************************************
! Initialize random number generator
! ******************************************************************************

  CALL rflu_randominit(plevel%regions)

! ******************************************************************************
! Read restart info. NOTE must not read restart info file for GENx runs because 
! will overwrite global%currentTime.
! ******************************************************************************
  
#ifndef GENX
  CALL rflu_readrestartinfo(global)
#endif
  CALL rflu_setrestarttimeflag(global)
  
! ******************************************************************************
! Read dimensions file
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_readdimensionswrapper(pregion)     
  END DO ! iReg

! ******************************************************************************
! Determine whether have moving grid
! ******************************************************************************

  movegridloop: DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    
    IF ( pregion%mixtInput%movegrid .EQV. .true. ) THEN
      movegrid = .true.       
      EXIT movegridloop
    END IF ! pRegion
  END DO movegridloop

! ******************************************************************************
! Allocate memory for grid and borders
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)

    CALL rflu_creategrid(pregion)
    CALL rflu_comm_createborders(pregion,create_borders_mode_dim_known)
  END DO ! iReg

! ******************************************************************************
! Read boundary condition file, must be done after creation of grid, because 
! grid and patches are created there.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    
    IF ( pregion%grid%nPatches > 0 ) THEN      
      CALL rflu_readbcinputfilewrapper(pregion)
      CALL rflu_allocatememorytbc(pregion)
      CALL rflu_readtbcinputfile(pregion)
    END IF ! pRegion%grid%nPatches    
  END DO ! iReg

#ifdef GENX
! ******************************************************************************
! Create surface and and register volume and surface grid. NOTE must be done 
! after having read comm lists because of pconn.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)

    CALL rflu_genx_getdimensionsderived(pregion)
    CALL rflu_genx_creategridsurf(pregion)    
    CALL rflu_genx_createpconn(pregion)
    CALL rflu_genx_registergridvol(pregion)
    CALL rflu_genx_registergridsurf(pregion)
  END DO ! iReg  
#endif
  
! ******************************************************************************
! Read grid file
! ******************************************************************************
  
  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_readgridwrapper(pregion)
  END DO ! iReg
 
! ******************************************************************************
! Print grid information
! ******************************************************************************

  IF ( global%myProcid == masterproc .AND. &
       global%verbLevel > verbose_none ) THEN
    DO ireg = 1,global%nRegionsLocal
      pregion => plevel%regions(ireg)
      CALL rflu_printgridinfo(pregion)
    END DO ! iReg
  END IF ! global%verbLevel

!*******************************************************************************
! Register Time Zooming Parameter
!*******************************************************************************
   
#ifdef GENX
  CALL rflu_genx_getglobaldata(global)
#endif

! ******************************************************************************
! Build data stucture, part 1
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg) 
    CALL rflu_createcellmapping(pregion)
    CALL rflu_readloc2globcellmapping(pregion)
    CALL rflu_buildglob2loccellmapping(pregion)      
  END DO ! iReg 

! ******************************************************************************
! Create and read comm lists, set proc ids for borders. Must be done before 
! face list is constructed because reorientation of actual-virtual faces
! requires knowledge of communication lists.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    pgrid   => pregion%grid   
    
    IF ( pgrid%nBorders > 0 ) THEN 
      CALL rflu_comm_createcommlists(pregion)
      CALL rflu_comm_readcommlists(pregion)
      CALL rflu_comm_getproclocregids(pregion)
    END IF ! pRegion%grid%nBorders
  END DO ! iReg  

! ******************************************************************************
! Build data stucture, part 2. Building the face list must be done after the 
! communication lists have been updated to take into account renumbering of 
! cells. Build cell-to-face list anyway, although only needed when have probes 
! or when running with higher-order scheme.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg) 
    CALL rflu_createbvertexlists(pregion)
    CALL rflu_buildbvertexlists(pregion)        
  END DO ! iReg

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg) 
    CALL rflu_createfacelist(pregion)
    CALL rflu_buildfacelist(pregion)
    CALL rflu_renumberbfacelists(pregion)

! TEMPORARY
!    IF ( pRegion%grid%nCellsTot > pRegion%grid%nCells ) THEN 
!      CALL RFLU_RNMB_CreatePBF2SBFMap(pRegion)
!      CALL RFLU_RNMB_CreatePC2SCMap(pRegion)
!      CALL RFLU_RNMB_CreatePV2SVMap(pRegion)
!      CALL RFLU_RNMB_ReadPxx2SxxMaps(pRegion)
!      CALL RFLU_ReorientFaces(pRegion) 
!! TEMPORARY
!!      CALL RFLU_RNMB_DestroyPBF2SBFMap(pRegion)
!!      CALL RFLU_RNMB_DestroyPC2SCMap(pRegion)
!!      CALL RFLU_RNMB_DestroyPV2SVMap(pRegion)
!! END TEMPORARY 
!    END IF ! pGrid%nCellsTot
! END TEMPORARY
  END DO ! iReg 

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_createcell2facelist(pregion)
    CALL rflu_buildcell2facelist(pregion)
  END DO ! iReg

#ifdef PLAG
  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)

    IF ( (pregion%global%plagUsed .EQV. .true.) .AND. & 
         (pregion%grid%nFacesAV > 0) ) THEN
      CALL rflu_createavface2borderlist(pregion)
      CALL rflu_buildavface2borderlist(pregion)
      
      CALL rflu_createavface2patchlist(pregion)
      CALL rflu_buildavface2patchlist(pregion)      
    END IF ! pRegion%global%plagUsed
  END DO ! iReg
#endif

! ******************************************************************************
! Build data stucture, part 3
! ******************************************************************************

  IF ( movegrid .EQV. .true. ) THEN
    DO ireg = 1,global%nRegionsLocal
      pregion => plevel%regions(ireg)
      CALL rflu_createedgelist(pregion)       
      CALL rflu_buildedgelist(pregion)      
      CALL rflu_createedge2celllist(pregion)              
      CALL rflu_buildedge2celllist(pregion)
      CALL rflu_destroyedge2celllist(pregion)      
    END DO ! iReg 
  END IF ! moveGrid

! ******************************************************************************
! Check topology
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal 
    pregion => plevel%regions(ireg)              
    CALL rflu_123d_checktopology(pregion)
  END DO ! iReg  

! ******************************************************************************
! Build boundary-face gradient access list for viscous flows
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal 
    pregion => plevel%regions(ireg) 
    
    IF ( pregion%mixtInput%flowModel == flow_navst ) THEN          
      CALL rflu_createbfacegradaccesslist(pregion)
      CALL rflu_buildbfacegradaccesslist(pregion)
    END IF ! pRegion%mixtInput
  END DO ! iReg  

! ******************************************************************************
! Allocate memory. NOTE must be done after having built face lists and after 
! reading boundary-condition file because of particle module.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_allocatememorywrapper(pregion)
    
    CALL rflu_createpatchcoeffs(pregion)
   
    IF ( global%forceFlag .EQV. .true. ) THEN 
      CALL rflu_createforcesmoments(pregion)
      CALL rflu_createglobalthrustflags(pregion)
    END IF ! global%forceFlag
  END DO ! iReg
    
! ------------------------------------------------------------------------------
! Set Global thrust flags from local thrust flags 
! ------------------------------------------------------------------------------

  CALL rflu_setglobalthrustflags(plevel%regions)

! ------------------------------------------------------------------------------
! Allocate memory for boundary variables if required, i.e., if NSCBC==1 
! ------------------------------------------------------------------------------

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    IF ( rflu_nscbc_decidehavenscbc(pregion) .EQV. .true. ) THEN
      CALL rflu_bxv_createvarscv(pregion)
      CALL rflu_bxv_createvarsdv(pregion)
      CALL rflu_bxv_createvarststep(pregion)
    END IF ! RFLU_NSCBC_DecideHaveNSCBC(pRegion)    

#ifdef PLAG
    IF ( global%plagUsed .EQV. .true. ) THEN 
      CALL plag_createsurfstats(pregion)
    END IF ! global%plagUsed
#endif    
  END DO ! iReg

! ******************************************************************************
! Set variable info. NOTE must be done after allocation of memory for solution.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_setvarinfowrapper(pregion)
  END DO ! iReg  

#ifdef STATS
! ******************************************************************************
! Statistics mapping (must be done before RFLU_GENX_RegisterData)
! ******************************************************************************

  IF (global%flowType == flow_unsteady .AND. global%doStat==active) THEN
    CALL statmapping( global )
  ENDIF
#endif

#ifdef GENX
! ******************************************************************************
! Register data with Roccom for interaction in GENX. NOTE must be done after 
! memory allocation.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    
    CALL rflu_genx_registerdatawrapper(pregion)
    CALL rflu_genx_createwindowsdone(pregion)
  END DO ! iReg  
#endif  

! ******************************************************************************
! Compute geometry
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)   
    CALL rflu_creategeometry(pregion)    
    CALL rflu_buildgeometry(pregion)
    CALL rflu_123d_checkgeometrywrapper(pregion)    
  END DO ! iReg 

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)   
    CALL rflu_computepatchnormalslocal(pregion)       
  END DO ! iReg 

  CALL rflu_computepatchnormalsglobal(plevel%regions)
  
  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)   
  CALL rflu_checkpatchbcconsistency(pregion)
  END DO ! iReg 

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    pmixtinput => pregion%mixtInput

    IF ( pmixtinput%fluidModel == fluid_model_incomp ) THEN
      CALL rflu_createfacedist(pregion)
      CALL rflu_computefacedist(pregion)
    END IF ! pMixtInput%fluidModel
  END DO ! iReg

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg) 
    
    IF ( rflu_sype_havesypepatches(pregion) .EQV. .true. ) THEN   
      CALL rflu_sype_readtransforms(pregion)       
    END IF ! RFLU_SYPE_HaveSyPePatches
  END DO ! iReg

! ******************************************************************************
! Build stencils. NOTE This must be done after the geometry is computed 
! because the stencils are now tested for singularity, which requires the
! computation of the weights and hence the geometry.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal 
    pregion => plevel%regions(ireg)
    pmixtinput => pregion%mixtInput 

    CALL rflu_createvert2celllist(pregion)
    CALL rflu_buildvert2celllist(pregion)
    
    IF ( pmixtinput%spaceOrder > 1 ) THEN 
      CALL rflu_setinfoc2cstencilwrapper(pregion,pmixtinput%spaceOrder-1) 
      CALL rflu_createc2cstencilwrapper(pregion)
      CALL rflu_buildc2cstencilwrapper(pregion)
      CALL rflu_buildlistcc2cstencil(pregion) 
    END IF ! pMixtInput%spaceOrder      
    
    IF ( pmixtinput%flowModel == flow_navst ) THEN
      CALL rflu_setinfof2cstencilwrapper(pregion,pmixtinput%spaceOrder-1)    
      CALL rflu_createf2cstencilwrapper(pregion)      
      CALL rflu_buildf2cstencilwrapper(pregion)   
      CALL rflu_buildlistcf2cstencil(pregion) 
    END IF ! pMixtInput%flowModel
      
    DO ipatch = 1,pregion%grid%nPatches 
      ppatch => pregion%patches(ipatch)

      IF ( rflu_decideneedbgradface(pregion,ppatch) .EQV. .true. ) THEN
        CALL rflu_setinfobf2cstencilwrapper(pregion,ppatch, &
                                            ppatch%spaceOrder)    
        CALL rflu_createbf2cstencilwrapper(pregion,ppatch)      
        CALL rflu_buildbf2cstencilwrapper(pregion,ppatch) 
      END IF ! RFLU_DecideNeedBGradFace
    END DO ! iPatch
    
    CALL rflu_destroyvert2celllist(pregion)
  END DO ! iReg

! ******************************************************************************
! Compute weights. NOTE must be done after stencils are built.
! ******************************************************************************

! ==============================================================================
! Weights for cell and face gradients
! ==============================================================================

  DO ireg = 1,global%nRegionsLocal 
    pregion => plevel%regions(ireg)
    pmixtinput => pregion%mixtInput   

    IF ( pmixtinput%spaceOrder > 1 ) THEN 
      CALL rflu_createwtsc2cwrapper(pregion,pmixtinput%spaceOrder-1)
      CALL rflu_computewtsc2cwrapper(pregion,pmixtinput%spaceOrder-1)
    END IF ! pMixtInput%spaceOrder      

    IF ( pmixtinput%flowModel == flow_navst ) THEN
      CALL rflu_createwtsf2cwrapper(pregion,pmixtinput%spaceOrder-1)    
      CALL rflu_computewtsf2cwrapper(pregion,pmixtinput%spaceOrder-1)
    END IF ! pMixtInput%flowModel
      
    DO ipatch = 1,pregion%grid%nPatches
      ppatch => pregion%patches(ipatch)
      
      IF ( rflu_decideneedbgradface(pregion,ppatch) .EQV. .true. ) THEN
        CALL rflu_createwtsbf2cwrapper(pregion,ppatch,ppatch%spaceOrder)    
        CALL rflu_computewtsbf2cwrapper(pregion,ppatch,ppatch%spaceOrder)    
      END IF ! RFLU_DecideNeedBGradFace
    END DO ! iPatch
  END DO ! iReg   

! ==============================================================================
! Weights for optimal LES approach. NOTE that at present, this will work only
! for non-moving grids.
! ==============================================================================

  DO ireg = 1,global%nRegionsLocal   
    pregion => plevel%regions(ireg)
    pmixtinput => pregion%mixtInput 

    IF ( pmixtinput%spaceDiscr == discr_opt_les ) THEN            
      CALL rflu_findprototypefacesoles(pregion)
      CALL rflu_buildstencilsoles(pregion)
      CALL rflu_computegeometrictermsoles(pregion)
      CALL rflu_buildsymmetrymapsoles(pregion)
      
!      CALL RFLU_ComputeIntegrals1245OLES(pRegion)
!      CALL RFLU_EnforceSymmetryOLES(pRegion)
!      CALL RFLU_WriteIntegrals1245OLES(pRegion)
      
      CALL rflu_readintegrals1245oles(pregion)
      CALL rflu_enforcesymmetryoles(pregion) 
!      CALL RFLU_WriteIntegrals1245OLES(pRegion)           
    END IF ! pMixtInput 
  END DO ! iReg 

#ifdef PLAG
! ******************************************************************************
! Compute in-cell test tolerance
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)

    IF ( pregion%global%plagUsed .EQV. .true. ) THEN 
      CALL rflu_ict_computetolerance(pregion)
    END IF ! pRegion%global%plagUsed
  END DO ! iReg
#endif

! ******************************************************************************
! Read solution data files
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)     
    CALL rflu_readflowwrapper(pregion)
    
#ifdef PLAG
    IF ( global%plagUsed .EQV. .true. ) THEN
      CALL plag_readsurfstatswrapper(pregion)
    END IF ! plagUsed
#endif          
  END DO ! iReg

#ifdef GENX
! ******************************************************************************
! Get interface data
! ******************************************************************************
  
  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)     
    CALL rflu_genx_getdatainterf(pregion)
  END DO ! iReg  
#endif

! ******************************************************************************
! Read boundary condition data (only relevant if distribution specified)
! Also Read boundary variables if required, i.e., if NSCBC==1 
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)

    CALL rflu_bxv_readvarswrapper(pregion)

    IF ( rflu_decidereadwritebcdatafile(pregion) .EQV. .true. ) THEN 
      CALL rflu_readbcdatafile(pregion)
    END IF ! RFLU_DecideReadWriteBcDataFile
  END DO ! iReg
  
! ******************************************************************************
! Read grid speeds. NOTE must be done after face list is constructed, because 
! need to know number of faces to be able to read grid speeds. 
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    
    IF ( rflu_decideneedgridspeeds(pregion) .EQV. .true. ) THEN 
      CALL rflu_readgridspeedswrapper(pregion)    
    END IF ! RFLU_DecideNeedGridSpeeds
  END DO ! iReg

! ******************************************************************************
! Initialize grid speed scaling factor. NOTE needs to be done for steady flows
! to work properly because grid speed is used together with scaling routines.
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    
    CALL rflu_initgridspeedscalefactor(pregion)
  END DO ! iReg

#ifdef STATS
! ******************************************************************************
! Statistics initialization
! ******************************************************************************

  CALL initstatistics(plevel%regions)
#endif

! ******************************************************************************
! Create buffers and tags for communication
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    pgrid   => pregion%grid   
    
    IF ( pgrid%nBorders > 0 ) THEN 
      CALL rflu_mpi_createbufferswrapper(pregion)
      CALL rflu_mpi_settagswrapper(pregion)
      
#ifdef PLAG
      IF ( pregion%global%plagUsed .EQV. .true. ) THEN 
        CALL rflu_mpi_createbufferipclsend(pregion)
      END IF ! pRegion%global%plagUsed
#endif      
    END IF ! pRegion%grid%nBorders
  END DO ! iReg  

! *****************************************************************************
! Initialize virtual-cell data via communication (done for GENX runs after 
! remeshing because remeshing tool does not initialize ghosts)
! *****************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_mpi_isendwrapper(pregion)
  END DO ! iReg 

  CALL rflu_mpi_copywrapper(plevel%regions)

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_mpi_recvwrapper(pregion)
  END DO ! iReg 

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_mpi_clearrequestwrapper(pregion)
  END DO ! iReg 

! ******************************************************************************
! Initialize dependent variables 
! ******************************************************************************
  
  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    CALL rflu_setvarswrapper(pregion,1,pregion%grid%nCellsTot)   

! TEMPORARY : move it to proper place ....
    IF ( rflu_nscbc_decidehavenscbc(pregion) .EQV. .true. ) THEN
      CALL rflu_bxv_setdependentvars(pregion)
    END IF !
! END TEMPORARY
  END DO ! iReg

#ifdef GENX
! ******************************************************************************
! Initialize Rocman
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)        
    CALL rflu_genx_initrocman(pregion,genxhandle)     
  END DO ! iReg

! ******************************************************************************
! Check that have coupled boundaries defined, must be done after field flags
! are created
! ******************************************************************************

! TEMPORARY - Breaks intermittently, without this you need to make sure that
!             your input files are correct; there is no checking...
!  CALL RFLU_CheckCouplingInput(pLevel%regions)
! END TEMPORARY

! ******************************************************************************
! Put initial data into GENX buffers. NOTE no longer get data to fill incoming
! buffers to make sure restarts are always the same regardless of the time. 
! Incoming buffers are filled at beginning of time-stepping routine
! ******************************************************************************

  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    IF ( global%currentTime /= 0.0_rfreal ) THEN
      CALL rflu_genx_initbflag(pregion)
      CALL rflu_getboundaryvalues(plevel%regions(ireg))
    END IF
    
    CALL rflu_putboundaryvalues(plevel%regions(ireg))            
  END DO ! iReg
#endif

! ******************************************************************************
! Set options for grid motion, must be done after boundary normals are built 
! and data fields for communication are created
! ******************************************************************************

! TEMPORARY - Disabled until merged with changes for periodic and symmetry
!             boundaries
!  IF ( moveGrid .EQV. .TRUE. ) THEN 
!    DO iReg = 1,global%nRegionsLocal
!      pRegion => pLevel%regions(iReg)
!      CALL RFLU_SetMoveGridOptions(pRegion) 
!    END DO ! iReg
!  END IF ! moveGrid
! END TEMPORARY

! ******************************************************************************
! Find probe cells and print information on probe locations
! ******************************************************************************

  IF ( global%nProbes > 0 ) THEN 
    DO ireg = 1,global%nRegionsLocal
      pregion => plevel%regions(ireg)
      CALL rflu_findprobecells(pregion)
    END DO ! iReg
    
    CALL rflu_printprobeinfo(global)
  END IF ! global 

! ******************************************************************************
! Open files for convergence data, probe data, and OLES output
! ******************************************************************************

  CALL rflu_openconverfile(global)
  
#ifndef GENX  
  IF ( movegrid .EQV. .true. ) THEN 
    CALL rflu_opentotalmassfile(global)
  END IF ! moveGrid
#endif

  IF ( global%nProbes > 0 ) THEN 
    DO ireg = 1,global%nRegionsLocal
      pregion => plevel%regions(ireg)
      CALL rflu_openprobefiles(pregion)
    END DO ! iReg
  END IF ! global      

! BEGIN TEMPORARY - only works for single regions at the moment
  DO ireg = 1,global%nRegionsLocal
    pregion => plevel%regions(ireg)
    
    IF ( pregion%mixtInput%spaceDiscr == discr_opt_les ) THEN 
      CALL rflu_openstatsfileoles(global)
    END IF ! pRegion%mixtInput
  END DO ! iReg  
! END TEMPORARY

#ifndef GENX
! ******************************************************************************
! Compute integral values and write to file
! ******************************************************************************
      
  global%massIn  = 0.0_rfreal
  global%massOut = 0.0_rfreal    
      
  IF ( movegrid .EQV. .true. ) THEN
    CALL rflu_computeintegralvalues(plevel%regions) 
    CALL writetotalmass(plevel%regions)
  END IF ! moveGrid
#endif  

#ifdef PETSC
! ******************************************************************************
! Initialize PETSc-related arrays and quantities
! ******************************************************************************
      
!  pRegion => pLevel%regions(1)
!  CALL RFLU_PETSC_Init(global)
!  CALL RFLU_PETSC_CreatePoisson(pRegion)
!  CALL RFLU_PETSC_BuildPoisson(pRegion)
!  CALL RFLU_PETSC_SetSolverPoisson(pRegion)
!  CALL RFLU_PETSC_SolvePressurePoisson(pRegion)
!  CALL RFLU_PETSC_Finalize(global)

  IF ( global%solverType == solv_implicit_nk ) THEN
    pregion => plevel%regions(1)
    CALL rflu_petsc_init(global)
    CALL rflu_petsc_createvectors(pregion)
    CALL rflu_petsc_createjacobian(pregion)
  END IF ! global%solverType
#endif

! ******************************************************************************
! End
! ******************************************************************************

  IF ( global%myProcid == masterproc .AND. & 
       global%verbLevel >= verbose_high ) THEN
    WRITE(stdout,'(A)') solver_name    
    WRITE(stdout,'(A,1X,A)') solver_name,'Initialization done.'
    WRITE(stdout,'(A)') solver_name 
  END IF ! global%myProcid

  CALL deregisterfunction(global)

END SUBROUTINE rflu_initflowsolver

! ******************************************************************************
!
! RCS Revision history:
!
! $Log: RFLU_InitFlowSolver.F90,v $
! Revision 1.123  2008/12/06 08:44:30  mtcampbe
! Updated license.
!
! Revision 1.122  2008/11/19 22:17:42  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.121  2007/04/20 16:07:49  mtcampbe
! Updating for burnout support function RFLU_GENX_InitBFLAG
!
! Revision 1.120  2007/04/14 14:33:35  mtcampbe
! Updated for TZ
!
! Revision 1.119  2007/02/27 13:12:29  haselbac
! Adapted to changes in RFLU_ModDimensionality
!
! Revision 1.118  2006/12/21 12:22:12  haselbac
! Added call to check patch-bc consistency
!
! Revision 1.117  2006/10/20 21:32:23  mparmar
! Added calls to create and compute global thrustFlags
!
! Revision 1.116  2006/08/19 15:46:27  mparmar
! Changed because of NSCBC implementation
!
! Revision 1.115  2006/08/18 14:04:50  haselbac
! Added calls to build AVFace2Patch list, read transforms, cosmetics
!
! Revision 1.114  2006/06/23 21:37:47  mtcampbe
! Added a GetBoundary call for genx restarts - makes surface data correct.
!
! Revision 1.113  2006/06/16 19:39:30  mtcampbe
! Fixed MPI_Init sequencing for Rocstar/Native initialization
!
! Revision 1.112  2006/06/06 21:36:04  mtcampbe
! Remeshing/Rocstar mods DummyCell population, time 0 inits
!
! Revision 1.111  2006/04/07 16:04:03  haselbac
! Adapted to changes in bf2c wts computation
!
! Revision 1.110  2006/04/07 15:19:22  haselbac
! Removed tabs
!
! Revision 1.109  2006/04/07 14:53:27  haselbac
! Adapted to changes in bface stencil routines
!
! Revision 1.108  2006/03/25 22:03:26  haselbac
! Fix comment
!
! Revision 1.107  2006/03/25 22:02:51  haselbac
! Changes bcos of sype patches: Comment out Rxx2Sxx maps and face 
! reorientation, compute patch normals
!
! Revision 1.106  2006/03/09 14:10:03  haselbac
! Now call wrapper routines for stencils
!
! Revision 1.105  2006/02/06 23:55:54  haselbac
! Added comm argument to RFLU_InitGlobal
!
! Revision 1.104  2006/01/10 05:04:58  wasistho
! moved InitStatistics to before InitRocman
!
! Revision 1.103  2006/01/06 22:15:36  haselbac
! Adapted to name changes
!
! Revision 1.102  2006/01/03 06:32:03  wasistho
! moved Genx new-attr and registr. routines to wrappers
!
! Revision 1.101  2005/12/24 21:34:49  haselbac
! Added computation of ICT tolerance
!
! Revision 1.100  2005/12/24 02:25:31  wasistho
! moved statistics mapping befor Genx registration
!
! Revision 1.99  2005/12/24 02:15:22  wasistho
! activated statistics mapping
!
! Revision 1.98  2005/12/01 17:14:36  fnajjar
! Moved call to RFLU_RandomInit after reading user input
!
! Revision 1.97  2005/11/10 16:51:29  fnajjar
! Added plagUsed IF statement around PLAG routines
!
! Revision 1.96  2005/11/04 14:07:24  haselbac
! Renamed dim check routine, added dim geom check routine
!
! Revision 1.95  2005/10/28 19:18:15  haselbac
! Added check for nProcs not being equal to nProcAlloc
!
! Revision 1.94  2005/10/27 19:20:19  haselbac
! Adapted to changes in stencil routine names
!
! Revision 1.93  2005/10/25 19:39:23  haselbac
! Added IF on forceFlag
!
! Revision 1.92  2005/10/05 14:19:23  haselbac
! Adapted to changes in stencil mods, added call to create and comp bface wts
!
! Revision 1.91  2005/09/14 15:59:33  haselbac
! Minor clean-up
!
! Revision 1.90  2005/09/13 20:39:39  mtcampbe
! Moved profiling call into this file
!
! Revision 1.89  2005/08/03 18:42:39  hdewey2
! Enclosed PETSc init calls inside IF
!
! Revision 1.88  2005/08/02 18:57:58  hdewey2
! Temporarily commented out USE RFLU_ModPETScPoisson
!
! Revision 1.87  2005/08/02 18:29:17  hdewey2
! Added init of PETSc data and quantities
!
! Revision 1.86  2005/07/01 15:15:17  haselbac
! Added setting of Roccom verbosity level
!
! Revision 1.85  2005/06/09 20:30:14  haselbac
! Disabled checking of move grid options
!
! Revision 1.84  2005/05/18 22:13:27  fnajjar
! ACH: Added creation of iPclSend buffers, now use nFacesAV
!
! Revision 1.83  2005/05/12 18:02:53  haselbac
! Removed call to COM_set_verbose
!
! Revision 1.82  2005/04/29 23:02:54  haselbac
! Added building of avf2b list
!
! Revision 1.81  2005/04/29 13:00:56  haselbac
! Fixed bug in name of routine for opening probe files
!
! Revision 1.80  2005/04/29 12:49:31  haselbac
! Added USE RFLU_ModProbes, removed interfaces for probe routines
!
! Revision 1.79  2005/04/15 16:31:18  haselbac
! Removed calls to XyzEdge2RegionDegrList routines
!
! Revision 1.78  2005/04/15 15:07:18  haselbac
! Converted to MPI, integrated MPI code with GENx
!
! Revision 1.77  2005/03/09 15:08:25  haselbac
! Added dimensionality check
!
! Revision 1.76  2005/01/18 15:18:18  haselbac
! Commented out COMM calls for now
!
! Revision 1.75  2005/01/14 21:35:29  haselbac
! Added calls to create and read comm lists
!
! Revision 1.74  2005/01/13 21:40:29  haselbac
! Bug fix in setting pRegion for PETSc testing
!
! Revision 1.73  2005/01/07 19:25:56  fnajjar
! Added call to PLAG_ReadSurfStatsWrapper
!
! Revision 1.72  2005/01/03 15:58:34  haselbac
! Adapted to changes in RFLU_ModStencils
!
! Revision 1.71  2004/12/28 20:28:13  wasistho
! moved statistics routines into module ModStatsRoutines
!
! Revision 1.70  2004/12/21 23:34:32  fnajjar
! Added definition of pMixtInput pointer in incompressible part
!
! Revision 1.69  2004/12/21 15:05:11  fnajjar
! Included calls for PLAG surface statistics
!
! Revision 1.68  2004/12/19 15:49:50  haselbac
! Added incompressible stuff
!
! Revision 1.67  2004/12/04 03:34:04  haselbac
! Adapted to changes in RFLU_ModCellMapping
!
! Revision 1.66  2004/11/29 17:17:20  wasistho
! use ModInterfacesStatistics
!
! Revision 1.65  2004/11/14 19:47:15  haselbac
! Now call RFLU_SetVarsWrapper instead of UpdateDependentVarsMP
!
! Revision 1.64  2004/11/03 17:05:08  haselbac
! Removed HACK_PERIODIC ifdef and call to RFLU_GENX_CreateAttrGridVol
!
! Revision 1.63  2004/11/02 02:32:51  haselbac
! Added call to RFLU_SetVarInfoWrapper
!
! Revision 1.62  2004/10/21 15:54:13  haselbac
! Added ifdef for static linking
!
! Revision 1.61  2004/10/20 15:01:13  haselbac
! Bug fix: Changes made to allow compilation within GENx without CHARM=1
!
! Revision 1.60  2004/10/19 19:29:19  haselbac
! Substantial changes because of new GENX logic
!
! Revision 1.59  2004/07/06 15:14:52  haselbac
! Adapted to changes in libflu and modflu, cosmetics
!
! Revision 1.58  2004/06/25 20:08:25  haselbac
! Added call to RFLU_SetRestartTimeFlag
!
! Revision 1.57  2004/06/22 15:55:05  haselbac
! Bug fix for running serial jobs with Charm code
!
! Revision 1.56  2004/06/16 20:01:09  haselbac
! Added allocation of patch and force and moment coeffs, cosmetics
!
! Revision 1.55  2004/06/07 23:09:57  wasistho
! moved statistics mapping from initStatistics to before initGenxInterfaces
!
! Revision 1.54  2004/04/14 02:09:24  haselbac
! Added initialization of grid-speed factor
!
! Revision 1.53  2004/02/26 21:02:09  haselbac
! Added PLAG support, changed alloc logic, added updateDependentVarsMP
!
! Revision 1.52  2004/01/29 22:59:22  haselbac
! Added call to reading of bc data file, clean-up
!
! Revision 1.51  2004/01/22 16:04:33  haselbac
! Changed declaration to eliminate warning on ALC
!
! Revision 1.50  2003/12/07 04:59:22  jiao
! When GENX is defined, added a local variable "levels" to be
! used when calling RFLU_BuildDataStruct and RFLU_AssignRegionMapping
! to work around a complaint of PGI compiler.
!
! Revision 1.49  2003/12/04 03:30:04  haselbac
! Added calls for stencils and weights, cleaned up
!
! Revision 1.48  2003/11/25 21:04:41  haselbac
! Added call to RFLU_ReadBcInputFileWrapper, commented out communication
!
! Revision 1.47  2003/11/03 03:51:31  haselbac
! Added call to build boundary-face gradient access list
!
! Revision 1.46  2003/09/12 21:35:51  haselbac
! Fixed bug: Needed fem files for 1 proc cases
!
! Revision 1.45  2003/08/29 22:48:33  haselbac
! mpif.h should not be included directly here...
!
! Revision 1.44  2003/08/28 20:27:19  olawlor
! Minor tweaks for non-genx compilation--
!    - We need mpif.h
!    - Read input files from current directory, not Rocflu/inDir/.
!
! Revision 1.43  2003/08/27 15:38:00  haselbac
! Removed single and double quotes from last comments
!
! Revision 1.42  2003/08/26 22:48:56  olawlor
! Changes to startup sequence for latest Charm++/FEM framework:
!   - Call FEM_Init with an MPI communicator to set up FEM.
!     This replaces the old FEM_Attach call, and corresponding
!     -fem parameter in genx.C.
!
!   - Get partition number and number of partitions from MPI.
!     The FEM partition numbers are not needed any more.
!
!   - Read in the FEM input files yourself, using FEM_Mesh_read.
!     This allows the FEM input files to reside in the Rocflu
!     directory.
!
! Revision 1.41  2003/08/13 20:29:01  haselbac
! Fixed bug with writing probe data within GENx
!
! Revision 1.40  2003/07/22 15:39:50  haselbac
! Added Nullify routines
!
! Revision 1.39  2003/06/20 22:35:43  haselbac
! Added call to RFLU_ReadRestartInfo
!
! Revision 1.38  2003/06/04 20:05:53  jferry
! re-worked implementation of TBCs in unstructured code
!
! Revision 1.37  2003/05/16 21:51:29  mtcampbe
! ACH: Temporarily disabled checking of coupling input
!
! Revision 1.36  2003/05/13 23:49:46  haselbac
! Changed format for writing out number of procs
!
! Revision 1.35  2003/05/01 14:11:19  haselbac
! Added call to RFLU_CheckCouplingInput
!
! Revision 1.34  2003/04/24 15:43:13  haselbac
! Adapted interface to RFLU_PutBoundaryValues
!
! Revision 1.33  2003/04/12 21:38:08  haselbac
! Added setting of FEMRocfluGrid, verb and check level now read
!
! Revision 1.32  2003/04/07 14:26:50  haselbac
! Added cell-to-face list and probe info calls
!
! Revision 1.31  2003/03/31 16:17:21  haselbac
! Added writing of version string
!
! Revision 1.30  2003/03/25 19:16:58  haselbac
! Changed calling sequence for reorientation of AV faces
!
! Revision 1.29  2003/03/18 21:34:28  haselbac
! Modified call to RFLU_AllocateMemoryWrapper
!
! Revision 1.28  2003/03/15 18:38:12  haselbac
! Some adaptations for || gm, added serial mapping imposition
!
! Revision 1.27  2003/02/17 19:31:12  jferry
! Implemented portable random number generator ModRandom
!
! Revision 1.26  2003/01/31 13:53:57  haselbac
! Removed call to RFLU_GetBoundaryValues if not restarting
!
! Revision 1.25  2003/01/28 14:40:33  haselbac
! Extensive reorganization to get GENx restart to work with gm
!
! Revision 1.24  2002/11/27 20:25:14  haselbac
! Moved RFLU_SetMoveGridOptions to after having read bc file
!
! Revision 1.23  2002/11/26 15:27:55  haselbac
! Added RFLU_SetMoveGridOptions
!
! Revision 1.22  2002/11/26 15:18:39  haselbac
! Added ifdef to opening of total mass file
!
! Revision 1.21  2002/11/08 21:32:01  haselbac
! Added opening of total-mass file
!
! Revision 1.20  2002/10/27 19:13:03  haselbac
! New calls for grid motion, cosmetic redesign
!
! Revision 1.19  2002/10/19 16:15:19  haselbac
! Cosmetic changes to output
!
! Revision 1.18  2002/10/17 22:35:03  jiao
! ACH: Deactivate RFLU_PrintFlowInfo with GENX, gives small discrepancy for restart
!
! Revision 1.17  2002/10/17 14:14:00  haselbac
! Removed RFLU_GetBValues: Moved to RFLU_FlowSolver (discussion with Jim J.)
!
! Revision 1.16  2002/10/16 21:17:37  haselbac
! Added writing of header when running
!
! Revision 1.15  2002/10/12 14:59:13  haselbac
! Changed order of BC and GENX, added call to RFLU_GetBValues
!
! Revision 1.14  2002/10/05 19:22:53  haselbac
! GENX integration, added interface for RFLU_CreateFields
!
! Revision 1.13  2002/09/09 16:27:12  haselbac
! CVS appears to have got confused...
!
! Revision 1.12  2002/09/09 15:51:56  haselbac
! RFLU_HACK_PeriodicCellMapping.F90
!
! Revision 1.11  2002/08/16 21:33:48  jblazek
! Changed interface to MixtureProperties.
!
! Revision 1.10  2002/07/25 14:20:51  haselbac
! Added call to OLES routines, completed CHARM code segment
!
! Revision 1.9  2002/06/27 15:28:22  haselbac
! Added CHARM stuff, deleted MPI stuff
!
! Revision 1.8  2002/06/14 21:54:35  wasistho
! Added time avg statistics
!
! Revision 1.7  2002/06/14 20:21:26  haselbac
! Deleted ModLocal, changed local%nRegions to global%nRegionsLocal
!
! Revision 1.6  2002/06/10 21:31:14  haselbac
! Added call to RFLU_PrintHeader, changed flag to CHECK_UNIFLOW
!
! Revision 1.5  2002/06/05 18:59:53  haselbac
! Added RFLU_PrintGridInfo and changed version number
!
! Revision 1.4  2002/05/04 17:10:20  haselbac
! Added memory allocation, mixture properties, and checking
!
! Revision 1.3  2002/04/11 19:03:45  haselbac
! Added calls and cosmetic changes
!
! Revision 1.2  2002/03/26 19:23:39  haselbac
! Some cleaning and added reading of input files
!
! Revision 1.1  2002/03/14 19:12:48  haselbac
! Initial revision
!
! ******************************************************************************