block.F90

Go to the documentation of this file.

module block
    !
    !       This module contains the definition of the derived data type
    !       for block, which is the basic building block for this code.
    !       Apart from the derived data type for block, this module also
    !       contains the actual array for storing the blocks and the
    !       number of blocks stored on this processor.
    !
    use constants, only: realtype, inttype, portype, maxcgnsnamelen, &
                         sortbydonor, sortbyreceiver
    implicit none
    save
 
    !
    !       The definition of the derived data type visc_subface_type,
    !       which stores the viscous stress tensor and heat flux vector.
    !       In this way it is avoided that these quantities must be
    !       recomputed for the viscous forces and postprocessing. This
    !       saves both time and a considerable amount of code.
    !
    type viscsubfacetype
 
        ! tau(:,:,6): The 6 components of the viscous stress tensor.
        !             The first 2 dimensions of these arrays are equal
        !             to the dimenions of the cell subface without any
        !             halo cell. Consequently the starting index is
        !             arbitrary, such that no offset computation is
        !             needed when the arrays are accessed.
        ! q(:,:,3):   Same story for the heat flux vector.
        ! uTau(:,:):  And for the friction velocity.
 
        real(kind=realtype), dimension(:, :, :), pointer :: tau, q
        real(kind=realtype), dimension(:, :), pointer :: utau
 
    end type viscsubfacetype
 
    type rptr
        real(kind=realtype), dimension(:, :, :), pointer :: var
    end type rptr
 
    type iptr
        integer(kind=intType), dimension(:, :, :), pointer :: var
    end type iptr
    !
    !       The definition of the derived data type BCDataType, which
    !       stores the prescribed data of boundary faces as well as unit
    !       normals. For all the arrays the first two dimensions equal the
    !       dimensions of the subface, possibly extended with halo cells.
    !       Consequently the starting index is arbitrary, such that no
    !       offset computation is needed when the array is accessed.
    !
    type bcdatatype
 
        ! inBeg, inEnd: Node range in the first direction of the subface
        ! jnBeg, jnEnd: Idem in the second direction.
        ! icBeg, icEnd: Cell range in the first direction of the subface
        ! jcBeg, jcEnd: Idem in the second direction.
 
        integer(kind=intType) :: inbeg, inend, jnbeg, jnend
        integer(kind=intType) :: icbeg, icend, jcbeg, jcend
 
        ! norm(:,:,3):  The unit normal; it points out of the domain.
        ! rface(:,:):   Velocity of the face in the direction of the
        !               outward pointing normal. only allocated for
        !               the boundary conditions that need this info.
 
        real(kind=realtype), dimension(:, :, :), pointer :: norm
        real(kind=realtype), dimension(:, :), pointer :: rface
        real(kind=realtype), dimension(:, :, :), pointer :: f, fv, fp
        real(kind=realtype), dimension(:, :, :), pointer :: t, tv, tp
        real(kind=realtype), dimension(:, :), pointer :: area
        real(kind=realtype), dimension(:, :), pointer :: cptarget
        integer(kind=realType), dimension(:, :), pointer :: surfindex
 
        ! Generic pointers for performing a globalized reduction.
        real(kind=realtype), dimension(:, :), pointer :: nodeval
        real(kind=realtype), dimension(:, :), pointer :: cellval
 
        ! symNorm is the normal for (symmertry) boundary conditions.
        ! symNormSet is set to false until symNorm is computed at the
        ! beginning of a simulation. symNorm then remains constant for
        ! the remainder of the simulation. This is ok, since if the
        ! normal of the symmetry plane is changing, your results are
        ! invalid anyway.  These values are only used on symmetry
        ! plane. They are undefined for other BC's.
        real(kind=realtype), dimension(3) :: symnorm
 
        logical :: symnormset
 
        ! subsonicInletTreatment: which boundary condition treatment
        !                         to use for subsonic inlets; either
        !                         totalConditions or massFlow.
 
        integer(kind=intType) :: subsonicinlettreatment
 
        ! uSlip(:,:,3):  the 3 components of the velocity vector on
        !                a viscous wall.
        ! TNS_Wall(:,:): Wall temperature for isothermal walls.
 
        real(kind=realtype), dimension(:, :, :), pointer :: uslip
        real(kind=realtype), dimension(:, :), pointer :: tns_wall
 
        ! The name of this boundary condition and it's index
        character(maxCGNSNameLen) :: family
        integer(kind=intType) :: famid
 
        ! Added by HDN
        ! normALE(0:nALEsteps,ie:ib,je:jb,3)
        !                 - Storage of norm for intermediate meshes.
        ! rFaceALE(0:nALEsteps,iBeg:iEnd,jBeg:jEnd)
        !                 - Storage of rface for intermediate meshes.
        ! uSlipALE(0:nALEsteps,iBeg:iEnd,jBeg:jEnd,3)
        !                 - Storage of uSlip for intermediate meshes.
        ! cellHeatFlux(iBeg:iEnd,jBeg:jEnd,3)
        !                 - Surface heat flux (cell based/node based).
        real(kind=realtype), dimension(:, :, :, :), pointer :: normale
        real(kind=realtype), dimension(:, :, :), pointer :: rfaceale
        real(kind=realtype), dimension(:, :, :, :), pointer :: uslipale
        real(kind=realtype), dimension(:, :), pointer :: nodeheatflux
        real(kind=realtype), dimension(:, :), pointer :: cellheatflux
 
        ! ptInlet(:,:):       Total pressure at subsonic inlets.
        ! ttInlet(:,:):       Total temperature at subsonic inlets.
        ! htInlet(:,:):       Total enthalpy at subsonic inlets.
        ! flowXDirInlet(:,:): X-direction of the flow for subsonic
        !                     inlets.
        ! flowYDirInlet(:,:): Idem in y-direction.
        ! flowZDirInlet(:,:): Idem in z-direction.
 
        real(kind=realtype), dimension(:, :), pointer :: ptinlet, ttinlet, htinlet
        real(kind=realtype), dimension(:, :), pointer :: flowxdirinlet, flowydirinlet, flowzdirinlet
 
        ! turbInlet(:,:,nt1:nt2): Turbulence variables at inlets,
        !                         either subsonic or supersonic.
 
        real(kind=realtype), dimension(:, :, :), pointer :: turbinlet
 
        ! rho(:,:):  density; used for multiple bc's.
        ! velX(:,:): x-velocity; used for multiple bc's.
        ! velY(:,:): y-velocity; used for multiple bc's.
        ! velZ(:,:): z-velocity; used for multiple bc's.
        ! ps(:,:):   static pressure; used for multiple bc's.
 
        real(kind=realtype), dimension(:, :), pointer :: rho
        real(kind=realtype), dimension(:, :), pointer :: velx, vely, velz
        real(kind=realtype), dimension(:, :), pointer :: ps
 
        ! Surface blanking for force integration
        integer(kind=intType), dimension(:, :), pointer :: iblank
 
        ! Surface deviation. This is an estimate of how much the surface
        ! deviates from the "real" underlying surface'
        real(kind=realtype), dimension(:, :), pointer :: delta
        real(kind=realtype), dimension(:, :), pointer :: deltanode
 
    end type bcdatatype
 
    type surfacenodeweightarray
        real(kind=realtype), dimension(:, :, :), pointer :: weight
    end type surfacenodeweightarray
 
    type fringetype
 
        ! Make everything in here static such that we can easily copy the
        ! datatype and use MPI to communicate them directly. This data
        ! type bears some resemblence to the haloList type used for the
        ! B2B preprocessing.
 
        ! The quality metric for the fringe
        real(kind=realtype) :: quality
 
        ! This is the information regarding where the cell came from.
        integer(kind=intType) :: myblock, myindex
 
        ! This is the information about the donor that was found
        integer(kind=intType) :: donorproc, donorblock, dindex
        real(kind=realtype) :: donorfrac(3)
 
    end type fringetype
 
    interface operator(<=)
        module procedure lessequalfringetype
    end interface operator(<=)
 
    interface operator(<)
        module procedure lessfringetype
    end interface operator(<)
 
    type interppttype
        integer(kind=intType) :: donorproc, donorblock, di, dj, dk, myblock
        real(kind=realtype) :: donorfrac(3)
    end type interppttype
 
    interface operator(<=)
        module procedure lessequalinterppttype
    end interface operator(<=)
 
    interface operator(<)
        module procedure lessinterppttype
    end interface operator(<)
 
    !       The definition of the derived data type block_type, which
    !       stores dimensions, coordinates, solution, etc.
    !
    type blocktype
        !
        !         Block dimensions and orientation.
        !
        !  nx, ny, nz - Block integer dimensions for no halo cell based
        !               quantities.
        !  il, jl, kl - Block integer dimensions for no halo node based
        !               quantities.
        !  ie, je, ke - Block integer dimensions for single halo
        !               cell-centered quantities.
        !  ib, jb, kb - Block integer dimensions for double halo
        !               cell-centered quantities.
        ! rightHanded - Whether or not the block is a right handed.
        !               If not right handed it is left handed of course.
 
        integer(kind=intType) :: nx, ny, nz
        integer(kind=intType) :: il, jl, kl
        integer(kind=intType) :: ie, je, ke
        integer(kind=intType) :: ib, jb, kb
 
        logical :: righthanded
        !
        !         Block boundary conditions.
        !
        !  nSubface             - Number of subfaces on this block.
        !  n1to1                - Number of 1 to 1 block boundaries.
        !  nBocos               - Number of physical boundary subfaces.
        !  nViscBocos           - Number of viscous boundary subfaces.
        !  BCType(:)            - Boundary condition type for each
        !                         subface. See the module BCTypes for
        !                         the possibilities.
        !  BCFaceID(:)          - Block face location of each subface.
        !                         possible values are: iMin, iMax, jMin,
        !                         jMax, kMin, kMax. see also module
        !                         BCTypes.
        !  cgnsSubface(:)       - The subface in the corresponding cgns
        !                         block. As cgns distinguishes between
        !                         boundary and internal boundaries, the
        !                         BCType of the subface is needed to
        !                         know which one to take.
        !  inBeg(:), inEnd(:)   - Lower and upper limits for the nodes
        !  jnBeg(:), jnEnd(:)     in each of the index directions on a
        !  knBeg(:), knEnd(:)     given subface. Note that one of these
        !                         indices will not change since we will
        !                         be moving on a face.
        !  dinBeg(:), dinEnd(:) - Lower and upper limits for the nodes
        !  djnBeg(:), djnEnd(:)   in the each of the index directions
        !  dknBeg(:), dknEnd(:)   of the donor subface for this
        !                         particular subface. Note that one of
        !                         these indices will not change since we
        !                         will be moving on a face.
        !  icBeg(:), icEnd(:)   - Lower and upper limits for the cells
        !  jcBeg(:), jcEnd(:)     in each of the index directions for
        !  kcBeg(:), kcEnd(:)     the subface. The cells indicated by
        !                         this range are halo cells (the
        !                         constant index) adjacent to the face.
        !                         a possible overlap outside the block
        !                         is stored.
        !  neighBlock(:)        - Local block number to which this
        !                         subface connects. This value is set to
        !                         zero if this subface is not connected
        !                         to another block.
        !  neighProc(:)         - Processor number where the neighbor
        !                         block is stored. This value is set to
        !                         -1 if this subface is not connected
        !                         to another block.
        !  l1(:), l2(:),        - Short hand for the transformation
        !  l3(:)                  matrix between this subface and the
        !                         neighbor block. These values are set
        !                         to zero if this subface is not
        !                         connected to another block.
        !  groupNum(:)          - Group number to which this subface
        !                         belongs. If this subface does not
        !                         belong to any group, the corresponding
        !                         entry in this array is zeroed out. If
        !                         the subface belongs to a sliding mesh
        !                         interface the absolute value of
        !                         groupNum contains the number of the
        !                         sliding mesh interface. One side of
        !                         the interface gets a positive number,
        !                         the other side a negative one.
        !
        !
        integer(kind=intType) :: nsubface, n1to1, nbocos, nviscbocos
 
        integer(kind=intType), dimension(:), pointer :: bctype
        integer(kind=intType), dimension(:), pointer :: bcfaceid
 
        integer(kind=intType), dimension(:), pointer :: cgnssubface
 
        integer(kind=intType), dimension(:), pointer :: inbeg, inend
        integer(kind=intType), dimension(:), pointer :: jnbeg, jnend
        integer(kind=intType), dimension(:), pointer :: knbeg, knend
 
        integer(kind=intType), dimension(:), pointer :: dinbeg, dinend
        integer(kind=intType), dimension(:), pointer :: djnbeg, djnend
        integer(kind=intType), dimension(:), pointer :: dknbeg, dknend
 
        integer(kind=intType), dimension(:), pointer :: icbeg, icend
        integer(kind=intType), dimension(:), pointer :: jcbeg, jcend
        integer(kind=intType), dimension(:), pointer :: kcbeg, kcend
 
        integer(kind=intType), dimension(:), pointer :: neighblock
        integer(kind=intType), dimension(:), pointer :: neighproc
        integer(kind=intType), dimension(:), pointer :: l1, l2, l3
        integer(kind=intType), dimension(:), pointer :: groupnum
 
        !
        !         Overset interpolation information
 
        integer(kind=intType), dimension(:, :, :), pointer :: iblank
        integer(kind=intType), dimension(:, :, :), pointer :: iblanklast
        integer(kind=intType), dimension(:, :, :), pointer :: status
        integer(kind=intType), dimension(:, :, :), pointer :: forcedrecv
        type(fringetype), dimension(:), pointer :: fringes => null()
        integer(kind=intType), dimension(:, :, :, :), pointer :: fringeptr => null()
        integer(kind=intType), dimension(:, :, :, :), pointer :: gind => null()
        integer(kind=intType), pointer :: ndonors
        integer(kind=intType) :: ndonorsonownedcells
 
        integer(kind=intType), dimension(:, :), pointer :: orphans
        integer(kind=intType) :: norphans
 
        !
        !         Boundary data for the boundary subfaces.
        !
        ! BCData(nBocos): The boundary data for each of the boundary
        !                 subfaces.
 
        type(bcdatatype), dimension(:), pointer :: bcdata
        !
        !         The stress tensor and heat flux vector at viscous wall faces
        !         as well as the face pointers to these viscous wall faces.
        !
        ! viscSubface(nViscBocos):    Storage for the viscous stress
        !                             tensor and heat flux vector for
        !                             the viscous subfaces.
        ! viscIMinPointer(2:jl,2:kl): Pointer to viscous subface for
        !                             the iMin block face. If the face
        !                             is not part of a viscous subface
        !                             this value is set to 0.
        ! viscIMaxPointer(2:jl,2:kl): Idem for iMax block face.
        ! viscJMinPointer(2:il,2:kl): Idem for jMin block face.
        ! viscJMaxPointer(2:il,2:kl): Idem for jmax block face.
        ! viscKMinPointer(2:il,2:jl): Idem for kMin block face.
        ! viscKMaxPointer(2:il,2:jl): Idem for kMax block face.
 
        type(viscsubfacetype), dimension(:), pointer :: viscsubface
 
        integer(kind=intType), dimension(:, :), pointer :: visciminpointer
        integer(kind=intType), dimension(:, :), pointer :: viscimaxpointer
        integer(kind=intType), dimension(:, :), pointer :: viscjminpointer
        integer(kind=intType), dimension(:, :), pointer :: viscjmaxpointer
        integer(kind=intType), dimension(:, :), pointer :: visckminpointer
        integer(kind=intType), dimension(:, :), pointer :: visckmaxpointer
        !
        !         Mesh related variables.
        !
        !  x(0:ie,0:je,0:ke,3)  - xyz locations of grid points in block.
        !  xOld(nOld,:,:,:,:)   - Coordinates on older time levels;
        !                         only needed for unsteady problems on
        !                         deforming grids. Only allocated on
        !                         the finest grid level. The blank
        !                         dimensions are equal to the dimensions
        !                         of x.
        !  sI(0:ie,1:je,1:ke,3) - Projected areas in the i-coordinate
        !                         direction. Normals point in the
        !                         direction of increasing i.
        !  sJ(1:ie,0:je,1:ke,3) - Projected areas in the j-coordinate
        !                         direction. Normals point in the
        !                         direction of increasing j.
        !  sK(1:ie,1:je,0:ke,3) - Projected areas in the k-coordinate
        !                         direction. Normals point in the
        !                         direction of increasing k.
        !  vol(0:ib,0:jb,0:kb)  - Cell volumes. The second level halo
        !                         is present for a multigrid option.
        !  volOld(nold,2:il,..) - Volumes on older time levels; only
        !                         needed for unsteady problems on
        !                         deforming grids. Only allocated on
        !                         the finest grid level.
        !  skew(0:ib,0:jb,0:kb)  - Skewness of Volume
        !  uv(2,2:il,2:jl,2:kl) - Parametric location on elemID for each cell.
        !                         Only used for fast wall distance calcs.
        !  porI(1:il,2:jl,2:kl) - Porosity in the i direction.
        !  porJ(2:il,1:jl,2:kl) - Porosity in the j direction.
        !  porK(2:il,2:jl,1:kl) - Porosity in the k direction.
        !
        !  indFamilyI(:,:,:)  - Index of the i-face in the arrays
        !                       to compute the local mass flow
        !                       for a family or sliding mesh interface.
        !                       Dimension is (1:il,2:jl,2:kl).
        !  indFamilyJ(:,:,:)  - Idem for the j-faces.
        !                       Dimension is (2:il,1:jl,2:kl).
        !  indFamilyK(:,:,:)  - Idem for the k-faces.
        !                       Dimension is (2:il,2:jl,1:kl)
        !  factFamilyI(:,:,:) - Corresponding factor to make sure
        !                       that the massflow is defined positive
        !                       when it enters the block and to define
        !                       the mass flow of the entire wheel
        !                       instead of a sector. Hence the possible
        !                       values or -nSlices and nSlices, where
        !                       nSlices or the number of sections to
        !                       obtain the full wheel.
        !  factFamilyJ(:,:,:) - Idem for the j-faces.
        !  factFamilyK(:,:,:) - Idem for the k-faces.
        !
        !  rotMatrixI(:,:,:,:,:) - Rotation matrix of the i-faces to
        !                          transform the velocity components
        !                          from Cartesian to local cylindrical.
        !                          This is needed only for problems with
        !                          rotational periodicity in combination
        !                          with an upwind scheme.
        !                          Dimension is (1:il,2:jl,2:kl,3,3).
        !  rotMatrixJ(:,:,:,:,:) - Idem for the j-faces.
        !                          Dimension is (2:il,1:jl,2:kl,3,3).
        !  rotMatrixK(:,:,:,:,:) - Idem for the k-faces.
        !                          Dimension is (2:il,2:jl,1:kl,3,3).
        !
        !  blockIsMoving      - Whether or not the block is moving.
        !  addGridVelocities  - Whether or not the face velocities
        !                       are allocated and set.
        !  sFaceI(0:ie,je,ke) - Dot product of the face velocity and
        !                       the normal in i-direction.
        !  sFaceJ(ie,0:je,ke) - Idem in j-direction.
        !  sFaceK(ie,je,0:ke) - Idem in k-direction.
 
        real(kind=realtype), dimension(:, :, :, :), pointer :: x, xtmp
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: xold
        real(kind=realtype), dimension(:, :, :, :), pointer :: si, sj, sk
        real(kind=realtype), dimension(:, :, :), pointer :: vol
        real(kind=realtype), dimension(:, :, :, :), pointer :: volold
        real(kind=realtype), dimension(:, :, :), pointer :: volref
        real(kind=realtype), dimension(:, :, :), pointer :: skew
        real(kind=realtype), dimension(:, :, :, :), pointer :: uv
        integer(kind=intType), dimension(:, :, :, :), pointer :: surfnodeindices
 
        integer(kind=porType), dimension(:, :, :), pointer :: pori, porj, pork
        integer(kind=intType), dimension(:, :, :), pointer :: indfamilyi, indfamilyj, indfamilyk
        integer(kind=intType), dimension(:, :, :), pointer :: factfamilyi, factfamilyj, factfamilyk
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: rotmatrixi, rotmatrixj, rotmatrixk
 
        logical :: blockismoving, addgridvelocities
 
        real(kind=realtype), dimension(:, :, :), pointer :: sfacei, sfacej, sfacek
 
        ! Added by HDN
        ! xALE(0:ie,0:je,0:ke,3)              - Temporary storage of x so that
        !                                       intermediate meshes can be stored in
        !                                       x directly
        ! sVeloIALE(0:ie,1:je,1:ke,3)
        ! sVeloJALE(1:ie,0:je,1:ke,3)
        ! sVeloKALE(1:ie,1:je,0:ke,3)         - Storage of surface velocities at one
        !                                       time step
        ! sIALE(0:nALEsteps,0:ie,1:je,1:ke,3)
        ! sJALE(0:nALEsteps,1:ie,0:je,1:ke,3)
        ! sKALE(0:nALEsteps,1:ie,1:je,0:ke,3) - Storage of sI, sJ, sK for intermediate
        !                                       meshes
        ! sFaceIALE(0:nALEsteps,0:ie,je,ke)
        ! sFaceJALE(0:nALEsteps,ie,0:je,ke)
        ! sFaceKALE(0:nALEsteps,ie,je,0:ke)   - Storage of sFaceI, sFaceJ, sFaceK for
        !                                       intermediate meshes
        real(kind=realtype), dimension(:, :, :, :), pointer :: xale
        real(kind=realtype), dimension(:, :, :, :), pointer :: sveloiale, svelojale, svelokale
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: siale, sjale, skale
        real(kind=realtype), dimension(:, :, :, :), pointer :: sfaceiale, sfacejale, sfacekale
 
        ! Tempory storage for overset variables
        real(kind=realtype), dimension(:, :, :, :), pointer :: xseed
        integer(kind=intType), dimension(:, :, :), pointer :: wallind
 
        !
        !         Flow variables.
        !
        ! w(0:ib,0:jb,0:kb,1:nw)       - The set of independent variables
        !                                w(i,j,k,1:nwf) flow field
        !                                variables, which are rho, u,
        !                                v, w and rhoE. In other words
        !                                the velocities  are stored and
        !                                not the momentum!!!!
        !                                w(i,j,k,nt1:nt2) turbulent
        !                                variables; also the primitive
        !                                variables are stored.
        ! wOld(nOld,2:il,2:jl,2:kl,nw) - Solution on older time levels,
        !                                needed for the time integration
        !                                for unsteady problems. In
        !                                constrast to w, the conservative
        !                                variables are stored in wOld for
        !                                the flow variables; the turbulent
        !                                variables are always the
        !                                primitive ones.
        !                                Only allocated on the finest
        !                                mesh.
        ! p(0:ib,0:jb,0:kb)            - Static pressure.
        ! gamma(0:ib,0:jb,0:kb)        - Specific heat ratio; only
        !                                allocated on the finest grid.
        ! rlv(0:ib,0:jb,0:kb)          - Laminar viscosity; only
        !                                allocated on the finest mesh
        !                                and only for viscous problems.
        ! rev(0:ib,0:jb,0:kb)          - Eddy viscosity; only
        !                                allocated rans problems with
        !                                eddy viscosity models.
        ! s(1:ie,1:je,1:ke,3)          - Mesh velocities of the cell
        !                                centers; only for moving mesh
        !                                problems.
 
        real(kind=realtype), dimension(:, :, :, :), pointer :: w, wtmp
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: dw_deriv
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: wold
        real(kind=realtype), dimension(:, :, :), pointer :: p, gamma, aa
        real(kind=realtype), dimension(:, :, :), pointer :: rlv, rev
        real(kind=realtype), dimension(:, :, :, :), pointer :: s
        real(kind=realtype), dimension(:, :, :), pointer :: shocksensor
 
        ! Nodal Fluxes: ux,uy,uz,vx,vy,vz,wx,wy,wz,qx,qy,qz(il, jl, kl)
        real(kind=realtype), dimension(:, :, :), pointer :: ux, uy, uz
        real(kind=realtype), dimension(:, :, :), pointer :: vx, vy, vz
        real(kind=realtype), dimension(:, :, :), pointer :: wx, wy, wz
        real(kind=realtype), dimension(:, :, :), pointer :: qx, qy, qz
 
        !
        !         Residual and multigrid variables.
        !
        ! dw(0:ib,0:jb,0:kb,1:nw)   - Values of convective and combined
        !                             flow residuals. Only allocated on
        !                             the finest mesh.
        ! fw(0:ib,0:jb,0:kb,1:nwf)  - values of artificial dissipation
        !                             and viscous residuals.
        !                             Only allocated on the finest mesh.
 
        ! dwOldRK(:,2:il,2:jl,2:kl,nw) - Old residuals for the time
        !                                accurate Runge-Kutta schemes.
        !                                The first dimension is
        !                                nRKStagesUnsteady - 1.Only
        !                                allocated on the finest level
        !                                and only in unsteady mode for
        !                                Runge-Kutta schemes.
 
        ! w1(1:ie,1:je,1:ke,1:nMGVar) - Values of the mg variables
        !                               upon first entry to a coarser
        !                               mesh; only allocated on the
        !                               coarser grids. The variables
        !                               used to compute the multigrid
        !                               corrections are rho, u, v, w
        !                               and p; the rhoE value is used
        !                               for unsteady problems only.
        ! p1(1:ie,1:je,1:ke)          - Value of the pressure upon
        !                               first entry to a coarser grid;
        !                               only allocated on the coarser
        !                               grids.
        ! wr(2:il,2:jl,2:kl,1:nMGVar) - Multigrid forcing terms; only
        !                               allocated on the coarser grids.
        !                               The forcing term of course
        !                               contains conservative residuals,
        !                               at least for the flow variables.
        ! shockSensor(0:ib,0:jb,0:kb)   Precomputed sensor value for shock
        !                               that is *NOT* differentated.
        ! scratch(0:ib,0:jb,0:kb,5)     Scratch space for the turbulence
        !                               models. NOMINALLY this could use
        !                               dw and the code was nominally setup
        !                               for this originally. However, this
        !                               complicates reverse mode sensitivities
        !                               So we use this instead.
 
        real(kind=realtype), dimension(:, :, :), pointer :: p1
        real(kind=realtype), dimension(:, :, :, :), pointer :: dw, fw
        real(kind=realtype), dimension(:, :, :, :), pointer :: dwtmp, dwtmp2
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: dwoldrk
        real(kind=realtype), dimension(:, :, :, :), pointer :: w1, wr
        real(kind=realtype), dimension(:, :, :, :), pointer :: scratch
 
        ! Added by HDN
        ! Used for ALE. Only allocated on the finest mesh.
        ! Extra dim is used to store initial residuals
        ! dwALE(0:nALEsteps,0:ib,0:jb,0:kb,1:nw)   - Values of ONLY the convective flux
        !                                            of intermediate meshes.
        ! fwALE(0:nALEsteps,0:ib,0:jb,0:kb,1:nwf)  - values of ONLY the artificial
        !                                            dissipation of intermediate meshes.
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: dwale, fwale
 
        ! mgIFine(2:il,2) - The two fine grid i-cells used for the
        !                   restriction of the solution and residual to
        !                   the coarse grid. Only on the coarser grids.
        ! mgJFine(2:jl,2) - Idem for j-cells.
        ! mgKFine(2:kl,2) - Idem for k-cells.
 
        ! mgIWeight(2:il) - Weight for the residual restriction in
        !                   in i-direction. Value is either 0.5 or 1.0,
        !                   depending whether mgIFine(,1) is equal to
        !                   or differs from mgIFine(,2).
        ! mgJWeight(2:jl) - Idem for weights in j-direction.
        ! mgKWeight(2:kl) - Idem for weights in k-direction.
 
        ! mgICoarse(2:il,2) - The two coarse grid i-cells used for the
        !                     interpolation of the correction to the
        !                     fine grid. Not on the coarsest grid.
        ! mgJCoarse(2:jl,2) - Idem for j-cells.
        ! mgKCoarse(2:kl,2) - Idem for k-cells.
 
        integer(kind=intType), dimension(:, :), pointer :: mgifine
        integer(kind=intType), dimension(:, :), pointer :: mgjfine
        integer(kind=intType), dimension(:, :), pointer :: mgkfine
 
        real(kind=realtype), dimension(:), pointer :: mgiweight
        real(kind=realtype), dimension(:), pointer :: mgjweight
        real(kind=realtype), dimension(:), pointer :: mgkweight
 
        integer(kind=intType), dimension(:, :), pointer :: mgicoarse
        integer(kind=intType), dimension(:, :), pointer :: mgjcoarse
        integer(kind=intType), dimension(:, :), pointer :: mgkcoarse
 
        ! iCoarsened - How this block was coarsened in i-direction.
        ! jCoarsened - How this block was coarsened in j-direction.
        ! kCoarsened - How this block was coarsened in k-direction.
 
        integer(kind=porType) :: icoarsened, jcoarsened, kcoarsened
 
        ! iCo: Indicates whether or not i grid lines are present on the
        !      coarse grid; not allocated for the coarsest grid.
        ! jCo: Idem in j-direction.
        ! kCo: Idem in k-direction.
 
        logical, dimension(:), pointer :: ico, jco, kco
        !
        !         Time-stepping and spectral radii variables.
        !         only allocated on the finest grid.
        !
        ! wn(2:il,2:jl,2:kl,1:nMGVar) - Values of the update variables
        !                               at the beginning of the RungeKutta
        !                               iteration. Only allocated for
        !                               RungeKutta smoother.
        ! pn(2:il,2:jl,2:kl)          - The pressure for the RungeKutta
        !                               smoother.
        ! dtl(1:ie,1:je,1:ke)         - Time step
        ! radI(1:ie,1:je,1:ke)        - Spectral radius in i-direction.
        ! radJ(1:ie,1:je,1:ke)        - Spectral radius in j-direction.
        ! radK(1:ie,1:je,1:ke)        - Spectral radius in k-direction.
 
        real(kind=realtype), dimension(:, :, :, :), pointer :: wn
        real(kind=realtype), dimension(:, :, :), pointer :: pn
        real(kind=realtype), dimension(:, :, :), pointer :: dtl
        real(kind=realtype), dimension(:, :, :), pointer :: radi, radj, radk
 
        !
        !         Variables for Iso/Surface Slice generation
        ! fc(1:ie,1:je,1:ke) - cell center values of the function to be iso-valued
        ! fn(1:il,1:jl,1:kl) - node values of the function to be iso-valued
        ! Note these are are only allocated temporaily during solution writing.
 
        real(kind=realtype), dimension(:, :, :), pointer :: fc
        real(kind=realtype), dimension(:, :, :), pointer :: fn
 
        !
        !         Turbulence model variables.
        !
        ! d2Wall(2:il,2:jl,2:kl) - Distance from the center of the cell
        !                          to the nearest viscous wall.
        ! intermittency( )       - Function defining the transition location
 
        real(kind=realtype), dimension(:, :, :), pointer :: d2wall, filterdes
        real(kind=realtype), dimension(:, :, :), pointer :: intermittency
 
        ! bmti1(je,ke,nt1:nt2,nt1:nt2): Matrix used for the implicit
        !                               boundary condition treatment of
        !                               the turbulence equations at the
        !                               iMin boundary. Only allocated on
        !                               the finest level and for the 1st
        !                               spectral solution.
        ! bmti2(je,ke,nt1:nt2,nt1:nt2): Idem for the iMax boundary.
        ! bmtj1(ie,ke,nt1:nt2,nt1:nt2): Idem for the jMin boundary.
        ! bmtj2(ie,ke,nt1:nt2,nt1:nt2): Idem for the jMax boundary.
        ! bmtk1(ie,je,nt1:nt2,nt1:nt2): Idem for the kMin boundary.
        ! bmtk2(ie,je,nt1:nt2,nt1:nt2): Idem for the kMax boundary.
 
        real(kind=realtype), dimension(:, :, :, :), pointer :: bmti1, bmti2
        real(kind=realtype), dimension(:, :, :, :), pointer :: bmtj1, bmtj2
        real(kind=realtype), dimension(:, :, :, :), pointer :: bmtk1, bmtk2
 
        ! bvti1(je,ke,nt1:nt2): RHS vector used for the implicit
        !                       boundary condition treatment of the
        !                       turbulence equations at the iMin
        !                       boundary. Only allocated on the finest
        !                       level and for the 1st spectral solution.
        ! bvti2(je,ke,nt1:nt2): Idem for the iMax boundary.
        ! bvtj1(ie,ke,nt1:nt2): Idem for the jMin boundary.
        ! bvtj2(ie,ke,nt1:nt2): Idem for the jMax boundary.
        ! bvti2(je,ke,nt1:nt2): Idem for the iMax boundary.
        ! bvtk1(ie,ke,nt1:nt2): Idem for the kMin boundary.
        ! bvtk2(ie,ke,nt1:nt2): idem for the kMax boundary.
 
        real(kind=realtype), dimension(:, :, :), pointer :: bvti1, bvti2
        real(kind=realtype), dimension(:, :, :), pointer :: bvtj1, bvtj2
        real(kind=realtype), dimension(:, :, :), pointer :: bvtk1, bvtk2
        !
        !         Relation to the original cgns grid.
        !
        ! sectionID      - The section of the grid this block belongs to.
        ! cgnsBlockID    - Block/zone number of the cgns grid to which
        !                  this block is related.
        ! iBegOr, iEndOr - Range of points of this block in the
        ! jBegOr, jEndOr   corresponding cgns block, i.e. for this block
        ! kBegOr, kEndOr   iBegOr <= i <= iEndOr, jBegOr <= j <= jEndOr,
        !                  kBegOr <= k <= kEndOr.
        !                  It is of course possible that the entire
        !                  block is stored.
        integer(kind=intType) :: sectionid = 1
        integer(kind=intType) :: cgnsblockid
        integer(kind=intType) :: ibegor, iendor, jbegor, jendor
        integer(kind=intType) :: kbegor, kendor
        type(surfacenodeweightarray), dimension(6) :: nodalweights
        !
        !         Adjoint solver variables.
        !
        ! globalNode(ib:ie,jb:je,kb:ke):  Global node numbering.
        ! globalCell(0:ib,0:jb,0:kb):     Global cell numbering.
        ! color(0:ib,0:jb,0:kb)     :     Temporary coloring array used for
        !                                 forward mode AD/FD calculations
        integer(kind=intType), dimension(:, :, :), pointer :: globalcgnsnode
        integer(kind=intType), dimension(:, :, :), pointer :: globalnode
        integer(kind=intType), dimension(:, :, :), pointer :: globalcell
        integer(kind=intType), dimension(:, :, :), pointer :: color
 
        ! Data storing the first order PC in tri-diagonal ordering. 7
        ! real(kind=realType), dimension(:, :, :, :, :), pointer :: Diag
        ! real(kind=realType), dimension(:, :, :, :, :), pointer :: i_L, i_U
        ! real(kind=realType), dimension(:, :, :, :, :), pointer :: j_L, j_U
        ! real(kind=realType), dimension(:, :, :, :, :), pointer :: k_L, k_U
 
        real(kind=realtype), dimension(:, :, :, :, :), pointer :: pcmat
 
        ! Generic vectors for doing products/preconditioning. Like w, but
        ! only 1 level of halos, and it is in block ordering (nw first)
        ! instead of field ordering like w is.
        real(kind=realtype), dimension(:, :, :, :), pointer :: pcvec1, pcvec2
 
        ! Data for the factorized trigonal solves
        real(kind=realtype), dimension(:, :, :, :), pointer :: i_d_fact, j_d_fact, k_d_fact
        real(kind=realtype), dimension(:, :, :, :), pointer :: i_l_fact, j_l_fact, k_l_fact
        real(kind=realtype), dimension(:, :, :, :), pointer :: i_u_fact, j_u_fact, k_u_fact
        real(kind=realtype), dimension(:, :, :, :), pointer :: i_u2_fact, j_u2_fact, k_u2_fact
 
        integer(kind=intType), dimension(:, :, :, :), pointer :: i_ipiv, j_ipiv, k_ipiv
 
        ! A list of pointers for generic communication of either real or
        ! integer data.
        type(rptr), dimension(24) :: realcommvars
        type(iptr), dimension(3) :: intcommvars
 
    end type blocktype
 
    !
    !       Array of all blocks at all multigrid levels and spectral sols.
    !
    ! nDom:            total number of computational blocks.
    ! flowDoms(:,:,:): array of blocks. Dimensions are
    !                  (nDom,nLevels,nTimeIntervalsSpectral)
 
    integer(kind=intType) :: ndom
 
    ! A global paramter for how to sort fringes
    integer(kind=intType) :: fringesorttype = sortbydonor
 
#ifdef USE_TAPENADE
    ! This is never actually compiled...just make tapenade think it
    ! isn't allocatable
    type(blocktype), dimension(nn:nn, 1, ntimeIntervalsSpectral) :: flowdoms
#else
    type(blocktype), allocatable, target, dimension(:, :, :) :: flowdoms
    type(blocktype), allocatable, target, dimension(:, :, :) :: flowdomsd
    type(blocktype), allocatable, target, dimension(:, :, :) :: flowdomsb
#endif
 
    !
    !       Additional info needed in the flow solver.
    !
    ! nCellGlobal(nLev) - Global number of cells on every mg level.
 
    integer(kind=intType), allocatable, dimension(:) :: ncellglobal
 
contains
 
    logical function lessequalfringetype(g1, g2)
 
        !         lessEqual returns .true. if g1 <= g2 and .false. otherwise.
        !         The comparison is firstly based on the processor ID of the
        !         donor, then the block, then then the I, J, K
        !
        implicit none
        !
        !        Function arguments.
        !
        type(fringetype), intent(in) :: g1, g2
        !
        ! Compare the donor processors first. If not equal,
        ! set lessEqual appropriately and return.
        if (fringesorttype == sortbydonor) then
            if (g1%donorProc < g2%donorProc) then
                lessequalfringetype = .true.
                return
            else if (g1%donorProc > g2%donorProc) then
                lessequalfringetype = .false.
                return
            end if
 
            ! Donor processors are identical. Now we check the block
 
            if (g1%donorBlock < g2%donorBlock) then
                lessequalfringetype = .true.
                return
            else if (g1%donorBlock > g2%donorBlock) then
                lessequalfringetype = .false.
                return
            end if
 
            ! Compare the indices of the halo. First k, then j and
            ! finally i.
 
            if (g1%dIndex < g2%dIndex) then
                lessequalfringetype = .true.
                return
            else if (g1%dindex > g2%dIndex) then
                lessequalfringetype = .false.
                return
            end if
 
        else if (fringesorttype == sortbyreceiver) then
 
            ! Compare my indices
 
            if (g1%myIndex < g2%myIndex) then
                lessequalfringetype = .true.
                return
            else if (g1%myIndex > g2%myIndex) then
                lessequalfringetype = .false.
                return
            end if
 
            ! Now compare the donor information:
 
            if (g1%donorProc < g2%donorProc) then
                lessequalfringetype = .true.
                return
            else if (g1%donorProc > g2%donorProc) then
                lessequalfringetype = .false.
                return
            end if
 
            ! Donor processors are identical. Now we check the block
 
            if (g1%donorBlock < g2%donorBlock) then
                lessequalfringetype = .true.
                return
            else if (g1%donorBlock > g2%donorBlock) then
                lessequalfringetype = .false.
                return
            end if
 
            ! Compare the indices of the halo. First k, then j and
            ! finally i.
 
            if (g1%dIndex < g2%dIndex) then
                lessequalfringetype = .true.
                return
            else if (g1%dIndex > g2%dIndex) then
                lessequalfringetype = .false.
                return
            end if
        end if
 
        ! Both entities are identical. So set lessEqual to .true.
 
        lessequalfringetype = .true.
 
    end function lessequalfringetype
 
    logical function lessfringetype(g1, g2)
 
        !         less returns .true. if g1 <= g2 and .false. otherwise.
        !         The comparison is firstly based on the processor ID of the
        !         donor, then the block, then then the I, J, K
        !
        implicit none
        !
        !        Function arguments.
        !
        type(fringetype), intent(in) :: g1, g2
        !
        ! Compare the donor processors first. If not equal,
        ! set less appropriately and return.
        if (fringesorttype == sortbydonor) then
            if (g1%donorProc < g2%donorProc) then
                lessfringetype = .true.
                return
            else if (g1%donorProc > g2%donorProc) then
                lessfringetype = .false.
                return
            end if
 
            ! Donor processors are identical. Now we check the block
 
            if (g1%donorBlock < g2%donorBlock) then
                lessfringetype = .true.
                return
            else if (g1%donorBlock > g2%donorBlock) then
                lessfringetype = .false.
                return
            end if
 
            ! Compare the indices of the halo. First k, then j and
            ! finally i.
 
            if (g1%dIndex < g2%dIndex) then
                lessfringetype = .true.
                return
            else if (g1%dIndex > g2%dIndex) then
                lessfringetype = .false.
                return
            end if
 
        else if (fringesorttype == sortbyreceiver) then
 
            ! Compare my indices
 
            if (g1%myIndex < g2%myIndex) then
                lessfringetype = .true.
                return
            else if (g1%myIndex > g2%myIndex) then
                lessfringetype = .false.
                return
            end if
 
            ! Now compare the donor information:
 
            if (g1%donorProc < g2%donorProc) then
                lessfringetype = .true.
                return
            else if (g1%donorProc > g2%donorProc) then
                lessfringetype = .false.
                return
            end if
 
            ! Donor processors are identical. Now we check the block
 
            if (g1%donorBlock < g2%donorBlock) then
                lessfringetype = .true.
                return
            else if (g1%donorBlock > g2%donorBlock) then
                lessfringetype = .false.
                return
            end if
 
            ! Compare the indices of the halo. First k, then j and
            ! finally i.
 
            if (g1%dIndex < g2%dIndex) then
                lessfringetype = .true.
                return
            else if (g1%dIndex > g2%dIndex) then
                lessfringetype = .false.
                return
            end if
        end if
 
        ! Both entities are identical. So set less to .False.
 
        lessfringetype = .false.
 
    end function lessfringetype
 
    logical function lessequalinterppttype(g1, g2)
 
        !         lessEqual returns .true. if g1 <= g2 and .false. otherwise.
        !         The comparison is firstly based on the processor ID of the
        !         donor, then the block, then then the I, J, K
        !
        implicit none
        !
        !        Function arguments.
        !
        type(interppttype), intent(in) :: g1, g2
        !
 
        if (g1%donorProc < g2%donorProc) then
            lessequalinterppttype = .true.
            return
        else if (g1%donorProc > g2%donorProc) then
            lessequalinterppttype = .false.
            return
        end if
 
        ! Donor processors are identical. Now we check the block
 
        if (g1%donorBlock < g2%donorBlock) then
            lessequalinterppttype = .true.
            return
        else if (g1%donorBlock > g2%donorBlock) then
            lessequalinterppttype = .false.
            return
        end if
 
        ! Compare the indices of the halo. First k, then j and
        ! finally i.
 
        if (g1%dK < g2%dK) then
            lessequalinterppttype = .true.
            return
        else if (g1%dK > g2%dK) then
            lessequalinterppttype = .false.
            return
        end if
 
        if (g1%dJ < g2%dJ) then
            lessequalinterppttype = .true.
            return
        else if (g1%dJ > g2%dJ) then
            lessequalinterppttype = .false.
            return
        end if
 
        if (g1%dI < g2%dI) then
            lessequalinterppttype = .true.
            return
        else if (g1%dI > g2%dI) then
            lessequalinterppttype = .false.
            return
        end if
 
        ! Both entities are identical. So set lessEqual to .true.
 
        lessequalinterppttype = .true.
 
    end function lessequalinterppttype
 
    logical function lessinterppttype(g1, g2)
 
        implicit none
        !
        !        Function arguments.
        !
        type(interppttype), intent(in) :: g1, g2
        !
        if (g1%donorProc < g2%donorProc) then
            lessinterppttype = .true.
            return
        else if (g1%donorProc > g2%donorProc) then
            lessinterppttype = .false.
            return
        end if
 
        ! Donor processors are identical. Now we check the block
 
        if (g1%donorBlock < g2%donorBlock) then
            lessinterppttype = .true.
            return
        else if (g1%donorBlock > g2%donorBlock) then
            lessinterppttype = .false.
            return
        end if
 
        ! Compare the indices of the halo. First k, then j and
        ! finally i.
 
        if (g1%dK < g2%dK) then
            lessinterppttype = .true.
            return
        else if (g1%dK > g2%dK) then
            lessinterppttype = .false.
            return
        end if
 
        if (g1%dJ < g2%dJ) then
            lessinterppttype = .true.
            return
        else if (g1%dJ > g2%dJ) then
            lessinterppttype = .false.
            return
        end if
 
        if (g1%dI < g2%dI) then
            lessinterppttype = .true.
            return
        else if (g1%dI > g2%dI) then
            lessinterppttype = .false.
            return
        end if
 
        ! Both entities are identical. So set less to .False.
 
        lessinterppttype = .false.
 
    end function lessinterppttype
 
end module block