Mesh3D_t Derived Type

  type,extends(SEMMesh) :: Mesh3D_t
    integer,pointer,dimension(:,:,:) :: sideInfo
    real(prec),pointer,dimension(:,:,:,:,:) :: nodeCoords
    integer,pointer,dimension(:,:) :: elemInfo
    integer,pointer,dimension(:,:,:,:) :: globalNodeIDs
    integer,pointer,dimension(:,:) :: CGNSCornerMap
    integer,pointer,dimension(:,:) :: sideMap
    integer,pointer,dimension(:,:) :: CGNSSideMap
    integer,pointer,dimension(:,:) :: BCType
    character(LEN=255),allocatable :: BCNames(:)
    ! 2:1 nonconforming (mortar) interface bookkeeping.
    !
    ! A mortar interface joins one "big" element face to the four quarter-faces of its
    ! 2:1 refined neighbors ("small" faces). Faces that participate in a mortar carry
    ! sideInfo(3) = 0 (no conforming neighbor) and sideInfo(5) = 0 (no boundary
    ! condition), so all conforming-face machinery (SideExchange, RecalculateFlip,
    ! boundary-condition mapping) skips them; sideInfo(1) is set to the mortar index
    ! for reference.
    !
    ! The big face is split into four sub-faces ("quadrants") indexed in the big
    ! face's trace coordinates: q = kx + 2*(ky-1) with kx, ky in {1,2} the
    ! half-interval index along the face's first and second coordinate
    ! (1 = [-1,0], 2 = [0,1]).
    !
    ! mortarInfo(1:14,1:nMortars) is replicated on all ranks (element ids are global):
    !   1  - big element id ; 2 - big local face id
    !   3  - small element id on the sub-face covering big-face quadrant 1
    !   4  - 10*(small local face) + flip for that sub-face
    !   5,6   - same for quadrant 2
    !   7,8   - same for quadrant 3
    !   9,10  - same for quadrant 4
    !   11:14 - global side ids of sub-faces 1..4 (used as MPI message tags)
    ! The flip maps big-face quadrant coordinates to the small face's own coordinates
    ! (the same receiver-to-donor convention as sideInfo(4); see MortarFaceMap).
    integer :: nMortars = 0
    integer,pointer,dimension(:,:) :: mortarInfo => null()
    ! Anisotropic (2-subface) nonconforming interfaces.
    !
    ! An anisotropic mortar joins one big face to two small faces that split it along
    ! one of its two trace coordinates only (the split coordinate) and span the whole
    ! interval [-1,1] of the other. This is the interface between a coarse column and two
    ! fine columns of an extruded mesh whose surface mesh has 2-D mortars. Its faces
    ! carry sideInfo(3) = 0 and sideInfo(5) = 0 like those of a 2x2 mortar, and
    ! sideInfo(1) = nMortars + a, so a nonzero sideInfo(1) still marks a mortar face.
    !
    ! anisoMortarInfo(1:9,1:nAnisoMortars) is replicated on all ranks (global element ids):
    !   1  - big element id ; 2 - big local face id
    !   3  - small element id on the half h = 1 ([-1,0] of the split coordinate)
    !   4  - 10*(small local face) + flip for that half
    !   5,6 - same for the half h = 2 ([0,1])
    !   7,8 - global side ids of the two small faces (used as MPI message tags)
    !   9  - the split coordinate of the big face, 1 or 2 (the face trace-coordinate
    !        convention of BoundaryInterp: faces 1,6 -> (xi1,xi2); 2,4 -> (xi1,xi3);
    !        3,5 -> (xi2,xi3))
    ! The flip maps big-face half coordinates to the small face's own coordinates, as for
    ! mortarInfo. The 1-D mortarR/mortarP of the half act on the split coordinate and the
    ! identity on the other.
    integer :: nAnisoMortars = 0
    integer,pointer,dimension(:,:) :: anisoMortarInfo => null()
    ! Material tracking: every element has an integer material id
    ! indexing into materialNames. Single-material constructors and
    ! readers (HOPr, structured, periodic) leave nMaterials = 1 with
    ! the name "default". The HOHQMesh ISM-MM reader populates the
    ! table with the material strings from the .mesh file.
    integer :: nMaterials = 0
    integer,allocatable :: elemMaterial(:)
    character(LEN=SELF_MESH_MATNAME_LENGTH),allocatable :: materialNames(:)
    ! Layer count of a mesh built by ExtrudedMesh, and 0 for every other mesh.
    !
    ! An extruded mesh stores its elements column by column: local element
    ! e3 = (e2-1)*nLayers + k is layer k (k = 1 at the bottom) of the column above local
    ! element e2 of the surface Mesh2D it was built from, and the same rule maps global
    ! ids. A column therefore never straddles two ranks, and the surface element and
    ! layer of an element follow from its id alone:
    !   e2 = (e3-1)/nLayers + 1 ,  k = e3 - (e2-1)*nLayers
    integer :: nLayers = 0

  contains

    procedure,public :: Init => Init_Mesh3D_t
    procedure,public :: Free => Free_Mesh3D_t
    procedure,public :: UpdateDevice => UpdateDevice_Mesh3D_t

    generic,public :: StructuredMesh => UniformStructuredMesh_Mesh3D_t
    procedure,private :: UniformStructuredMesh_Mesh3D_t

    procedure,public :: SimpleMortarMesh => SimpleMortarMesh_Mesh3D_t
    procedure,public :: SimpleAnisoMortarMesh => SimpleAnisoMortarMesh_Mesh3D_t

    generic,public :: PeriodicStructuredMesh => UniformPeriodicMesh_Mesh3D_t
    procedure,private :: UniformPeriodicMesh_Mesh3D_t

    procedure,public :: ExtrudedMesh => ExtrudedMesh_Mesh3D_t

    procedure,public :: Read_HOPr => Read_HOPr_Mesh3D_t
    procedure,public :: Read_HOHQMesh => Read_HOHQMesh_Mesh3D_t

    procedure,public :: ResetBoundaryConditionType => ResetBoundaryConditionType_Mesh3D_t

    procedure,public :: Write_Mesh => Write_Mesh3D_t

    procedure,public :: RecalculateFlip => RecalculateFlip_Mesh3D_t

  endtype Mesh3D_t