scale_localmesh_base.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module FElib / Mesh / Local, Base
!!
!! @par Description
!!      Base module to manage meshes for element-based methods
!!
!! @author Yuta Kawai, Team SCALE
!<
#include "scaleFElib.h"
module scale_localmesh_base
 
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_io
 
  use scale_element_base, only: elementbase
 
  !-----------------------------------------------------------------------------
  implicit none
  private
 
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedure
  ! 
  
  !> Derived type to manage a local computational domain (base type)
  type, public :: localmeshbase
    integer :: ne  !< Number of finite elements in the local computational domain
    integer :: nes !< Start index of finite element indices in the local computational domain
    integer :: nee !< End index of finite element indices in the local computational domain
    integer :: nea !< Total number of finite elements (Ne + halo buffer)
    integer :: nv  !< Number of vertices in the local computational domain
 
    class(elementbase), pointer :: refelem !< Pointer to an object with a reference element
    
    real(rp), allocatable :: pos_ev(:,:)      !< Position of vertices in finite elements in the local computational domain
    real(rp), allocatable :: pos_en(:,:,:)    !< Position of nodes in finite elements in the local computational domain
    real(rp), allocatable :: normal_fn(:,:,:)
 
    real(rp), allocatable :: sj(:,:)
    real(rp), allocatable :: j(:,:)
    
    real(rp), allocatable :: escale(:,:,:,:)
    real(rp), allocatable :: fscale(:,:)
 
    integer, allocatable :: etov(:,:)
    integer, allocatable :: etoe(:,:)
    integer, allocatable :: etof(:,:)
    integer, allocatable :: vmapm(:,:)
    integer, allocatable :: vmapp(:,:)
    integer, allocatable :: mapm(:,:)
    integer, allocatable :: mapp(:,:)
 
    integer, allocatable :: bctype(:,:)
    integer, allocatable :: mapb(:)
    integer, allocatable :: vmapb(:)
    ! integer, allocatable :: MapD(:)
    ! integer, allocatable :: VMapD(:)
    ! integer, allocatable :: MapN(:)
    ! integer, allocatable :: VMapN(:)
 
    integer :: tileid
    integer :: panelid
    integer :: prc_myrank
    integer :: lcdomid      !< ID of local computational mesh
  
    real(rp), allocatable :: g_ij(:,:,:,:) !< The covariant component of metric tensor with horizontal general curvilinear coordinate 
    real(rp), allocatable :: gij(:,:,:,:)  !< The contravariant component of metric tensor with horizontal general curvilinear coordinate 
    real(rp), allocatable :: gsqrt(:,:)    !< The Jacobian of 3D transformation in the computational coordinate (=GsqrtH * GsqrtV)
  end type localmeshbase
 
  public :: localmeshbase_init
  public :: localmeshbase_final
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  integer, public, parameter :: bctype_interior  = 0
  integer, public, parameter :: bctype_undefbc   = 1
  integer, public, parameter :: bctype_periodic  = 2
  integer, public, parameter :: bctype_dirchlet  = 3
  integer, public, parameter :: bctype_neuman    = 4
  integer, public, parameter :: bctype_shoreline = 5
 
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
 
contains
!> Setup an object to manage a local computational mesh
  subroutine localmeshbase_init( this, lcdomID, refElem, ndim, myrank )
    
    use scale_prc, only: prc_myrank
    implicit none
 
    class(localmeshbase), intent(inout) :: this
    integer, intent(in) :: lcdomid
    class(elementbase), intent(in), target :: refelem
    integer, intent(in) :: ndim
    integer, intent(in), optional :: myrank
    !-----------------------------------------------------------------------------
 
    this%lcdomID = lcdomid
    this%refElem => refelem
 
    if (present(myrank)) then
      this%PRC_myrank = myrank
    else
      this%PRC_myrank = prc_myrank
    end if
 
    return
  end subroutine localmeshbase_init
 
!> Finalize an object to manage a local computational mesh
  subroutine localmeshbase_final( this, is_generated )
    implicit none
    
    class(localmeshbase), intent(inout) :: this
    logical, intent(in) :: is_generated
    !-----------------------------------------------------------------------------
 
    if ( is_generated ) then
      deallocate( this%pos_ev, this%pos_en, this%normal_fn )
      deallocate( this%sJ, this%J )
 
      deallocate( this%Escale, this%Fscale )
 
      deallocate( this%EToV, this%EToE, this%EToF )
 
      if ( allocated(this%VMapM) ) then
        deallocate( this%VMapM, this%VMapP, this%MapM, this%MapP )
      end if
      if ( allocated(this%VMapB) ) then
        deallocate( this%BCType )
        deallocate( this%VMapB, this%MapB )
      end if
      if ( allocated(this%G_ij) ) then
        deallocate( this%G_ij, this%GIJ )
        deallocate( this%Gsqrt )
      end if
    end if
    
    return
  end subroutine localmeshbase_final
end module scale_localmesh_base