scale_mesh_base.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module FElib / Mesh / Base
!!
!! @par Description
!!      Base module to manage meshes for element-based methods
!!
!! @author Yuta Kawai, Team SCALE
!<
#include "scaleFElib.h"
module scale_mesh_base
 
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision 
  use scale_io 
  
  use scale_element_base, only: elementbase
  use scale_localmesh_base, only: localmeshbase
 
  !-----------------------------------------------------------------------------
  implicit none
  private
 
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedure
  ! 
 
  !> Derived type to manage an information of a mesh dimension
  type, public :: meshdiminfo
    character(len=H_SHORT) :: name !< Name of the dimension
    character(len=H_MID) :: desc   !< Description of the dimension
    character(len=H_SHORT) :: unit !< Unit of the dimension
    logical :: positive_down       !< Flag whether the positive direction is downward (e.g., for vertical dimension)
  end type meshdiminfo
 
  !> Base type to manage a computational mesh
  type, abstract, public :: meshbase
    integer :: local_mesh_num         !< Number of local meshes in each MPI process
    integer :: prc_num                !< Number of MPI processes
    integer :: local_mesh_num_global  !< Total number of local meshes across all MPI processes
    
    integer, allocatable :: tileid_globalmap(:,:)
    integer, allocatable :: tilefaceid_globalmap(:,:)
    integer, allocatable :: tilepanelid_globalmap(:,:)
    integer, allocatable :: tileid_global2localmap(:)
    integer, allocatable :: prcrank_globalmap(:)
 
    class(elementbase), pointer :: refelem       !< Pointer to an object with a reference element
    type(meshdiminfo), allocatable :: diminfo(:) !< Array of information for each dimension
 
    real(rp) :: dom_vol        !< Total volume of the computational domain
 
    logical :: isgenerated     !< Flag whether the mesh is generated
  contains
    procedure(meshbase_get_localmesh), deferred :: getlocalmesh
    procedure :: setdiminfo => meshbase_setdiminfo
  end type meshbase
 
  interface 
    subroutine meshbase_get_localmesh( this, id, ptr_lcmesh )
      import meshbase
      import localmeshbase
      class(meshbase), target, intent(in) :: this
      integer, intent(in) :: id
      class(localmeshbase), pointer, intent(out) :: ptr_lcmesh
    end subroutine meshbase_get_localmesh
  end interface
 
  public :: meshbase_init
  public :: meshbase_final
  public :: meshbase_setgeometricinfo
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
 
contains
  !> Initialize an object to manage a computational mesh
!OCL SERIAL
  subroutine meshbase_init( this, &
     ndimtype, refElem, NLocalMeshPerPrc, NsideTile, &
     nprocs                                          )
    
    use scale_prc, only: &
      prc_nprocs
    implicit none
 
    class(meshbase), intent(inout) :: this
    integer, intent(in) :: ndimtype                      !< Number of DIMTYPE
    class(elementbase), intent(in), target :: refelem    !< An object with a reference element
    integer, intent(in) :: nlocalmeshperprc              !< Number of local meshes in each MPI process
    integer, intent(in) :: nsidetile                     !< Number of side tiles
    integer, intent(in), optional :: nprocs              !< MPI processes (if not provided, it will be set to the value from PRC_nprocs)
 
    integer :: n
    !-----------------------------------------------------------------------------
    
    if ( present(nprocs) ) then
      this%PRC_NUM = nprocs
    else
      this%PRC_NUM = prc_nprocs
    end if
 
    this%LOCAL_MESH_NUM        = nlocalmeshperprc
    this%LOCAL_MESH_NUM_global = this%PRC_NUM * this%LOCAL_MESH_NUM
 
    this%refElem => refelem
        
    allocate( this%tileID_globalMap(nsidetile, this%LOCAL_MESH_NUM_global) )
    allocate( this%tileFaceID_globalMap(nsidetile, this%LOCAL_MESH_NUM_global) )
    allocate( this%tilePanelID_globalMap(nsidetile, this%LOCAL_MESH_NUM_global) )
    allocate( this%tileID_global2localMap(this%LOCAL_MESH_NUM_global) )
    allocate( this%PRCRank_globalMap(this%LOCAL_MESH_NUM_global) )
    allocate( this%dimInfo(ndimtype) )
    !$acc enter data create(this%tileID_globalMap, this%tileFaceID_globalMap, this%tilePanelID_globalMap, &
    !$acc   this%tileID_global2localMap, this%PRCRank_globalMap, this%dimInfo )
    
    this%isGenerated = .false.
 
    return
  end subroutine meshbase_init
 
  !> Finalize an object to manage a computational mesh
!OCL SERIAL
  subroutine meshbase_final( this )
    implicit none
    class(meshbase), intent(inout) :: this
    !-----------------------------------------------------------------------------
  
    if ( allocated(this%tileID_globalMap) ) then
      !$acc exit data delete(this%tileID_globalMap, this%tileFaceID_globalMap, this%tilePanelID_globalMap, &
      !$acc   this%tileID_global2localMap, this%PRCRank_globalMap, this%dimInfo)
      deallocate( this%tileID_globalMap )
      deallocate( this%tileFaceID_globalMap )
      deallocate( this%tilePanelID_globalMap )
      deallocate( this%tileID_global2localMap )
      deallocate( this%PRCRank_globalMap )
      deallocate( this%dimInfo )
    end if
    return
  end subroutine meshbase_final
 
!OCL SERIAL
  subroutine meshbase_setgeometricinfo( mesh, ndim )
    use scale_element_base, only: elementbase3d
    use scale_localmesh_3d, only: localmesh3d
    implicit none
    
    class(localmeshbase), intent(inout) :: mesh
    integer, intent(in) :: ndim
 
    class(elementbase), pointer :: refelem
    !-----------------------------------------------------------------------------
 
    refelem => mesh%refElem
 
    allocate( mesh%pos_en(refelem%Np,mesh%Ne,ndim) )
    !allocate( mesh%fx(refElem%Nfaces*refElem%Nfp,mesh%Ne) )
    !allocate( mesh%fy(refElem%Nfaces*refElem%Nfp,mesh%Ne) )
    allocate( mesh%normal_fn(refelem%NfpTot,mesh%Ne,ndim) )
    allocate( mesh%sJ(refelem%NfpTot,mesh%Ne) )
    allocate( mesh%J(refelem%Np,mesh%Ne) )
    allocate( mesh%Fscale(refelem%NfpTot,mesh%Ne) )
    allocate( mesh%Escale(refelem%Np,mesh%Ne,ndim,ndim) )
    allocate( mesh%Gsqrt(refelem%Np,mesh%NeA) )
    !$acc enter data create(mesh%pos_en, mesh%normal_fn, mesh%sJ, mesh%J, &
    !$acc   mesh%Fscale, mesh%Escale, mesh%Gsqrt)
 
    return
  end subroutine meshbase_setgeometricinfo
 
!OCL SERIAL
  subroutine meshbase_setdiminfo( this, &
      dimID, name, unit, desc, positive_down )
    implicit none
    class(meshbase), intent(inout) :: this
    integer, intent(in) :: dimid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: unit
    character(len=*), intent(in) :: desc
    logical, intent(in), optional :: positive_down
 
    !-----------------------------------------------
 
    this%dimInfo(dimid)%name = name
    this%dimInfo(dimid)%unit = unit
    this%dimInfo(dimid)%desc = desc
    if ( present(positive_down) ) then
      this%dimInfo(dimid)%positive_down = positive_down      
    else
      this%dimInfo(dimid)%positive_down = .false.      
    end if
 
    return
  end subroutine meshbase_setdiminfo
 
end module scale_mesh_base