rflupart.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: Driver routine for rflupart. 
!
! Description: None.
!
! Input: 
!   caseString  String with casename
!   verbLevel   Verbosity level
!
! Output: None.
!
! Notes:
!   1. There is no call to RFLU_AllocateMemoryWrapper and the corresponding 
!      call to RFLU_DeallocateMemoryWrapper because the grid quantities are 
!      determined in the grid conversion routines. 
!
! ******************************************************************************
!
! $Id: rflupart.F90,v 1.22 2008/12/06 08:45:03 mtcampbe Exp $
!
! Copyright: (c) 2005-2006 by the University of Illinois
!
! ******************************************************************************

SUBROUTINE rflupart(caseString,verbLevel)

  USE moderror
  USE moddatatypes
  USE modparameters  
  USE modglobal, ONLY: t_global
  USE moddatastruct, ONLY: t_level,t_region
  USE modmpi
  
  USE rflu_modallocatememory
  USE rflu_modboundlists
  USE rflu_modcellmapping
  USE rflu_modcoloring
  USE rflu_modcommlists
  USE rflu_moddeallocatememory
  USE rflu_moddimensions
  USE rflu_modfacelist
  USE rflu_modgeometry
  USE rflu_modgridspeedutils
  USE rflu_modgridutils
  USE rflu_modpartitionregion
  USE rflu_modpatchutils
  USE rflu_modreadbcinputfile
  USE rflu_modreadwritegrid
  USE rflu_modreadwritegridspeeds
  USE rflu_modregionmapping
  USE rflu_modrenumberings
  USE rflu_modstencilscells
  USE rflu_modstencilsutils
  USE rflu_modsymmetryperiodic
  USE rflu_modvertexlists

#ifdef GENX
  USE rflu_modrocstaradmin
  USE rflu_modrocstario
#endif

  USE modinterfaces, ONLY: rflu_builddatastruct, &   
                           rflu_creategrid, &
                           rflu_destroygrid, &
                           rflu_getuserinput, &
                           rflu_initglobal, & 
                           rflu_printgridinfo, & 
                           rflu_printheader, & 
                           rflu_printwarninfo, &
                           rflu_randominit, &
                           rflu_readconvgridwrapper, &
                           rflu_readrestartinfo, & 
                           rflu_setmoduletype, &  
                           rflu_setrestarttimeflag, &
                           rflu_user_enforcepatchcoords, & 
                           rflu_writerestartinfo, & 
                           rflu_writeversionstring, &
                           scalerotatevector
                           
  IMPLICIT NONE

#ifdef GENX
  include 'roccomf90.h'
#endif

! ******************************************************************************
! Definitions and declarations
! ******************************************************************************

! ==============================================================================
! Arguments
! ==============================================================================

  CHARACTER(*) :: casestring
  INTEGER, INTENT(IN) :: verblevel

! ==============================================================================
! Locals
! ==============================================================================

  CHARACTER(CHRLEN) :: casename
#ifdef GENX
  CHARACTER(CHRLEN) :: surfwinnameinput,volwinnameinput
#endif
  INTEGER :: errorflag,ilev,ireg
#ifdef GENX
  INTEGER :: handleobtain
#endif
  TYPE(t_region), POINTER :: pregion,pregionserial
  TYPE(t_global), POINTER :: global
  TYPE(t_level), POINTER :: levels(:)

! TEMPORARY
!  INTEGER :: order
! END TEMPORARY

! ******************************************************************************
! Start, initialize global data
! ******************************************************************************  
  ALLOCATE(global,stat=errorflag)
  IF ( errorflag /= err_none ) THEN 
    WRITE(stderr,'(A,1X,A)') solver_name,'ERROR - Pointer allocation failed.'
    stop
  END IF ! errorFlag 

  casename = casestring(1:len(casestring))

  CALL rflu_initglobal(casename,verblevel,mpi_comm_world,global)


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

  CALL rflu_setmoduletype(global,module_type_part)

#ifdef GENX
! ******************************************************************************
! Read GENX control file, store communicator and hardcode window name
! ****************************************************************************** 

  CALL rflu_genx_readctrlfile(global)
  CALL rflu_genx_storecommunicator(global,mpi_comm_world)
  CALL rflu_genx_hardcodewindowname(global)
#endif

  ! MS TODO The verbosity level is not propagated to RFLU properly
  !global%verbLevel = 3
  !WRITE (*,*) 'global%verbLevel = ', global%verbLevel
  ! MS end
! ******************************************************************************
! Print header and write version string
! ******************************************************************************

  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%myProcid

! ******************************************************************************
! Read mapping file, impose serial mapping, and build basic data structure
! ******************************************************************************

  CALL rflu_readregionmappingfile(global,mapfile_readmode_peek,global%myProcId)
  CALL rflu_setregionmappingserial(global)  
  CALL rflu_createregionmapping(global,maptype_reg)
  CALL rflu_imposeregionmappingserial(global)

  CALL rflu_builddatastruct(global,levels) 
  CALL rflu_applyregionmapping(global,levels)
  CALL rflu_destroyregionmapping(global,maptype_reg)  

#ifdef GENX
! ******************************************************************************
! Initialize Roccom and load Rocin and Rocout
! ******************************************************************************

  CALL com_init
! TEMPORARY
!  CALL COM_set_verbose(10)
! END TEMPORARY

  surfwinnameinput = 'RocfluInputSurf'
  volwinnameinput  = 'RocfluInputVol TEMP'

  global%winNameIn  = trim(global%winName)//'-IN'
  global%winNameOut = trim(global%winName)//'-OUT'

  CALL rocin_load_module(trim(global%winNameIn))
  CALL rocout_load_module(trim(global%winNameOut))
  
  handleobtain = com_get_function_handle(trim(global%winNameIn)// &
                                         '.obtain_attribute')
  CALL rflu_genx_storenameshandles(global,surfwinnameinput,volwinnameinput, & 
                                   handleobtain)

! ******************************************************************************
! Create windows and attributes 
! ******************************************************************************
  
  pregionserial => levels(1)%regions(0)

  CALL rflu_genx_createwindows(pregionserial) 
  CALL rflu_genx_createattrgridsurf(pregionserial)
  CALL rflu_genx_createattrgspeeds(pregionserial)     
#endif

! ******************************************************************************
! Initialize random number generator. NOTE needed in order to write sensible 
! data when writing Rocpart solution files. 
! ******************************************************************************

  CALL rflu_randominit(levels(1)%regions)

! ******************************************************************************
! Read input file and restart info. NOTE need restart info for GENX runs to 
! determine whether have a restart. 
! ******************************************************************************

  CALL rflu_getuserinput(levels(1)%regions,.true.) 
  CALL rflu_readrestartinfo(global)
  CALL rflu_setrestarttimeflag(global)

! ******************************************************************************
! Read and convert grid
! ******************************************************************************

  pregionserial => levels(1)%regions(0) ! NOTE must set otherwise get core dump 
    
  CALL rflu_readconvgridwrapper(pregionserial)

! ******************************************************************************
! Read boundary condition file
! ******************************************************************************
    
  IF ( pregionserial%grid%nPatches > 0 ) THEN        
    CALL rflu_readbcinputfilewrapper(pregionserial)    
  END IF ! pRegionSerial%grid%nPatches 
  
! ******************************************************************************
! Set maximum dimensions
! ******************************************************************************

  CALL rflu_setmaxdimensions(pregionserial)

! ******************************************************************************
! Impose patch coordinates, scale and rotate if desired
! ******************************************************************************

  IF ( global%enforceFlag .EQV. .true. ) THEN 
    CALL rflu_user_enforcepatchcoords(pregionserial)
  END IF ! global%enforceFlag
  
  IF ( global%transformFlag .EQV. .true. ) THEN 
    CALL scalerotatevector(global,pregionserial%grid%xyz)
  END IF ! global%transformFlag

  IF ( global%verbLevel > verbose_none ) THEN 
    CALL rflu_printgridinfo(pregionserial)
  END IF ! global%verbLevel

! ******************************************************************************
! Build data structures
! ******************************************************************************

  CALL rflu_createcellmapping(pregionserial)
  CALL rflu_buildloc2globcellmapping(pregionserial)
  CALL rflu_buildglob2loccellmapping(pregionserial)

  CALL rflu_createbvertexlists(pregionserial)
  CALL rflu_buildbvertexlists(pregionserial)

  CALL rflu_createfacelist(pregionserial)
  CALL rflu_buildfacelist(pregionserial)
  CALL rflu_renumberbfacelists(pregionserial)

! ******************************************************************************
! Distort grid (NOTE needs to be done after having boundary vertex lists)
! ******************************************************************************

  IF ( global%distortFlag .EQV. .true. ) THEN
    CALL rflu_distortgrid(pregionserial)
  END IF ! global%distortFlag

! ******************************************************************************
! Add virtual cells on symmetry and periodic boundaries
! ******************************************************************************

  IF ( rflu_sype_havesypepatches(pregionserial) .EQV. .true. ) THEN
    CALL rflu_createpatchneighbormaps(pregionserial)
    CALL rflu_buildpatchneighbormaps(pregionserial)
  
    CALL rflu_comm_countbordersserial(pregionserial)
    CALL rflu_comm_createborders(pregionserial)
    
    CALL rflu_creategeometry(pregionserial)
    CALL rflu_buildgeometry(pregionserial,.false.) 
   
    CALL rflu_computepatchnormalslocal(pregionserial)
    CALL rflu_checkpatchbcconsistency(pregionserial)
    CALL rflu_sype_buildtransforms(pregionserial)
    CALL rflu_sype_writetransforms(pregionserial)    

    CALL rflu_sype_createvertexmaps(pregionserial)
    CALL rflu_sype_buildvertexmaps(pregionserial)

    CALL rflu_createvert2celllist(pregionserial)
    CALL rflu_buildvert2celllist(pregionserial)

    CALL rflu_sype_addvirtualcells(pregionserial)
    CALL rflu_sype_buildp2vclistserial(pregionserial)    
    
    CALL rflu_destroyvert2celllist(pregionserial)
    CALL rflu_destroygeometry(pregionserial)
    
    CALL rflu_destroypatchneighbormaps(pregionserial)    
    
    CALL rflu_printgridinfo(pregionserial)
    
    CALL rflu_comm_writecommlists(pregionserial)
    
    CALL rflu_destroybvertexlists(pregionserial)
    CALL rflu_destroyfacelist(pregionserial)
    
    CALL rflu_createbvertexlists(pregionserial)
    CALL rflu_buildbvertexlists(pregionserial)

    CALL rflu_createfacelist(pregionserial)
    CALL rflu_buildfacelist(pregionserial)
    CALL rflu_renumberbfacelists(pregionserial)    
  END IF ! RFLU_SYPE_HaveSyPePatches  

! ******************************************************************************
! Allocate memory 
! ******************************************************************************
 
  IF ( rflu_decideneedgridspeeds(pregionserial) .EQV. .true. ) THEN 
    CALL rflu_allocatememorygspeeds(pregionserial)
  END IF ! RFLU_DecideNeedGridSpeeds

! ******************************************************************************
! Write dimensions. Also write cell mapping for serial grid, which is needed by 
! post-processor if the regions are merged. Write grid if running in serial or
! if running with particles. In the latter case, the serial grid is needed to 
! initialize the particle field.
! ******************************************************************************
  
  CALL rflu_writedimensions(pregionserial)  
  CALL rflu_writeloc2globcellmapping(pregionserial)

  IF ( (global%nRegionsLocal == 1) .OR. (global%plagUsed .EQV. .true.) ) THEN 
#ifdef GENX
    CALL rflu_genx_creategridsurf(pregionserial) 
    CALL rflu_genx_registergrid(pregionserial)  
    CALL rflu_genx_buildgridsurf(pregionserial) 
#endif
    CALL rflu_writegridwrapper(pregionserial)
#ifdef GENX
    CALL rflu_genx_destroygridsurf(pregionserial) 
#endif
  END IF ! global%nRegionsLocal

! ******************************************************************************
! Build coloring for implicit solver, write for serial runs
! ******************************************************************************

! TO DO
! Need to integrate this better with partitioning so that there is no need to
! build geometry twice. This probably means that need to have two calls to 
! build coloring, one for purely serial runs and another for parallel runs.
! END TO DO

  IF ( global%solverType == solv_implicit_nk ) THEN 
    IF ( pregionserial%mixtInput%spaceOrder > 1 ) THEN
      CALL rflu_createvert2celllist(pregionserial)
      CALL rflu_buildvert2celllist(pregionserial)

      CALL rflu_creategeometry(pregionserial)
      CALL rflu_buildgeometry(pregionserial)

      CALL rflu_setinfoc2cstencilwrapper(pregionserial, & 
                                         pregionserial%mixtInput%spaceOrder-1)
      CALL rflu_createc2cstencilwrapper(pregionserial)
      CALL rflu_buildc2cstencilwrapper(pregionserial,constrinput=constr_none)

      CALL rflu_destroygeometry(pregionserial)
      CALL rflu_destroyvert2celllist(pregionserial)
    END IF ! pRegionSerial%mixtInput%spaceOrder

    CALL rflu_createcell2facelist(pregionserial)  
    CALL rflu_buildcell2facelist(pregionserial)
  
    CALL rflu_col_createcoloring(pregionserial)
    CALL rflu_col_buildcoloring(pregionserial)

    IF ( pregionserial%mixtInput%spaceOrder > 1 ) THEN
      CALL rflu_destroyc2cstencilwrapper(pregionserial)
    ELSE
      CALL rflu_destroycell2facelist(pregionserial)      
    END IF ! pRegionSerial%mixtInput%spaceOrder

    IF ( global%nRegionsLocal == 1 ) THEN 
      CALL rflu_col_writecoloring(pregionserial)
    END IF ! global%nRegionsLocal
  END IF ! global%solverType

! ******************************************************************************
! Partition
! ******************************************************************************

  IF ( global%nRegionsLocal > 1 ) THEN 

! ==============================================================================
!   Partition region and build lists
! ==============================================================================

    CALL rflu_rnmb_createsc2rmap(pregionserial)    
    CALL rflu_part_partitionregion(pregionserial)  
    CALL rflu_rnmb_writesc2rmap(pregionserial)
    
    CALL rflu_part_createreg2cellmap(pregionserial)    
    CALL rflu_part_buildreg2cellmap(pregionserial)
    
    CALL rflu_part_buildborderfacelist(pregionserial)

    CALL rflu_createvert2celllist(pregionserial)
    CALL rflu_buildvert2celllist(pregionserial)

    CALL rflu_createbcellmlist(pregionserial)
    CALL rflu_buildbcellmlist(pregionserial) 

    IF ( pregionserial%mixtInput%spaceOrder > 1 ) THEN 
      CALL rflu_creategeometry(pregionserial)
      CALL rflu_buildgeometry(pregionserial) 
    END IF ! pRegionSerial
         
! ==============================================================================
!   Write out grid, solution, and renumbering lists for each region
! ==============================================================================

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

      CALL rflu_part_createcelllists(pregion,pregionserial)
      CALL rflu_rnmb_createpc2scmap(pregion)

      CALL rflu_createcellmapping(pregion)
      CALL rflu_buildloc2globcellmapping(pregion)
      CALL rflu_buildglob2loccellmapping(pregion)      
      
      CALL rflu_part_buildcelllists(pregion,pregionserial)
      CALL rflu_part_addvirtualcells(pregion,pregionserial)      
      CALL rflu_rnmb_buildsc2pcmap(pregion)

      CALL rflu_part_buildvertexlists(pregion,pregionserial)
      CALL rflu_rnmb_buildsv2pvmap(pregion)
      
      CALL rflu_rnmb_buildsbc2pcmap(pregion,pregionserial)      
      CALL rflu_part_createpatchlists(pregion,pregionserial)
      CALL rflu_rnmb_createpbf2sbfmap(pregion)
      CALL rflu_part_buildpatchlists(pregion,pregionserial)
      CALL rflu_rnmb_destroysbc2pcmap(pregion)
      CALL rflu_part_renumbervertexlists(pregion)
      
      CALL rflu_part_buildvertexdata(pregion,pregionserial) 
      
      CALL rflu_setmaxdimensions(pregion)
      CALL rflu_writedimensions(pregion)
      CALL rflu_writeloc2globcellmapping(pregion)

#ifdef GENX
      CALL rflu_createbvertexlists(pregion)
      CALL rflu_buildbvertexlists(pregion)

      CALL rflu_genx_creategridsurf(pregion) 
      CALL rflu_genx_registergridsurf(pregion)  
      CALL rflu_genx_registergridvol(pregion)
      CALL rflu_genx_buildgridsurf(pregion) 
#endif

      CALL rflu_writegridwrapper(pregion)

#ifdef GENX
      CALL rflu_genx_destroygridsurf(pregion) 
      CALL rflu_destroybvertexlists(pregion)
#endif
      
      CALL rflu_rnmb_writepxx2sxxmaps(pregion)
      
      IF ( global%solverType == solv_implicit_nk ) THEN 
        CALL rflu_col_createcoloring(pregion)
        CALL rflu_col_buildcoloring(pregion,pregionserial)
        CALL rflu_col_writecoloring(pregion)
        CALL rflu_col_destroycoloring(pregion)
      END IF ! global%solverType      
      
      CALL rflu_destroycellmapping(pregion)
      
      CALL rflu_part_destroyvertexdata(pregion)
                        
      CALL rflu_rnmb_destroypc2scmap(pregion)
      CALL rflu_rnmb_destroypbf2sbfmap(pregion)
      CALL rflu_rnmb_destroypv2svmap(pregion)      
      
      CALL rflu_rnmb_destroysc2pcmap(pregion)
      CALL rflu_rnmb_destroysv2pvmap(pregion)

      CALL rflu_part_destroypatchlists(pregion)      
      CALL rflu_part_destroycelllists(pregion)       
    END DO ! iReg

    CALL rflu_destroybcellmlist(pregionserial)        
    CALL rflu_destroyvert2celllist(pregionserial)   
    CALL rflu_part_buildborderfacelist(pregionserial)

    IF ( pregionserial%mixtInput%spaceOrder > 1 ) THEN 
      CALL rflu_destroygeometry(pregionserial)
    END IF ! pRegionSerial

! ==============================================================================
!   Build communication lists
! ==============================================================================

! ------------------------------------------------------------------------------
!   Read dimensions and renumbering lists. NOTE need to read bc file because of
!   sype cases, in which mapping from patches to virtual cells is constructed
!   below.
! ------------------------------------------------------------------------------

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

      CALL rflu_readdimensions(pregion) 
! TEMPORARY - THIS IS A BUG - MUST NOT BE CALLED BEFORE CREATEGRID BCOS 
!             PATCHES NOT YET CREATED - MAX DIMS READ FROM FILE ANYWAY
!      CALL RFLU_SetMaxDimensions(pRegion)
! END TEMPORARY              
              
      CALL rflu_creategrid(pregion)
      
      IF ( pregion%grid%nPatches > 0 ) THEN        
        CALL rflu_readbcinputfilewrapper(pregion)    
      END IF ! pRegion%grid%nPatches       

#ifdef GENX
      CALL rflu_genx_readwindow(pregion,genx_window_type_surf)
      CALL rflu_genx_readwindow(pregion,genx_window_type_vol)
      CALL rflu_genx_getdimensionsderived(pregion)
      CALL rflu_genx_creategridsurf(pregion) 
      CALL rflu_genx_registergridsurf(pregion) 
      CALL rflu_genx_registergridvol(pregion)    
#endif

      CALL rflu_readgridwrapper(pregion)
     
      CALL rflu_createcellmapping(pregion)
      CALL rflu_readloc2globcellmapping(pregion)
      CALL rflu_buildglob2loccellmapping(pregion)
     
      CALL rflu_rnmb_createpc2scmap(pregion)    
      CALL rflu_rnmb_createpv2svmap(pregion)
      CALL rflu_rnmb_createpbf2sbfmap(pregion)
      
      CALL rflu_rnmb_readpxx2sxxmaps(pregion)
            
      CALL rflu_rnmb_buildsc2pcmap(pregion)
      CALL rflu_rnmb_buildsv2pvmap(pregion)
      
! TO DO DELETE WINDOW
!
! END TO DO DELETE WINDOW
    END DO ! iReg

! ------------------------------------------------------------------------------
!   Count number of borders, create borders, and build communication lists
! ------------------------------------------------------------------------------

    DO ireg = 1,global%nRegionsLocal
      pregion => levels(1)%regions(ireg)
    
      CALL rflu_comm_createbordercntr(pregion)
      CALL rflu_comm_countborders(pregion,pregionserial)      
    END DO ! iReg

    CALL rflu_comm_checkcountborders(levels(1)%regions)

    DO ireg = 1,global%nRegionsLocal
      pregion => levels(1)%regions(ireg)
    
      CALL rflu_comm_createborders(pregion,create_borders_mode_dim_unknown)    
    END DO ! iReg

    CALL rflu_comm_buildcommlists(levels(1)%regions)      

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

! ------------------------------------------------------------------------------
!   Write communication lists, destroy renumbering and communication lists. 
!   NOTE need to write dimensions again because now also have information about
!   number of borders.
! ------------------------------------------------------------------------------

    DO ireg = 1,global%nRegionsLocal    
      pregion => levels(1)%regions(ireg)
     
      CALL rflu_writedimensionsborders(pregion)
      
      CALL rflu_comm_writecommlists(pregion)

      IF ( rflu_sype_havesypepatches(pregion) .EQV. .true. ) THEN 
        CALL rflu_sype_buildp2vclist(pregion,pregionserial)
        CALL rflu_writedimensions(pregion) 
        CALL rflu_writegridwrapper(pregion)  
        CALL rflu_sype_destroyp2vclist(pregion)                 
      END IF ! RFLU_SYPE_HaveSyPePatches

#ifdef GENX
      CALL rflu_createbvertexlists(pregion)
      CALL rflu_buildbvertexlists(pregion)

      CALL rflu_genx_createpconn(pregion)
      CALL rflu_genx_buildpconn(pregion)

      CALL rflu_genx_registergridsurf(pregion)
      CALL rflu_genx_registergridvol(pregion)

      CALL rflu_writegridwrapper(pregion)
#endif
     
      CALL rflu_destroycellmapping(pregion)
     
      CALL rflu_rnmb_destroypc2scmap(pregion)    
      CALL rflu_rnmb_destroypv2svmap(pregion)
      CALL rflu_rnmb_destroypbf2sbfmap(pregion)   

      CALL rflu_rnmb_destroysc2pcmap(pregion)
      CALL rflu_rnmb_destroysv2pvmap(pregion)      
   
#ifdef GENX
      CALL rflu_genx_destroypconn(pregion)
      CALL rflu_genx_destroygridsurf(pregion)
 
      CALL rflu_destroybvertexlists(pregion)
#endif
      CALL rflu_destroygrid(pregion)
    END DO ! iReg

! ==============================================================================
!   Destroy partition mapping
! ==============================================================================

    CALL rflu_rnmb_destroysc2rmap(pregionserial) 
  END IF ! global%nRegionsLocal                 

! ******************************************************************************
! Write restart info file
! ******************************************************************************

  CALL rflu_writerestartinfo(global) 

! ******************************************************************************
! Deallocate memory 
! ******************************************************************************
    
  IF ( rflu_sype_havesypepatches(pregionserial) .EQV. .true. ) THEN 
    CALL rflu_sype_destroyp2vclist(pregionserial)                 
  END IF ! RFLU_SYPE_HaveSyPePatches    
    
  IF ( rflu_decideneedgridspeeds(pregionserial) .EQV. .true. ) THEN   
    CALL rflu_deallocatememorygspeeds(pregionserial)
  END IF ! RFLU_DecideNeedGridSpeeds
  
  IF ( global%solverType == solv_implicit_nk ) THEN 
    CALL rflu_col_destroycoloring(pregionserial)
  END IF ! global%solverType  
  
  CALL rflu_destroyfacelist(pregionserial)  
  CALL rflu_destroybvertexlists(pregionserial)
  CALL rflu_destroycellmapping(pregionserial)

! ******************************************************************************
! Print info about warnings
! ******************************************************************************
  
  CALL rflu_printwarninfo(global)

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

  CALL deregisterfunction(global)

  WRITE (*,*) "rflumap finished sucessfully"
END SUBROUTINE rflupart

! ******************************************************************************
!
! RCS Revision history:
!
! $Log: rflupart.F90,v $
! Revision 1.22  2008/12/06 08:45:03  mtcampbe
! Updated license.
!
! Revision 1.21  2008/11/19 22:18:14  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.20  2006/08/18 14:05:26  haselbac
! Added call to write transforms
!
! Revision 1.19  2006/08/04 03:06:52  haselbac
! Added grid distortion capability
!
! Revision 1.18  2006/04/17 19:57:50  haselbac
! Bug fix: Must read bc file before building patch-to-virtual cell mapping
!
! Revision 1.17  2006/04/15 17:02:12  haselbac
! Bug fix: bc file must be read before face list construction
!
! Revision 1.16  2006/03/25 22:06:23  haselbac
! Added capability of dealing with sype patches
!
! Revision 1.15  2006/02/06 23:55:55  haselbac
! Added comm argument to RFLU_InitGlobal
!
! Revision 1.14  2006/01/06 22:17:38  haselbac
! Adapted to name changes
!
! Revision 1.13  2005/10/27 19:21:39  haselbac
! Adapted to changes in stencil routine names
!
! Revision 1.12  2005/10/05 14:25:51  haselbac
! Adapted to changes in stencil modules, added use of vertex list module
!
! Revision 1.11  2005/09/22 17:13:59  hdewey2
! Moved stencil building calls for the implicit solver so the Jacobian can always be colored based on the 1st order stencils.
!
! Revision 1.10  2005/09/19 18:41:24  haselbac
! Bug fix for asymmetric borders: Now check and correct
!
! Revision 1.9  2005/08/24 01:39:28  haselbac
! Added capability to build coloring for second-order runs
!
! Revision 1.8  2005/08/19 16:37:53  haselbac
! Bug fix: Added calls to build cell-to-face list before coloring
!
! Revision 1.7  2005/08/19 02:36:54  haselbac
! Added calls to coloring routines
!
! Revision 1.6  2005/07/01 16:19:47  haselbac
! Set max dims bfor writing to reduce mem in rfluinit and rflump
!
! Revision 1.5  2005/05/09 17:44:25  haselbac
! Bug fix: Call RFLU_ReadDimensions, not wrapper
!
! Revision 1.4  2005/05/05 18:38:39  haselbac
! Removed MPI calls after bug in Rocin/out fixed
!
! Revision 1.3  2005/05/04 03:36:46  haselbac
! Added init and finalize of MPI when running within GENX
!
! Revision 1.2  2005/05/03 03:11:31  haselbac
! Converted to C++ reading of command-line
!
! Revision 1.1  2005/04/15 15:09:15  haselbac
! Initial revision
!
! ******************************************************************************