scale_mesh_base.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
#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
  ! 
 
  type, public :: meshdiminfo
    character(len=H_SHORT) :: name
    character(len=H_MID) :: desc
    character(len=H_SHORT) :: unit
    logical :: positive_down
  end type meshdiminfo
 
  type, abstract, public :: meshbase
    integer :: local_mesh_num
    integer :: prc_num
    integer :: local_mesh_num_global
    
    integer, allocatable :: tileid_globalmap(:,:)
    integer, allocatable :: tilefaceid_globalmap(:,:)
    integer, allocatable :: tilepanelid_globalmap(:,:)
    integer, allocatable :: tileid_global2localmap(:)
    integer, allocatable :: prcrank_globalmap(:)
 
    class(elementbase), pointer :: refelem
    type(meshdiminfo), allocatable :: diminfo(:)
 
    real(rp) :: dom_vol
 
    logical :: isgenerated
  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, meshbase_final
  public :: meshbase_setgeometricinfo
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
 
contains
!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
    class(elementbase), intent(in), target :: refelem
    integer, intent(in) :: nlocalmeshperprc
    integer, intent(in) :: nsidetile
    integer, intent(in), optional :: 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) )
    
    this%isGenerated = .false.
 
    return
  end subroutine meshbase_init
 
!OCL SERIAL
  subroutine meshbase_final( this )
    implicit none
    class(meshbase), intent(inout) :: this
    !-----------------------------------------------------------------------------
  
    if ( allocated(this%tileID_globalMap) ) then
      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 )
    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%Ne) )
    allocate( mesh%G_ij(refelem%Np,mesh%Ne, ndim,ndim) )
    allocate( mesh%GIJ (refelem%Np,mesh%Ne, ndim,ndim) )
 
    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