adtData.F90

Go to the documentation of this file.

module adtdata
!
!      Module, which defines the derived data types and the arrays to
!      store multiple ADT's. An array is chosen to store multiple
!      ATD's rather than a linked list, because this is more
!      convenient during the search. When the ADT's are built there
!      is some additional work due to reallocation. However this is
!      negligible due to the usage of pointers.
!
    use constants, only: inttype, realtype, adtelementtype, alwaysrealtype
    implicit none
    save
!
!      Define the functions needed for the sorting of the derived
!      data types to be private, i.e. they can only be accessed
!      within this module.
!
    public
    private :: adtbboxtargettypelessequal
    private :: adtbboxtargettypeless
    private :: adttypeassign
!
!      Definition of the derived data type store a leaf of an ADT.
!      The ADT itself is an array of these leaves.
!
    type adtleaftype
 
        ! children(2): Children of the parent. If negative it means that
        !              it is a terminal leaf and the absolute values
        !              indicate the bounding box id's. Note that it is
        !              allowed that 1 child is negative and the other
        !              positive.
        ! xMin(6):     The minimum coordinates of the leaf.
        ! xMax(6):     The maximum coordinates of the leaf.
 
        integer(kind=intType), dimension(2) :: children
        real(kind=realtype), dimension(6) :: xmin, xmax
 
    end type adtleaftype
!
!      The definition of adtBBoxTargetType, which stores the data of
!      a possible bounding box which minimizes the distances to the
!      given coordinate.
!
    type adtbboxtargettype
 
        ! ID:       The id of the bounding box in the list.
        ! posDist2: the possible minimum distance squared to the active
        !           coordinate.
 
        integer(kind=intType) :: id
        real(kind=realtype) :: posdist2
 
    end type adtbboxtargettype
 
    ! Interfaces for the extension of the operators <= and <.
    ! These are needed for the sorting of BBoxTargetType. Note
    ! that the = operator does not need to be defined, because
    ! BBoxTargetType only contains primitive types.
 
    interface operator(<=)
        module procedure adtbboxtargettypelessequal
    end interface
 
    interface operator(<)
        module procedure adtbboxtargettypeless
    end interface
!
!      Definition of the derived data type to store an ADT.
!
    type adttype
 
        ! comm:   The communicator of this ADT.
        ! nProcs: The number of processors which participate in this
        !         ADT.
        ! myID:   My processor ID in the processor group of comm.
 
        integer :: comm, nprocs, myid
 
        ! adtType:  Type of ADT. Possibilities are adtSurfaceADT and
        !           adtVolumeADT.
        ! adtID:    The given ID of the ADT.
        ! isActive: Whether or not the ADT is active. If not, this
        !           entry could be used during a reallocation.
 
        integer :: adttype
        character(len=64) :: adtid
        logical :: isactive
 
        ! nNodes:  Number of local nodes in the given grid.
        ! nTria:   Number of local triangles in the given grid.
        ! nQuads:  Idem for the quadrilaterals.
        ! nTetra:  Idem for the tetrahedra.
        ! nPyra:   Idem for the pyramids.
        ! nPrisms: Idem for the prisms.
        ! nHexa:   Idem for the hexahedra.
 
        integer(kind=intType) :: nnodes, ntria, nquads
        integer(kind=intType) :: ntetra, npyra, nprisms, nhexa
 
        ! coor(3,nNodes): Nodal coordinates of the local grid.
        !                 To save memory this pointer is not
        !                 allocated, but set to the data given.
        real(kind=realtype), dimension(:, :), pointer :: coor
 
        ! triaConn(3,nTria):     Local connectivity of the triangles.
        !                        To save memory this pointer is not
        !                        allocated, but set to the data given.
        ! quadsConn(4,nQuads):   Idem for the quadrilaterals.
        ! tetraConn(4,nTetra):   Idem for the tetrahedra.
        ! pyraConn(5,nPyra):     Idem for the pyramids.
        ! prismsConn(6,nPrisms): Idem for the prisms.
        ! hexaConn(8,nHexa):     Idem for the hexahedra.
 
        integer(kind=intType), dimension(:, :), pointer :: triaconn
        integer(kind=intType), dimension(:, :), pointer :: quadsconn
        integer(kind=intType), dimension(:, :), pointer :: tetraconn
        integer(kind=intType), dimension(:, :), pointer :: pyraconn
        integer(kind=intType), dimension(:, :), pointer :: prismsconn
        integer(kind=intType), dimension(:, :), pointer :: hexaconn
 
        ! nRootLeaves:        Number of non-empty root leaves.
        !                     This number is of course less than or
        !                     equal to nProcs.
        ! myEntryInRootProcs: If the local tree is not empty, this
        !                     contains the entry in rootLeavesProcs.
        ! rootLeavesProcs(:): The corresponding processor ID's.
        ! rootBBoxes(3,2,:):  The 3D bounding boxes of the non-empty
        !                     root leaves.
 
        integer :: nrootleaves, myentryinrootprocs
        integer, dimension(:), pointer :: rootleavesprocs
        real(kind=realtype), dimension(:, :, :), pointer :: rootbboxes
 
        ! nBBoxes:              Number of bounding boxes stored in
        !                       the ADT.
        ! elementType(nBBoxes): The corresponding element type of the
        !                       bounding box.
        ! elementID(nBBoxes):   The corresponding entry in the element
        !                       connectivity of the bounding box.
        ! xBBox(6,nBBoxes):     The coordinates of the bounding boxes
        !                       of the elements stored in the ADT.
 
        integer(kind=intType) :: nbboxes
 
        integer(kind=adtElementType), dimension(:), pointer :: elementtype
        integer(kind=intType), dimension(:), pointer :: elementid
        real(kind=realtype), dimension(:, :), pointer :: xbbox
 
        ! nLeaves:         Number of present in the ADT. Due to the
        !                  variable splitting the tree is optimally
        !                  balanced and therefore nLeaves = nBBoxes -1.
        ! ADTree(nLeaves): The alternating digital tree.
 
        integer(kind=intType) :: nleaves
        type(adtleaftype), dimension(:), pointer :: adtree
 
    end type adttype
 
    ! Interface for the extension of the operator =.
 
    interface assignment(=)
        module procedure adttypeassign
    end interface
!
!                Variables stored in this module.
!
    ! ADTs(:): The array to store the different ADT's.
 
    type(adttype), dimension(:), allocatable, target :: adts
 
    ! nProcRecv:      Number of processors from which I receive
    !                 coordinates that must be searched in my ADT.
    ! nCoorMax:       Maximum number of coordinates that can be
    !                 searched during an interpolation round.
    ! nRounds:        Number of rounds in the outer loop of the search
    !                 algorithm.
    ! nLocalInterpol: Number of local coordinates that must be
    !                 searched in the locally stored tree.
 
    integer :: nprocrecv
 
    integer(kind=intType) :: ncoormax
    integer(kind=intType) :: nrounds
    integer(kind=intType) :: nlocalinterpol
 
    ! procRecv:         Processor ID's from which I will receive
    !                   coordinates.
    ! nCoorProcRecv:    Number of coordinates I must receive from the
    !                   processors which send coordinates to me.
    ! nCoorPerRootLeaf: Number of coordinates, which may be searched
    !                   in each of the local ADT's. The array is in
    !                   cumulative storage format.
    ! mCoorPerRootLeaf: Idem, but its contents changes during the
    !                   iterative algorithm.
    ! coorPerRootLeaf:  The ID's of the corresponding coordinates.
 
    integer, dimension(:), allocatable :: procrecv
 
    integer(kind=intType), dimension(:), allocatable :: ncoorprocrecv
    integer(kind=intType), dimension(:), allocatable :: ncoorperrootleaf
    integer(kind=intType), dimension(:), allocatable :: mcoorperrootleaf
    integer(kind=intType), dimension(:), allocatable :: coorperrootleaf
 
    !=================================================================
 
contains
 
    !===============================================================
 
    logical function adtbboxtargettypelessequal(g1, g2)
!
!        This function returns .true. if g1 <= g2. The comparison is
!        firstly based on the possible minimum distance such that the
!        most likely candidates are treated first. In case of ties
!        the boundary box ID is considered.
!        Function intent(in) arguments.
!        ------------------------------
!        g1, g2: The two instances of the derived datatype that most
!                be compared.
!
        implicit none
!
!       Function arguments.
!
        type(adtbboxtargettype), intent(in) :: g1, g2
 
        ! Compare the possible minimum distances.
 
        if (g1%posDist2 < g2%posDist2) then
            adtbboxtargettypelessequal = .true.
            return
        else if (g1%posDist2 > g2%posDist2) then
            adtbboxtargettypelessequal = .false.
            return
        end if
 
        ! Compare the bounding box ID's.
 
        if (g1%ID < g2%ID) then
            adtbboxtargettypelessequal = .true.
            return
        else if (g1%ID > g2%ID) then
            adtbboxtargettypelessequal = .false.
            return
        end if
 
        ! g1 and g2 are identical. Return .true.
 
        adtbboxtargettypelessequal = .true.
 
    end function adtbboxtargettypelessequal
 
    !===============================================================
 
    logical function adtbboxtargettypeless(g1, g2)
!
!        This function returns .true. if g1 < g2. The comparison is
!        firstly based on the possible minimum distance such that the
!        most likely candidates are treated first. In case of ties
!        the boundary box ID is considered.
!        Function intent(in) arguments.
!        ------------------------------
!        g1, g2: The two instances of the derived datatype that most
!                be compared.
!
        implicit none
!
!       Function arguments.
!
        type(adtbboxtargettype), intent(in) :: g1, g2
 
        ! Compare the possible minimum distances.
 
        if (g1%posDist2 < g2%posDist2) then
            adtbboxtargettypeless = .true.
            return
        else if (g1%posDist2 > g2%posDist2) then
            adtbboxtargettypeless = .false.
            return
        end if
 
        ! Compare the bounding box ID's.
 
        if (g1%ID < g2%ID) then
            adtbboxtargettypeless = .true.
            return
        else if (g1%ID > g2%ID) then
            adtbboxtargettypeless = .false.
            return
        end if
 
        ! g1 and g2 are identical. Return .false.
 
        adtbboxtargettypeless = .false.
 
    end function adtbboxtargettypeless
 
    !===============================================================
 
    subroutine adttypeassign(g1, g2)
!
!        This subroutine defines the generic assignment operator for
!        the derived datatype adtType. The contents of g1 is copied
!        into g2, where pointers just point to the other pointers,
!        i.e. no additional allocation takes place.
!        Subroutine intent(in) arguments.
!        --------------------------------
!        g2: Entity whose data should be copied.
!        Subroutine intent(out) arguments.
!        ---------------------------------
!        g1: Entity whose data should be assigned.
!
        implicit none
!
!       Subroutine arguments.
!
        type(adttype), intent(in) :: g2
        type(adttype), intent(out) :: g1
 
        g1%comm = g2%comm
        g1%nProcs = g2%nProcs
        g1%myID = g2%myID
        g1%adtType = g2%adtType
        g1%adtID = g2%adtID
        g1%isActive = g2%isActive
 
        g1%nNodes = g2%nNodes
        g1%nTria = g2%nTria
        g1%nQuads = g2%nQuads
        g1%nTetra = g2%nTetra
        g1%nPyra = g2%nPyra
        g1%nPrisms = g2%nPrisms
        g1%nHexa = g2%nHexa
 
        g1%coor => g2%coor
        g1%triaConn => g2%triaConn
        g1%quadsConn => g2%quadsConn
        g1%tetraConn => g2%tetraConn
        g1%pyraConn => g2%pyraConn
        g1%prismsConn => g2%prismsConn
        g1%hexaConn => g2%hexaConn
 
        g1%nRootLeaves = g2%nRootLeaves
        g1%myEntryInRootProcs = g2%myEntryInRootProcs
        g1%rootLeavesProcs => g2%rootLeavesProcs
        g1%rootBBoxes => g2%rootBBoxes
 
        g1%nBBoxes = g2%nBBoxes
        g1%elementType => g2%elementType
        g1%elementID => g2%elementID
        g1%xBBox => g2%xBBox
 
        g1%nLeaves = g2%nLeaves
        g1%ADTree => g2%ADTree
 
    end subroutine adttypeassign
 
end module adtdata