oversetPackingRoutines.F90

Go to the documentation of this file.

module oversetpackingroutines
contains
 
    subroutine getoblockbuffersizes(il, jl, kl, iSize, rSize)
 
        ! Subroutine to get the required buffer sizes. This only uses the
        ! block dimensions and technically doesn't have anything to do with
        ! oBlock. This allows us to figure out the sizes and perform a
        ! global communication before actually building the ADTrees, which
        ! may not be that well load-balanced.
 
        use constants
        implicit none
 
        ! Input/OUtput
        integer(kind=intType) :: il, jl, kl
        integer(kind=intType) :: rSize, iSize
 
        ! Working paramters
        integer(kind=intType) :: ie, je, ke, nBBox, nLeaves
 
        ! Initializeation
        isize = 0
        rsize = 0
 
        ! Create ie sizes as well
        ie = il + 1; je = jl + 1; ke = kl + 1
 
        ! Count up the integers we want to send:
 
        isize = isize + 6 ! Blocks sizes + proc + nn + cluster
 
        isize = isize + 8 * il * jl * kl ! hexa conn
 
        isize = isize + (ie + 2) * (je + 2) * (ke + 2) ! global cell
 
        isize = isize + il * jl * kl ! nearWall
 
        isize = isize + ie * je * ke ! invalidDonor
 
        ! Number of boxes in the ADT is the same as the number of elements
        ! (like hexa conn (without the *8 obviously)
        nbbox = il * jl * kl
        nleaves = nbbox - 1 ! See ADT/adtBuild.f90
 
        isize = isize + nleaves * 2 ! Two ints for the children in each leaf
 
        ! Count up the reals we ned to send:
        rsize = rsize + ie * je * ke ! qualDonor
 
        rsize = rsize + 3 * ie * je * ke ! xADT
 
        rsize = rsize + nbbox * 6 ! Cell bounding boxes
 
        rsize = rsize + nleaves * 12 ! Bounding boxes for leaves
 
        rsize = rsize + 1 ! Min block volume
    end subroutine getoblockbuffersizes
 
    subroutine packoblock(oBlock)
 
        use constants
        use oversetdata, only: oversetblock
        implicit none
 
        ! Pack up everything we need for this block into its own buffer
        ! inlucding the data required for the ADTree
 
        ! Input/Output Parameters
        type(oversetblock), intent(inout) :: oBlock
 
        ! Working paramters
        integer(kind=intType) :: rSize, iSize, i, j, k, nHexa, nADT
        integer(kind=intType) :: ie, je, ke, il, jl, kl
 
        ! If the buffer is already allocated, the block is packed and there
        ! is nothing to do
        if (allocated(oblock%rBuffer)) then
            return
        end if
 
        call getoblockbuffersizes(oblock%il, oblock%jl, oblock%kl, isize, rsize)
 
        ! Allocate the buffers
        allocate (oblock%rBuffer(rsize), oblock%iBuffer(isize))
 
        ! Reset the integer counter and add all the integers on this pass
        isize = 0
 
        oblock%iBuffer(1) = oblock%il
        oblock%iBuffer(2) = oblock%jl
        oblock%iBuffer(3) = oblock%kl
        oblock%iBuffer(4) = oblock%proc
        oblock%iBuffer(5) = oblock%block
        oblock%iBuffer(6) = oblock%cluster
 
        isize = isize + 6
 
        il = oblock%il
        jl = oblock%jl
        kl = oblock%kl
 
        ie = il + 1
        je = jl + 1
        ke = kl + 1
 
        nhexa = oblock%il * oblock%jl * oblock%kl
        nadt = ie * je * ke
 
        do j = 1, nhexa
            do i = 1, 8
                isize = isize + 1
                oblock%iBuffer(isize) = oblock%hexaConn(i, j)
            end do
        end do
 
        do k = 0, ke + 1
            do j = 0, je + 1
                do i = 0, ie + 1
                    isize = isize + 1
                    oblock%iBuffer(isize) = oblock%globalCell(i, j, k)
                end do
            end do
        end do
 
        do k = 1, kl
            do j = 1, jl
                do i = 1, il
                    isize = isize + 1
                    oblock%iBuffer(isize) = oblock%nearWall(i, j, k)
                end do
            end do
        end do
 
        do k = 1, ke
            do j = 1, je
                do i = 1, ie
                    isize = isize + 1
                    oblock%iBuffer(isize) = oblock%invalidDonor(i, j, k)
                end do
            end do
        end do
 
        do i = 1, oblock%ADT%nLeaves
            isize = isize + 1
            oblock%iBuffer(isize) = oblock%ADT%ADTree(i)%children(1)
            isize = isize + 1
            oblock%iBuffer(isize) = oblock%ADT%ADTree(i)%children(2)
        end do
 
        ! Reset the real counter and add all the real values on this pass.
        rsize = 0
 
        do i = 1, ie * je * ke
            rsize = rsize + 1
            oblock%rBuffer(rsize) = oblock%qualDonor(1, i)
        end do
 
        do j = 1, ie * je * ke
            do i = 1, 3
                rsize = rsize + 1
                oblock%rBuffer(rsize) = oblock%xADT(i, j)
            end do
        end do
 
        do i = 1, oblock%ADT%nBboxes
            oblock%rBuffer(rsize + 1:rsize + 6) = oblock%ADT%xBBox(:, i)
            rsize = rsize + 6
        end do
 
        do i = 1, oblock%ADT%nLeaves
            oblock%rBuffer(rsize + 1:rsize + 6) = oblock%ADT%ADTree(i)%xMin(:)
            rsize = rsize + 6
 
            oblock%rBuffer(rsize + 1:rsize + 6) = oblock%ADT%ADTree(i)%xMax(:)
            rsize = rsize + 6
        end do
 
        rsize = rsize + 1
        oblock%rBuffer(rsize) = oblock%minVol
 
    end subroutine packoblock
 
    subroutine unpackoblock(oBlock)
 
        use constants
        use oversetdata, only: oversetblock
        implicit none
 
        ! unPack everything we need for this block from its own buffer
        ! and reconstitute the data required for the ADTree. It is assumed
        ! the buffers are already allocated and the data is available. This
        ! does the exact *OPPOSITE* operation as the packBlock() routine
 
        ! Input/Output Parameters
        type(oversetblock), intent(inout) :: oBlock
 
        ! Working paramters
        integer(kind=intType) :: rSize, iSize, i, j, k, nHexa, nADT
        integer(kind=intType) :: ie, je, ke, il, jl, kl
 
        ! Reset the integer counter and add all the integers on this pass
        isize = 0
 
        oblock%il = oblock%iBuffer(1)
        oblock%jl = oblock%iBuffer(2)
        oblock%kl = oblock%iBuffer(3)
        oblock%proc = oblock%iBuffer(4)
        oblock%block = oblock%iBuffer(5)
        oblock%cluster = oblock%iBuffer(6)
        isize = isize + 6
 
        il = oblock%il
        jl = oblock%jl
        kl = oblock%kl
        ie = il + 1
        je = jl + 1
        ke = kl + 1
 
        nhexa = oblock%il * oblock%jl * oblock%kl
        nadt = ie * je * ke
 
        ! Allocate the remainder of the arrays in oBlock.
        allocate (oblock%hexaConn(8, nhexa))
        allocate (oblock%globalCell(0:ie + 1, 0:je + 1, 0:ke + 1))
        allocate (oblock%nearWall(1:il, 1:jl, 1:kl))
        allocate (oblock%invalidDonor(1:ie, 1:je, 1:ke))
        allocate (oblock%qualDonor(1, ie * je * ke))
        allocate (oblock%xADT(3, nadt))
 
        ! -------------------------------------------------------------------
        ! Once we know the sizes, allocate all the arrays in the
        ! ADTree. Since we are not going to call the *actual* build routine
        ! for the ADT, we need to set all the information ourselves. This
        ! essentially does the same thing as buildSerialHex.
        oblock%ADT%adtType = adtvolumeadt
        oblock%ADT%nNodes = nadt
        oblock%ADT%nTetra = 0
        oblock%ADT%nPyra = 0
        oblock%ADT%nPrisms = 0
        oblock%ADT%nTria = 0
        oblock%ADT%nQuads = 0
        oblock%ADT%coor => oblock%xADT
        oblock%ADT%hexaConn => oblock%hexaConn
        nullify (oblock%ADT%tetraConn, oblock%ADT%pyraConn, oblock%ADT%prismsConn)
        oblock%ADT%nBBoxes = nhexa
        allocate (oblock%ADT%xBBOX(6, nhexa))
        allocate (oblock%ADT%elementType(nhexa))
        allocate (oblock%ADT%elementID(nhexa))
        oblock%ADT%comm = mpi_comm_self
        oblock%ADT%nProcs = 1
        oblock%ADT%myID = 0
 
        ! All hexas
        oblock%ADT%elementType = adthexahedron
 
        do i = 1, nhexa
            oblock%ADT%elementID(i) = i
        end do
 
        oblock%ADT%nLeaves = oblock%ADT%nBBoxes - 1
        if (oblock%ADT%nBBoxes <= 1) oblock%ADT%nLeaves = oblock%ADT%nLeaves + 1
        allocate (oblock%ADT%ADTree(oblock%ADT%nLeaves))
 
        ! -------------------------------------------------------------------
 
        ! Now continue copying out the integer values
        do i = 1, nhexa
            do j = 1, 8
                isize = isize + 1
                oblock%hexaConn(j, i) = oblock%iBuffer(isize)
            end do
        end do
 
        do k = 0, ke + 1
            do j = 0, je + 1
                do i = 0, ie + 1
                    isize = isize + 1
                    oblock%globalCell(i, j, k) = oblock%iBuffer(isize)
                end do
            end do
        end do
 
        do k = 1, kl
            do j = 1, jl
                do i = 1, il
                    isize = isize + 1
                    oblock%nearWall(i, j, k) = oblock%iBuffer(isize)
                end do
            end do
        end do
 
        do k = 1, ke
            do j = 1, je
                do i = 1, ie
                    isize = isize + 1
                    oblock%invalidDonor(i, j, k) = oblock%iBuffer(isize)
                end do
            end do
        end do
 
        do i = 1, oblock%ADT%nLeaves
            isize = isize + 1
            oblock%ADT%ADTree(i)%children(1) = oblock%iBuffer(isize)
            isize = isize + 1
            oblock%ADT%ADTree(i)%children(2) = oblock%iBuffer(isize)
        end do
 
        ! Now copy out the real values
        rsize = 0
 
        do i = 1, ie * je * ke
            rsize = rsize + 1
            oblock%qualDonor(1, i) = oblock%rBuffer(rsize)
        end do
 
        do j = 1, ie * je * ke
            do i = 1, 3
                rsize = rsize + 1
                oblock%xADT(i, j) = oblock%rBuffer(rsize)
            end do
        end do
 
        do i = 1, oblock%ADT%nBboxes
            oblock%ADT%xBBox(:, i) = oblock%rBuffer(rsize + 1:rsize + 6)
            rsize = rsize + 6
        end do
 
        do i = 1, oblock%ADT%nLeaves
            oblock%ADT%ADTree(i)%xMin(:) = oblock%rBuffer(rsize + 1:rsize + 6)
            rsize = rsize + 6
 
            oblock%ADT%ADTree(i)%xMax(:) = oblock%rBuffer(rsize + 1:rsize + 6)
            rsize = rsize + 6
        end do
 
        rsize = rsize + 1
        oblock%minVol = oblock%rBuffer(rsize)
 
        ! Flag this oBlock as being allocated:
        oblock%allocated = .true.
        deallocate (oblock%iBuffer, oblock%rBuffer)
 
    end subroutine unpackoblock
 
    subroutine getofringebuffersizes(il, jl, kl, iSize, rSize)
 
        ! Subroutine to get the required buffer sizes. This one is pretty
        ! easy, but we use a routine to make it look the same as for the
        ! oBlock.
 
        use constants
        implicit none
 
        ! Input/OUtput
        integer(kind=intType), intent(in) :: il, jl, kl
        integer(kind=intType), intent(out) :: rSize, iSize
 
        ! Working
        integer(kind=intType) :: mm
 
        ! All arrays have the same size
        mm = (il - 1) * (jl - 1) * (kl - 1) ! nx*ny*nz
 
        ! Initializeation
        isize = mm * 3 + 5 ! We need wallInd, isWall, myIndex plus 5 for the sizes
        rsize = mm * 6 ! Need to send x and xSeed (3 each)
 
    end subroutine getofringebuffersizes
 
    subroutine packofringe(oFringe)
 
        use constants
        use oversetdata, only: oversetfringe
 
        implicit none
 
        ! Pack up the search coordines in this oFringe into its own buffer
        ! so we are ready to send it.
 
        ! Input/Output Parameters
        type(oversetfringe), intent(inout) :: oFringe
 
        ! Working paramters
        integer(kind=intType) :: rSize, iSize, mm, i, ii
 
        ! If the buffer is already allocated, the block is packed and there
        ! is nothing to do
        if (allocated(ofringe%rBuffer)) then
            return
        end if
 
        call getofringebuffersizes(ofringe%il, ofringe%jl, ofringe%kl, &
                                   isize, rsize)
 
        ! Allocate the buffers
        allocate (ofringe%rBuffer(rsize), ofringe%iBuffer(isize))
 
        mm = (ofringe%nx) * (ofringe%ny) * (ofringe%nz)
 
        ofringe%iBuffer(1) = ofringe%il
        ofringe%iBuffer(2) = ofringe%jl
        ofringe%iBuffer(3) = ofringe%kl
        ofringe%iBuffer(4) = ofringe%cluster
        ofringe%iBuffer(5) = ofringe%block
        ii = 5
 
        ! Copy the integers. Just wallInd and isWall
        do i = 1, mm
 
            ii = ii + 1
            ofringe%iBuffer(ii) = ofringe%wallInd(i)
 
            ii = ii + 1
            ofringe%iBuffer(ii) = ofringe%isWall(i)
 
            ii = ii + 1
            ofringe%iBuffer(ii) = ofringe%fringeIntBuffer(5, i) ! myIndex
 
        end do
 
        ! Copy the reals. Reset the buffer here.
        ii = 0
        do i = 1, mm
            ofringe%rBuffer(ii + 1) = ofringe%x(1, i)
            ofringe%rBuffer(ii + 2) = ofringe%x(2, i)
            ofringe%rBuffer(ii + 3) = ofringe%x(3, i)
            ofringe%rBuffer(ii + 4) = ofringe%xSeed(1, i)
            ofringe%rBuffer(ii + 5) = ofringe%xSeed(2, i)
            ofringe%rBuffer(ii + 6) = ofringe%xSeed(3, i)
            ii = ii + 6
        end do
 
    end subroutine packofringe
 
    subroutine unpackofringe(oFringe)
 
        use constants
        use oversetdata, only: oversetfringe
        implicit none
 
        ! Pack up the search coordines in this oFringe into its own buffer
        ! so we are ready to send it.
 
        ! Input/Output Parameters
        type(oversetfringe), intent(inout) :: oFringe
 
        ! Working paramters
        integer(kind=intType) :: rSize, iSize, idom, i, ii, mm
 
        ! Set the sizes of this oFringe
        ofringe%il = ofringe%iBuffer(1)
        ofringe%jl = ofringe%iBuffer(2)
        ofringe%kl = ofringe%iBuffer(3)
        ofringe%nx = ofringe%il - 1
        ofringe%ny = ofringe%jl - 1
        ofringe%nz = ofringe%kl - 1
        ofringe%cluster = ofringe%iBuffer(4)
        ofringe%block = ofringe%ibuffer(5)
 
        mm = (ofringe%nx) * (ofringe%ny) * (ofringe%nz)
 
        allocate ( &
            ofringe%x(3, mm), &
            ofringe%xSeed(3, mm), &
            ofringe%wallInd(mm), &
            ofringe%isWall(mm))
 
        ! Assume each cell will get just one donor. It's just a guess, it
        ! will be expanded if necessary so the exact value doesn't matter.
        allocate (ofringe%fringeIntBuffer(5, mm), ofringe%fringeRealBuffer(4, mm))
        ofringe%nDonor = 0
 
        ii = 5 ! Already copied out the sizes
 
        ! Copy out integers
        do i = 1, mm
            ii = ii + 1
            ofringe%wallInd(i) = ofringe%iBuffer(ii)
 
            ii = ii + 1
            ofringe%isWall(i) = ofringe%iBuffer(ii)
 
            ii = ii + 1
            ofringe%fringeIntBuffer(5, i) = ofringe%iBuffer(ii)
 
            ofringe%fringeIntBuffer(4, i) = ofringe%block
        end do
 
        ! Copy the reals. Reset the counter ii counter here.
        ii = 0
        do i = 1, mm
            ofringe%x(1, i) = ofringe%rBuffer(ii + 1)
            ofringe%x(2, i) = ofringe%rBuffer(ii + 2)
            ofringe%x(3, i) = ofringe%rBuffer(ii + 3)
 
            ofringe%xSeed(1, i) = ofringe%rBuffer(ii + 4)
            ofringe%xSeed(2, i) = ofringe%rBuffer(ii + 5)
            ofringe%xSeed(3, i) = ofringe%rBuffer(ii + 6)
 
            ii = ii + 6
        end do
 
        ! Flag this oFringe as being allocated:
        ofringe%allocated = .true.
        deallocate (ofringe%rBuffer, ofringe%iBuffer)
 
    end subroutine unpackofringe
 
    subroutine getwallsize(famList, nNodes, nCells, dualMesh)
        ! Simple helper routine to return the number of wall nodes and cells
        ! for the block pointed to by blockPointers.
 
        use constants
        use blockpointers, only: bctype, nbocos, bcdata
        use sorting, only: faminlist
        implicit none
 
        ! Input
        integer(kind=intType), intent(in), dimension(:) :: famList
        logical :: dualMesh
 
        ! Output
        integer(kind=intType), intent(out) :: nNodes, nCells
 
        ! Working:
        integer(kind=intType) :: mm, iBeg, iEnd, jBeg, jEnd
 
        ! Figure out the size the wall is going to be.
        nnodes = 0
        ncells = 0
        do mm = 1, nbocos
            faminclude: if (faminlist(bcdata(mm)%famID, famlist)) then
                if (dualmesh) then
                    jbeg = bcdata(mm)%jnBeg - 1; jend = bcdata(mm)%jnEnd
                    ibeg = bcdata(mm)%inBeg - 1; iend = bcdata(mm)%inEnd
                else
                    jbeg = bcdata(mm)%jnBeg; jend = bcdata(mm)%jnEnd
                    ibeg = bcdata(mm)%inBeg; iend = bcdata(mm)%inEnd
                end if
 
                nnodes = nnodes + (iend - ibeg + 1) * (jend - jbeg + 1)
                ncells = ncells + (iend - ibeg) * (jend - jbeg)
            end if faminclude
        end do
 
    end subroutine getwallsize
 
    subroutine getosurfbuffersizes(famList, il, jl, kl, iSize, rSize, dualMesh)
 
        ! Subroutine to get the required buffer sizes. This one is pretty
        ! easy, but we use a routine to make it look the same as for hte
        ! oBlock. Note that these bufer sizes are over-estimates. They are
        ! the maximum possible amount of data to send.
 
        use constants
        implicit none
 
        ! Input/OUtput
        integer(kind=intType), intent(in), dimension(:) :: famList
        integer(kind=intType), intent(in) :: il, jl, kl
        logical, intent(in) :: dualMesh
        integer(kind=intType), intent(out) :: rSize, iSize
 
        ! Working
        integer(kind=intType) :: mm, nNodes, nCells, nBBox, nLeaves
 
        ! Initalization
        isize = 3 ! For the block sizes
        isize = isize + 4 ! For the maxCells/nCells/nNodes variables
        rsize = 0
 
        call getwallsize(famlist, nnodes, ncells, dualmesh)
 
        ! Note that nCells here is the maximum number size. This will result
        ! in a slight overestimate of the buffer size. This is ok.
 
        if (nnodes > 0) then
            ! Count up the integers we want to send:
 
            isize = isize + ncells * 4 ! This is for the connectivity
 
            isize = isize + ncells   ! This is for the iblank array
 
            isize = isize + ncells   ! This is for the cellPtr array
 
            ! Number of boxes in the ADT is the same as the number of elements
            nbbox = ncells
            nleaves = nbbox - 1 ! See ADT/adtBuild.f90
 
            isize = isize + nleaves * 2 ! Two ints for the children in each leaf
 
            ! Count up the reals we ned to send:
            rsize = rsize + 3 * nnodes ! surface coordinates
 
            rsize = rsize + nnodes ! surface delta
 
            rsize = rsize + nbbox * 6 ! Cell bounding boxes
 
            rsize = rsize + nleaves * 12 ! Bounding boxes for leaves
        end if
    end subroutine getosurfbuffersizes
 
    subroutine packosurf(famList, oSurf, dualMesh)
 
        use constants
        use oversetdata, only: oversetwall
 
        implicit none
 
        ! Pack up the search coordines in this oSurf into its own buffer
        ! so we are ready to send it.
 
        ! Input/Output Parameters
        integer(kind=intType), intent(in), dimension(:) :: famList
        type(oversetwall), intent(inout) :: oSurf
        logical, intent(in) :: dualMesh
        ! Working paramters
        integer(kind=intType) :: rSize, iSize, mm, i, j, nNodes, nCells
 
        call getosurfbuffersizes(famlist, osurf%il, osurf%kl, osurf%kl, isize, rsize, dualmesh)
 
        ! Allocate the buffers
        allocate (osurf%rBuffer(rsize), osurf%iBuffer(isize))
 
        osurf%iBuffer(1) = osurf%il
        osurf%iBuffer(2) = osurf%jl
        osurf%iBuffer(3) = osurf%kl
        osurf%iBuffer(4) = osurf%nNodes
        osurf%iBuffer(5) = osurf%nCells
        osurf%iBuffer(6) = osurf%maxCells
        osurf%iBuffer(7) = osurf%cluster
 
        if (osurf%nNodes > 0) then
            isize = 7
            do j = 1, osurf%nCells
                do i = 1, 4
                    isize = isize + 1
                    osurf%iBuffer(isize) = osurf%conn(i, j)
                end do
            end do
 
            do i = 1, osurf%maxCells
                isize = isize + 1
                osurf%iBuffer(isize) = osurf%iBlank(i)
            end do
 
            do i = 1, osurf%nCells
                isize = isize + 1
                osurf%iBuffer(isize) = osurf%cellPtr(i)
            end do
 
            do i = 1, osurf%ADT%nLeaves
                isize = isize + 1
                osurf%iBuffer(isize) = osurf%ADT%ADTree(i)%children(1)
                isize = isize + 1
                osurf%iBuffer(isize) = osurf%ADT%ADTree(i)%children(2)
            end do
 
            ! Done with the integer values, do the real ones
            rsize = 0
 
            do i = 1, osurf%nNodes
                do j = 1, 3
                    rsize = rsize + 1
                    osurf%rBuffer(rsize) = osurf%x(j, i)
                end do
            end do
 
            do i = 1, osurf%nNodes
                rsize = rsize + 1
                osurf%rBuffer(rsize) = osurf%delta(i)
            end do
 
            do i = 1, osurf%ADT%nBboxes
                osurf%rBuffer(rsize + 1:rsize + 6) = osurf%ADT%xBBox(:, i)
                rsize = rsize + 6
            end do
 
            do i = 1, osurf%ADT%nLeaves
                osurf%rBuffer(rsize + 1:rsize + 6) = osurf%ADT%ADTree(i)%xMin(:)
                rsize = rsize + 6
 
                osurf%rBuffer(rsize + 1:rsize + 6) = osurf%ADT%ADTree(i)%xMax(:)
                rsize = rsize + 6
            end do
        end if
    end subroutine packosurf
 
    subroutine unpackosurf(oSurf)
 
        use constants
        use oversetdata, only: oversetwall
        use kdtree2_module, only: kdtree2_create
        implicit none
 
        ! Input/Output Parameters
        type(oversetwall), intent(inout) :: oSurf
 
        ! Working paramters
        integer(kind=intType) :: rSize, iSize, idom, i, j, k, n, iNode
 
        ! Set the sizes of this oSurf
        osurf%il = osurf%iBuffer(1)
        osurf%jl = osurf%iBuffer(2)
        osurf%kl = osurf%iBuffer(3)
 
        osurf%nNodes = osurf%iBuffer(4)
        osurf%nCells = osurf%iBuffer(5)
        osurf%maxCells = osurf%iBuffer(6)
        osurf%cluster = osurf%iBuffer(7)
 
        isize = 7
        rsize = 0
 
        ! Allocate the arrays now that we know the sizes
        allocate (osurf%x(3, osurf%nNodes))
        allocate (osurf%delta(osurf%nNodes))
        allocate (osurf%conn(4, osurf%nCells))
        allocate (osurf%iBlank(osurf%maxCells))
        allocate (osurf%cellPtr(osurf%nCells))
        allocate (osurf%nte(4, osurf%nNodes))
        ! Once we know the sizes, allocate all the arrays in the
        ! ADTree. Since we are not going to call the *actual* build routine
        ! for the ADT, we need to set all the information ourselves. This
        ! essentially does the same thing as buildSerialHex.
        osurf%ADT%adtType = adtsurfaceadt
        osurf%ADT%nNodes = osurf%nNodes
        osurf%ADT%nTetra = 0
        osurf%ADT%nPyra = 0
        osurf%ADT%nPrisms = 0
        osurf%ADT%nTria = 0
        osurf%ADT%nQuads = osurf%nCells
        osurf%ADT%coor => osurf%x
        osurf%ADT%quadsConn => osurf%conn
        nullify (osurf%ADT%triaConn)
        osurf%ADT%nBBoxes = osurf%nCells
        allocate (osurf%ADT%xBBOX(6, osurf%nCells))
        allocate (osurf%ADT%elementType(osurf%nCells))
        allocate (osurf%ADT%elementID(osurf%nCells))
        osurf%ADT%comm = mpi_comm_self
        osurf%ADT%nProcs = 1
        osurf%ADT%myID = 0
 
        ! All hexas
        osurf%ADT%elementType = adtquadrilateral
 
        do i = 1, osurf%nCells
            osurf%ADT%elementID(i) = i
        end do
 
        osurf%ADT%nLeaves = osurf%ADT%nBBoxes - 1
        if (osurf%ADT%nBBoxes <= 1) osurf%ADT%nLeaves = osurf%ADT%nLeaves + 1
 
        allocate (osurf%ADT%ADTree(osurf%ADT%nLeaves))
 
        ! Now continue copying out the values if necessary:
        if (osurf%nNodes > 0) then
            do j = 1, osurf%nCells
                do i = 1, 4
                    isize = isize + 1
                    osurf%conn(i, j) = osurf%iBuffer(isize)
                end do
            end do
 
            do i = 1, osurf%maxCells
                isize = isize + 1
                osurf%iBlank(i) = osurf%iBuffer(isize)
            end do
 
            do i = 1, osurf%nCells
                isize = isize + 1
                osurf%cellPtr(i) = osurf%iBuffer(isize)
            end do
 
            do i = 1, osurf%ADT%nLeaves
                isize = isize + 1
                osurf%ADT%ADTree(i)%children(1) = osurf%iBuffer(isize)
                isize = isize + 1
                osurf%ADT%ADTree(i)%children(2) = osurf%iBuffer(isize)
            end do
 
            ! Done with the integer values, do the real ones
            rsize = 0
 
            do i = 1, osurf%nNodes
                do j = 1, 3
                    rsize = rsize + 1
                    osurf%x(j, i) = osurf%rBuffer(rsize)
                end do
            end do
 
            do i = 1, osurf%nNodes
                rsize = rsize + 1
                osurf%delta(i) = osurf%rBuffer(rsize)
            end do
 
            do i = 1, osurf%ADT%nBboxes
                osurf%ADT%xBBox(:, i) = osurf%rBuffer(rsize + 1:rsize + 6)
                rsize = rsize + 6
            end do
 
            do i = 1, osurf%ADT%nLeaves
                osurf%ADT%ADTree(i)%xMin(:) = osurf%rBuffer(rsize + 1:rsize + 6)
                rsize = rsize + 6
 
                osurf%ADT%ADTree(i)%xMax(:) = osurf%rBuffer(rsize + 1:rsize + 6)
                rsize = rsize + 6
            end do
        end if
 
        ! Build the KDTree
        if (osurf%nNodes > 0) then
            osurf%tree => kdtree2_create(osurf%x)
        end if
 
        ! Build the inverse of the connectivity, the nodeToElem array.
        osurf%nte = 0
        do i = 1, osurf%nCells
            do j = 1, 4
                n = osurf%conn(j, i)
                inner: do k = 1, 4
                    if (osurf%nte(k, n) == 0) then
                        osurf%nte(k, n) = i
                        exit inner
                    end if
                end do inner
            end do
        end do
 
        ! Flag this oSurf as being allocated:
        osurf%allocated = .true.
        deallocate (osurf%rBuffer, osurf%iBuffer)
    end subroutine unpackosurf
end module oversetpackingroutines