RFLU_ModAllocateMemory.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: Suite of routines to allocate memory.
!
! Description: None.
!
! Notes: None.
!
! ******************************************************************************
!
! $Id: RFLU_ModAllocateMemory.F90,v 1.16 2008/12/06 08:44:20 mtcampbe Exp $
!
! Copyright: (c) 2004-2005 by the University of Illinois
!
! ******************************************************************************

MODULE rflu_modallocatememory

  USE moddatatypes
  USE moderror
  USE modglobal, ONLY: t_global
  USE modparameters
  USE modgrid, ONLY: t_grid
  USE modbndpatch, ONLY: t_patch
  USE moddatastruct, ONLY: t_region
  USE modmixture, ONLY: t_mixt_input
  USE modmpi

  USE modinterfaces, ONLY: rflu_decideneedbgradface

  IMPLICIT NONE

  PRIVATE
  PUBLIC :: rflu_allocatememorygspeeds, &
            rflu_allocatememorysol, &
            rflu_allocatememorysolcv, &
            rflu_allocatememorysoldv, &
            rflu_allocatememorysolgv, &
            rflu_allocatememorysoltv, &
            rflu_allocatememorytstep, & 
            rflu_allocatememorytstep_c, & 
            rflu_allocatememorytstep_i

! ******************************************************************************
! Declarations and definitions
! ******************************************************************************

  CHARACTER(CHRLEN) :: RCSIdentString = &
    '$RCSfile: RFLU_ModAllocateMemory.F90,v $ $Revision: 1.16 $'

! ******************************************************************************
! Routines
! ******************************************************************************

  CONTAINS





! ******************************************************************************
!
! Purpose: Allocate memory for grid speeds.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorygspeeds(pRegion)

  USE rflu_modgridspeedutils

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: errorflag,ifc,ipatch
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_mixt_input), POINTER :: pmixtinput
  TYPE(t_patch), POINTER :: ppatch
  TYPE(t_global), POINTER :: global

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemoryGSpeeds',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

! ==============================================================================
! Require grid speeds
! ==============================================================================

  IF ( rflu_decideneedgridspeeds(pregion) .EQV. .true. ) THEN

! ------------------------------------------------------------------------------
!   Interior faces
! ------------------------------------------------------------------------------

#ifndef GENX
    ALLOCATE(pgrid%gs(pgrid%nFaces),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pGrid%gs')
    END IF ! global%error

    DO ifc = 1,pgrid%nFaces ! Explicit loop to avoid Frost problem
      pgrid%gs(ifc) = 0.0_rfreal
    END DO ! ifc
#else
    ALLOCATE(pgrid%gs(pgrid%nFacesTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pGrid%gs')
    END IF ! global%error

    DO ifc = 1,pgrid%nFacesTot ! Explicit loop to avoid Frost problem
      pgrid%gs(ifc) = 0.0_rfreal
    END DO ! ifc
#endif

! ------------------------------------------------------------------------------
!   Patch faces
! ------------------------------------------------------------------------------

    IF ( pgrid%nPatches > 0 ) THEN
      DO ipatch = 1,pgrid%nPatches
        ppatch => pregion%patches(ipatch)

#ifndef GENX
        ALLOCATE(ppatch%gs(ppatch%nBFaces),stat=errorflag)
        global%error = errorflag
        IF ( global%error /= err_none ) THEN
          CALL errorstop(global,err_allocate,__line__,'pPatch%gs')
        END IF ! global%error

        DO ifc = 1,ppatch%nBFaces ! Explicit loop to avoid Frost problem
          ppatch%gs(ifc) = 0.0_rfreal
        END DO ! ifc
#else
        ALLOCATE(ppatch%gs(ppatch%nBFacesTot),stat=errorflag)
        global%error = errorflag
        IF ( global%error /= err_none ) THEN
          CALL errorstop(global,err_allocate,__line__,'pPatch%gs')
        END IF ! global%error

        DO ifc = 1,ppatch%nBFaces ! Explicit loop to avoid Frost problem
          ppatch%gs(ifc) = 0.0_rfreal
        END DO ! ifc

        DO ifc = ppatch%nBFaces+1,ppatch%nBFacesTot
          ppatch%gs(ifc) = REAL(crazy_value_int,kind=rfreal)
        END DO ! ifc
#endif
      END DO ! iPatch
    END IF ! pGrid%nPatches

! ==============================================================================
! Do not require grid speeds
! ==============================================================================

  ELSE

! ------------------------------------------------------------------------------
!   Interior faces
! ------------------------------------------------------------------------------

    ALLOCATE(pgrid%gs(0:1),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pGrid%gs')
    END IF ! global%error

    DO ifc = 0,1 ! Explicit loop to avoid Frost problem
      pgrid%gs(ifc) = 0.0_rfreal
    END DO ! ifc

! ------------------------------------------------------------------------------
!   Patch faces
! ------------------------------------------------------------------------------

    IF ( pgrid%nPatches > 0 ) THEN
      DO ipatch = 1,pgrid%nPatches
        ppatch => pregion%patches(ipatch)

        ALLOCATE(ppatch%gs(0:1),stat=errorflag)
        global%error = errorflag
        IF ( global%error /= err_none ) THEN
          CALL errorstop(global,err_allocate,__line__,'pPatch%gs')
        END IF ! global%error

        DO ifc = 0,1 ! Explicit loop to avoid Frost problem
          ppatch%gs(ifc) = 0.0_rfreal
        END DO ! ifc
      END DO ! iPatch
    END IF ! pGrid%nPatches
  END IF ! pMixtInput%moveGrid

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorygspeeds






! ******************************************************************************
!
! Purpose: Allocate memory for mixture solution.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorysol(pRegion)

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  TYPE(t_global), POINTER :: global

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemorySol',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Allocate memory
! ******************************************************************************

  CALL rflu_allocatememorysolcv(pregion)
  CALL rflu_allocatememorysoldv(pregion)
  CALL rflu_allocatememorysolgv(pregion)
  CALL rflu_allocatememorysoltv(pregion)

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorysol






! ******************************************************************************
!
! Purpose: Allocate memory for conserved variables of mixture.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorysolcv(pRegion)

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: errorflag
  TYPE(t_global), POINTER :: global
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_mixt_input), POINTER :: pmixtinput  

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemorySolCv',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

  ALLOCATE(pregion%mixt%cv(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
  global%error = errorflag
  IF (global%error /= err_none) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%cv')
  END IF ! global%error

  ALLOCATE(pregion%mixt%cvInfo(pmixtinput%nCv),stat=errorflag)
  global%error = errorflag
  IF (global%error /= err_none) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%cvInfo')
  END IF ! global%error

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorysolcv





! ******************************************************************************
!
! Purpose: Allocate memory for dependent variables of mixture.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorysoldv(pRegion)

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: errorflag
  TYPE(t_global), POINTER :: global
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_mixt_input), POINTER :: pmixtinput

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemorySolDv',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

  ALLOCATE(pregion%mixt%dv(pmixtinput%nDv,pgrid%nCellsTot),stat=errorflag)
  global%error = errorflag
  IF (global%error /= err_none) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%dv')
  END IF ! global%error

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorysoldv





! ******************************************************************************
!
! Purpose: Allocate memory for gas variables of mixture.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorysolgv(pRegion)

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: errorflag
  TYPE(t_global), POINTER :: global
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_mixt_input), POINTER :: pmixtinput

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemorySolGv',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

  IF ( pmixtinput%gasModel == gas_model_tcperf ) THEN
    ALLOCATE(pregion%mixt%gv(pmixtinput%nGv,0:1),stat=errorflag)
  ELSE
    ALLOCATE(pregion%mixt%gv(pmixtinput%nGv,pgrid%nCellsTot),stat=errorflag)
  END IF ! pRegion
  global%error = errorflag
  IF (global%error /= err_none) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%gv')
  END IF ! global%error

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorysolgv





! ******************************************************************************
!
! Purpose: Allocate memory for transport variables of mixture.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorysoltv(pRegion)

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: errorflag
  TYPE(t_global), POINTER :: global
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_mixt_input), POINTER :: pmixtinput

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemorySolTv',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

  IF ( pmixtinput%computeTv .EQV. .true. ) THEN
    ALLOCATE(pregion%mixt%tv(pmixtinput%nTv,pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF (global%error /= err_none) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%tv')
    END IF ! global%error
  ELSE
    nullify(pregion%mixt%tv)
  END IF ! pMixtInput%computeTv

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorysoltv





! ******************************************************************************
!
! Purpose: Allocate memory for mixture time-stepping.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorytstep(pRegion)

  USE rflu_modoles

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: arraylimlow,arraylimupp,errorflag,ic,icmp,ifc,iv,ipatch,nbfaces, &
             nbfacestot
  TYPE(t_grid), POINTER :: pgrid,pgridold,pgridold2
  TYPE(t_patch), POINTER :: ppatch
  TYPE(t_global), POINTER :: global
  TYPE(t_mixt_input), POINTER :: pmixtinput  

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemoryTStep',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pgridold   => pregion%gridOld
  pgridold2  => pregion%gridOld2
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

! ==============================================================================
! Compute number of boundary faces for later use
! ==============================================================================

  nbfaces    = 0
  nbfacestot = 0

  DO ipatch = 1,pgrid%nPatches
    ppatch => pregion%patches(ipatch)

    nbfaces    = nbfaces    + ppatch%nBTris    + ppatch%nBQuads
    nbfacestot = nbfacestot + ppatch%nBTrisTot + ppatch%nBQuadsTot
  END DO ! iPatch

! ==============================================================================
! Old solutions
! ==============================================================================

  ALLOCATE(pregion%mixt%cvOld(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
  global%error = errorflag
  IF (global%error /= err_none) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%cvOld')
  END IF ! global%error

  IF ( global%solverType == solv_implicit_nk ) THEN  
    ALLOCATE(pregion%mixt%cvOld1(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF (global%error /= err_none) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%cvOld1')
    END IF ! global%error

    ALLOCATE(pregion%mixt%cvOld2(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF (global%error /= err_none) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%cvOld2')
    END IF ! global%error
  END IF ! global%solverType

! ==============================================================================
! Time step
! ==============================================================================

  ALLOCATE(pregion%dt(pgrid%nCellsTot),stat=errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%dt')
  END IF ! global%error

! ==============================================================================
! Residuals
! ==============================================================================

  ALLOCATE(pregion%mixt%rhs(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%rhs')
  END IF ! global%error

  ALLOCATE(pregion%mixt%diss(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%diss')
  END IF ! global%error

  IF ( global%flowType == flow_unsteady ) THEN
    ALLOCATE(pregion%mixt%rhsSum(pmixtinput%nCv,pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%rhsSum')
    END IF ! global%error
  ELSE
    nullify(pregion%mixt%rhsSum)
  END IF ! global%flowType

! ==============================================================================
! Gradients
! ==============================================================================

! ------------------------------------------------------------------------------
! Cell gradients
! ------------------------------------------------------------------------------

  IF ( (pmixtinput%spaceDiscr == discr_upw_roe     ) .OR. &
       (pmixtinput%spaceDiscr == discr_upw_hllc    ) .OR. & 
       (pmixtinput%spaceDiscr == discr_upw_ausmplus) ) THEN
    IF ( pmixtinput%spaceOrder > 1 ) THEN
      ALLOCATE(pregion%mixt%gradCell(xcoord:zcoord, &
                                     grc_mixt_dens:grc_mixt_pres, &
                                     pgrid%nCellsTot),stat=errorflag)
      global%error = errorflag
      IF ( global%error /= err_none ) THEN
        CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%gradCell')
      END IF ! global%error
    ELSE
      nullify(pregion%mixt%gradCell)
    END IF ! pMixtInput%spaceOrder
  ELSE IF ( pmixtinput%spaceDiscr == discr_opt_les ) THEN
    ALLOCATE(pregion%mixt%gradCell(xcoord:zcoord, &
                                   grc_mixt_xvel:grc_mixt_zvel, &
                                   pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%gradCell')
    END IF ! global%error
  ELSE
    nullify(pregion%mixt%gradCell)
  END IF ! pMixtInput%spaceDiscr

! ------------------------------------------------------------------------------
! Face gradients
! ------------------------------------------------------------------------------

  IF ( pmixtinput%flowModel == flow_navst ) THEN
    ALLOCATE(pregion%mixt%gradFace(xcoord:zcoord, &
                                   grf_mixt_xvel:grf_mixt_temp, &
                                   pgrid%nFaces),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%gradFace')
    END IF ! global%error
  ELSE
    nullify(pregion%mixt%gradFace)
  END IF ! pMixtInput%flowModel

  IF ( pgrid%nPatches > 0 ) THEN
    DO ipatch = 1,pregion%grid%nPatches
      ppatch => pregion%patches(ipatch)

      IF ( rflu_decideneedbgradface(pregion,ppatch) .EQV. .true. ) THEN
        ALLOCATE(ppatch%mixt%gradFace(xcoord:zcoord, &
                                      grbf_mixt_dens:grbf_mixt_pres, &
                                      ppatch%nBFaces),stat=errorflag)
        global%error = errorflag
        IF ( global%error /= err_none ) THEN
          CALL errorstop(global,err_allocate,__line__,'pPatch%mixt%gradFace')
        END IF ! global%error
      ELSE
        nullify(ppatch%mixt%gradFace)
      END IF ! RFLU_DecideNeedBGradFace
    END DO ! iPatch
  END IF ! pGrid%nPatches

! ==============================================================================
! Grid motion. NOTE grid speeds are allocated separately because they are
! written into grid file, and hence they need to be allocated in pre- and
! postprocessors also.
! ==============================================================================

  IF ( pmixtinput%moveGrid .EQV. .true. ) THEN

! ------------------------------------------------------------------------------
!   Residual
! ------------------------------------------------------------------------------

    ALLOCATE(pgrid%rhs(xcoord:zcoord,pgrid%nVertTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pGrid%rhs')
    END IF ! global%error

    DO icmp = xcoord,zcoord ! Explicit loop to avoid Frost problem
      DO iv = 1,pgrid%nVertTot
        pgrid%rhs(icmp,iv) = 0.0_rfreal
      END DO ! iv
    END DO ! icmp

! ------------------------------------------------------------------------------
!   Displacement
! ------------------------------------------------------------------------------

    IF ( pmixtinput%moveGridType /= movegrid_type_xyz ) THEN
      ALLOCATE(pgrid%disp(xcoord:zcoord,pgrid%nVertTot),stat=errorflag)
      global%error = errorflag
      IF ( global%error /= err_none ) THEN
        CALL errorstop(global,err_allocate,__line__,'pGrid%disp')
      END IF ! global%error

      DO icmp = xcoord,zcoord ! Explicit loop to avoid Frost problem
        DO iv = 1,pgrid%nVertTot
          pgrid%disp(icmp,iv) = 0.0_rfreal
        END DO ! iv
      END DO ! icmp
    END IF ! pMixtInput%moveGridType

! ------------------------------------------------------------------------------
!   Old coordinates
! ------------------------------------------------------------------------------

    ALLOCATE(pgridold%xyz(xcoord:zcoord,pgrid%nVertTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%gridOld%xyz')
    END IF ! global%error

    DO icmp = xcoord,zcoord ! Explicit loop to avoid Frost problem
      DO iv = 1,pgrid%nVertTot
        pgridold%xyz(icmp,iv) = 0.0_rfreal
      END DO ! iv
    END DO ! icmp

    IF ( global%solverType == solv_implicit_nk ) THEN 
      ALLOCATE(pgridold2%xyz(xcoord:zcoord,pgrid%nVertTot),stat=errorflag)
      global%error = errorflag
      IF ( global%error /= err_none ) THEN
        CALL errorstop(global,err_allocate,__line__,'pRegion%gridOld2%xyz')
      END IF ! global%error
  
      DO icmp = xcoord,zcoord ! Explicit loop to avoid Frost problem
        DO iv = 1,pgrid%nVertTot
          pgridold2%xyz(icmp,iv) = 0.0_rfreal
        END DO ! iv
      END DO ! icmp
    END IF ! global%solverType

! ------------------------------------------------------------------------------
!   Old volume
! ------------------------------------------------------------------------------

    ALLOCATE(pgridold%vol(pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%gridOld%vol')
    END IF ! global%error

    DO ic = 1,pgrid%nCellsTot ! Explicit loop to avoid Frost problem
      pgridold%vol(ic) = 0.0_rfreal
    END DO ! ic

    IF ( global%solverType == solv_implicit_nk ) THEN 
      ALLOCATE(pgridold2%vol(pgrid%nCellsTot),stat=errorflag)
      global%error = errorflag
      IF ( global%error /= err_none ) THEN
        CALL errorstop(global,err_allocate,__line__,'pRegion%gridOld2%vol')
      END IF ! global%error
  
      DO ic = 1,pgrid%nCellsTot ! Explicit loop to avoid Frost problem
        pgridold2%vol(ic) = 0.0_rfreal
      END DO ! ic
    END IF ! global%solverType

#ifndef GENX
! ------------------------------------------------------------------------------
!   Patch displacements. NOTE allocate here only if not running inside GENX,
!   because when running inside GENX allocate displacements also for virtual
!   vertices.
! ------------------------------------------------------------------------------

    IF ( pgrid%nPatches > 0 ) THEN
      DO ipatch = 1,pgrid%nPatches
        ppatch => pregion%patches(ipatch)

        ALLOCATE(ppatch%dXyz(xcoord:zcoord,ppatch%nBVert),stat=errorflag)
        global%error = errorflag
        IF ( global%error /= err_none ) THEN
          CALL errorstop(global,err_allocate,__line__,'pPatch%dXyz')
        END IF ! global%error

        DO icmp = xcoord,zcoord ! Explicit loop to avoid Frost problem
          DO iv = 1,ppatch%nBVert
            ppatch%dXyz(icmp,iv) = 0.0_rfreal
          END DO ! iv
        END DO ! icmp
      END DO ! iPatch
    END IF ! pGrid%nPatches
#endif
  END IF ! pMixtInput%moveGrid

#ifdef STATS
! ==============================================================================
! Time averaged statistics
! ==============================================================================

  IF ( (global%flowType == flow_unsteady) .AND. &
       (global%doStat == active) ) THEN
    ALLOCATE(pregion%mixt%tav(global%mixtNStat,pgrid%nCellsTot),stat=errorflag)
    global%error = errorflag
    IF ( global%error /= err_none ) THEN
      CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%tav')
    END IF ! global%error
  ELSE
    nullify(pregion%mixt%tav)
  END IF ! global%flowType
#endif

! ==============================================================================
! Optimal LES
! ==============================================================================

  IF ( pmixtinput%spaceDiscr == discr_opt_les ) THEN
    CALL rflu_createstencilsweightsoles(pregion)
    CALL rflu_createintegralsoles(pregion)
  END IF ! pMixtInput%spaceDiscr

! ==============================================================================
! Substantial derivative. NOTE only needed for Equilibrium Eulerian method,
! but allocate anyway, because would need IF statement inside loops otherwise.
! ==============================================================================

  SELECT CASE ( pmixtinput%indSd )
    CASE ( 0 )
      arraylimlow = 0
      arraylimupp = 1
    CASE ( 1 )
      arraylimlow = 1
      arraylimupp = pgrid%nCellsTot
    CASE default
      CALL errorstop(global,err_reached_default,__line__)
  END SELECT ! pMixtInput%indSd

  ALLOCATE(pregion%mixt%sd(sd_xmom:sd_zmom,arraylimlow:arraylimupp), &
                           stat=errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%sd')
  END IF ! global%error

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorytstep






! ******************************************************************************
!
! Purpose: Allocate memory for mixture time-stepping for compressible fluid.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorytstep_c(pRegion)

  USE rflu_modoles

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: arraylimlow,arraylimupp,errorflag,ipatch
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_patch), POINTER :: ppatch
  TYPE(t_global), POINTER :: global
  TYPE(t_mixt_input), POINTER :: pmixtinput  

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemoryTStep_C',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid      => pregion%grid
  pmixtinput => pregion%mixtInput

! ******************************************************************************
! Allocate memory
! ******************************************************************************

! ==============================================================================
! Mass fluxes. NOTE only needed when solving additional scalar transport
! equations, but allocate anyway, because would need IF statement inside flux
! loops otherwise.
! ==============================================================================

  IF ( pmixtinput%indMfMixt == 1 ) THEN
    arraylimlow = 1
    arraylimupp = pgrid%nFaces
  ELSE
    arraylimlow = 0
    arraylimupp = 1
  END IF ! pMixtInput%indMfMixt

  ALLOCATE(pregion%mixt%mfMixt(arraylimlow:arraylimupp),stat=errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%mfMixt')
  END IF ! global%error

  IF ( pregion%grid%nPatches > 0 ) THEN
    DO ipatch = 1,pregion%grid%nPatches
      ppatch => pregion%patches(ipatch)

      IF ( pmixtinput%indMfMixt == 1 ) THEN
        arraylimlow = 1
        arraylimupp = ppatch%nBFaces
      ELSE
        arraylimlow = 0
        arraylimupp = 1
      END IF ! pMixtInput%indMfMixt

      ALLOCATE(ppatch%mfMixt(arraylimlow:arraylimupp),stat=errorflag)
      global%error = errorflag
      IF ( global%error /= err_none ) THEN
        CALL errorstop(global,err_allocate,__line__,'pPatch%mfMixt')
      END IF ! global%error
    END DO ! iPatch
  END IF ! pRegion%grid%nPatches

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorytstep_c





! ******************************************************************************
!
! Purpose: Allocate memory for mixture time-stepping for incompressible fluid.
!
! Description: None.
!
! Input:
!   pRegion        Region pointer
!
! Output: None.
!
! Notes: None.
!
! ******************************************************************************

SUBROUTINE rflu_allocatememorytstep_i(pRegion)

  IMPLICIT NONE

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

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

  TYPE(t_region), POINTER :: pregion

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

  INTEGER :: errorflag,ipatch
  TYPE(t_grid), POINTER :: pgrid
  TYPE(t_patch), POINTER :: ppatch
  TYPE(t_global), POINTER :: global 

! ******************************************************************************
! Start
! ******************************************************************************

  global => pregion%global

  CALL registerfunction(global,'RFLU_AllocateMemoryTStep_I',&
  'RFLU_ModAllocateMemory.F90')

! ******************************************************************************
! Set pointers
! ******************************************************************************

  pgrid => pregion%grid

! ******************************************************************************
! Allocate memory
! ******************************************************************************

! ==============================================================================
! Face velocities
! ==============================================================================

  ALLOCATE(pregion%mixt%vfMixt(pgrid%nFaces),stat=errorflag)
  global%error = errorflag
  IF ( global%error /= err_none ) THEN
    CALL errorstop(global,err_allocate,__line__,'pRegion%mixt%vfMixt')
  END IF ! global%error

  IF ( pregion%grid%nPatches > 0 ) THEN
    DO ipatch = 1,pregion%grid%nPatches
      ppatch => pregion%patches(ipatch)

      ALLOCATE(ppatch%vfMixt(ppatch%nBFaces),stat=errorflag)
      global%error = errorflag
      IF ( global%error /= err_none ) THEN
        CALL errorstop(global,err_allocate,__line__,'pPatch%vfMixt')
      END IF ! global%error
    END DO ! iPatch
  END IF ! pRegion%grid%nPatches

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

  CALL deregisterfunction(global)

END SUBROUTINE rflu_allocatememorytstep_i





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

END MODULE rflu_modallocatememory


! ******************************************************************************
!
! RCS Revision history:
!
! $Log: RFLU_ModAllocateMemory.F90,v $
! Revision 1.16  2008/12/06 08:44:20  mtcampbe
! Updated license.
!
! Revision 1.15  2008/11/19 22:17:31  mtcampbe
! Added Illinois Open Source License/Copyright
!
! Revision 1.14  2006/11/01 15:50:00  haselbac
! Changed so implicit-solver arrays dealt with properly
!
! Revision 1.13  2006/10/20 21:17:34  mparmar
! Fixed a bug in allocation of pPatch%mixt%gradFace
!
! Revision 1.12  2006/08/19 15:38:59  mparmar
! Moved region%mixt%bGradFace to patch%mixt%gradFace
!
! Revision 1.11  2006/02/08 21:03:16  hdewey2
! Added old2 quantities
!
! Revision 1.10  2006/01/07 10:16:33  wasistho
! STATS tav allocation to nCellsTot
!
! Revision 1.9  2005/10/31 21:09:36  haselbac
! Changed specModel and SPEC_MODEL_NONE
!
! Revision 1.8  2005/09/22 17:09:21  hdewey2
! Added allocation of cvOld1 and cvOld2 for transient implicit solver.
!
! Revision 1.7  2005/07/14 21:42:17  haselbac
! Added AUSM flux function to memory allocation IF statement
!
! Revision 1.6  2005/03/31 17:00:19  haselbac
! Changed allocation of sd
!
! Revision 1.5  2004/12/19 15:46:56  haselbac
! Added memory allocation for incompressible solver
!
! Revision 1.4  2004/11/02 02:30:22  haselbac
! Removed use of CV_MIXT_NEQS and init of cvInfo
!
! Revision 1.3  2004/10/19 19:27:44  haselbac
! Modified allocation criteria for grid speeds
!
! Revision 1.2  2004/07/30 22:47:36  jferry
! Implemented Equilibrium Eulerian method for Rocflu
!
! Revision 1.1  2004/03/19 21:15:19  haselbac
! Initial revision
!
! ******************************************************************************