scale_meshutil_cubedsphere2d Module Reference

module FElib / Mesh / utility for 2D cubed-sphere mesh More...

Functions/Subroutines
subroutine, public	meshutilcubedsphere2d_buildglobalmap (panelid_table, pi_table, pj_table, tileid_map, tilefaceid_map, tilepanelid_map, ntile)
subroutine, public	meshutilcubedsphere2d_modifyconnectivity (tilepanelid_map, tileid_map, tilefaceid_map, panelid_table, pi_table, pj_table, nex, ney, ntile, nface)
subroutine, public	meshutilcubedsphere2d_getpanelconnectivity (panel_connectivity, face_connectivity)
subroutine, public	meshutilcubedsphere2d_getpanelid (panelid, lon, lat, np)

Detailed Description

module FElib / Mesh / utility for 2D cubed-sphere mesh

Description

A module useful for generating 2D cubed-sphere mesh

Author

Yuta Kawai, Team SCALE

Function/Subroutine Documentation

meshutilcubedsphere2d_buildglobalmap()

subroutine, public scale_meshutil_cubedsphere2d::meshutilcubedsphere2d_buildglobalmap	(	integer, dimension(ntile), intent(out)	panelid_table,
		integer, dimension(ntile), intent(out)	pi_table,
		integer, dimension(ntile), intent(out)	pj_table,
		integer, dimension(4,ntile), intent(out)	tileid_map,
		integer, dimension(4,ntile), intent(out)	tilefaceid_map,
		integer, dimension(4,ntile), intent(out)	tilepanelid_map,
		integer, intent(in)	ntile )

Definition at line 48 of file scale_meshutil_cubedsphere2d.F90.

    
    use scale_meshutil_2d, only: &
      meshutil2d_genconnectivity
    implicit none
 
    integer, intent(in) :: Ntile
    integer, intent(out) :: panelID_table(Ntile)
    integer, intent(out) :: pi_table(Ntile)
    integer, intent(out) :: pj_table(Ntile)
    integer, intent(out) :: tileID_map(4,Ntile)
    integer, intent(out) :: tileFaceID_map(4,Ntile)
    integer, intent(out) :: tilePanelID_map(4,Ntile)
 
    integer :: NtilePerPanel
    integer :: NeX, NeY, NvX, NvY
    integer, allocatable :: nodesID_2d(:,:,:)
    integer, allocatable :: EToV(:,:)
    integer, allocatable :: EToE(:,:)
    integer, allocatable :: EToF(:,:)
    integer :: i, j, k, f
    integer :: panelID
    integer :: tileID, tileID_R
    integer :: counter
    !-----------------------------------------------------------------------------
 
    ntileperpanel = ntile / 6
    ney = int( sqrt(dble(ntileperpanel)) )
    nex = ntileperpanel/ney
    nvx = nex + 1
    nvy = ney + 1
    allocate( nodesid_2d(nvx,nvy,6) )
    allocate( etov(ntile,4), etoe(ntile,4), etof(ntile,4) )
 
    counter = 0
    do panelid = 1, 6
    do j = 1, nvy
    do i = 1, nvx
      counter = counter + 1
      nodesid_2d(i,j,panelid) = counter
    end do
    end do
    end do
 
    !----
 
    tileid = 0
    do panelid = 1, 6
    do j = 1, ney
    do i = 1, nex
      tileid = tileid + 1
      panelid_table(tileid) = panelid
      pi_table(tileid) = i; pj_table(tileid) = j;
      etov(tileid,:) = (/ nodesid_2d(i,j  ,panelid), nodesid_2d(i+1,j  ,panelid),   &
                          nodesid_2d(i,j+1,panelid), nodesid_2d(i+1,j+1,panelid)   /)
    end do
    end do
    end do
 
    call meshutil2d_genconnectivity( etoe, etof, &
      etov, ntile, 4 )
    tileid_map(:,:) = transpose(etoe)
    tilefaceid_map(:,:) = transpose(etof)
    
    do tileid=1, ntile
    do f=1, 4
      tileid_r = tileid_map(f,tileid)
      tilepanelid_map(f,tileid) = panelid_table(tileid_r)
    end do
    end do
 
    call meshutilcubedsphere2d_modifyconnectivity( &
      tilepanelid_map, tileid_map, tilefaceid_map,          & ! (inout)
      panelid_table, pi_table, pj_table, nex, ney, ntile, 4 ) ! (in)
 
    return

References scale_meshutil_2d::meshutil2d_genconnectivity(), and meshutilcubedsphere2d_modifyconnectivity().

Referenced by scale_mesh_cubedspheredom2d::meshcubedspheredom2d_setuplocaldom().

meshutilcubedsphere2d_modifyconnectivity()

subroutine, public scale_meshutil_cubedsphere2d::meshutilcubedsphere2d_modifyconnectivity	(	integer, dimension(nface,ntile), intent(out)	tilepanelid_map,
		integer, dimension(nface,ntile), intent(out)	tileid_map,
		integer, dimension(nface,ntile), intent(out)	tilefaceid_map,
		integer, dimension(ntile), intent(in)	panelid_table,
		integer, dimension(ntile), intent(in)	pi_table,
		integer, dimension(ntile), intent(in)	pj_table,
		integer, intent(in)	nex,
		integer, intent(in)	ney,
		integer, intent(in)	ntile,
		integer, intent(in)	nface )

Definition at line 131 of file scale_meshutil_cubedsphere2d.F90.

 
    integer, intent(in) :: Ntile
    integer, intent(in) :: Nface
    integer, intent(out) :: tileID_map(Nface,Ntile)
    integer, intent(out) :: tileFaceID_map(Nface,Ntile)
    integer, intent(out) :: tilePanelID_map(Nface,Ntile)
    integer, intent(in) :: panelID_table(Ntile)
    integer, intent(in) :: pi_table(Ntile)
    integer, intent(in) :: pj_table(Ntile)
    integer, intent(in) :: NeX, NeY
 
    integer :: panel_connectivity(4,6)
    integer :: face_connectivity (4,6)
 
    integer :: tileID
    integer :: panelID
    integer :: f
    integer :: pi_, pj_    
    !-----------------------------------------------------------------------------
 
    call meshutilcubedsphere2d_getpanelconnectivity( &
      panel_connectivity, face_connectivity )
 
    
    do tileid=1, ntile
      panelid = panelid_table(tileid)
 
      do f=1, 4
        if ( tilefaceid_map(f,tileid) /= f ) cycle ! Does the face correspond the boundary of panel of cubed sphere?
 
        pi_ = pi_table(tileid)          
        pj_ = pj_table(tileid)  
        
        select case( panelid )
        case ( 1 )
          if ( mod(f,2) == 0 ) then ! West / East
            if ( pi_table(tileid) == 1   ) pi_ = nex
            if ( pi_table(tileid) == nex ) pi_ = 1
          else                      ! North / South
            if ( pj_table(tileid) == 1   ) pj_ = ney
            if ( pj_table(tileid) == ney ) pj_ = 1  
          end if
        case ( 2 )
          if ( mod(f,2) == 0 ) then ! West / East
            if ( pi_table(tileid) == 1   ) pi_ = nex
            if ( pi_table(tileid) == nex ) pi_ = 1
          else                      ! North / South
            if ( pj_table(tileid) == 1   ) then
              pi_ = nex; pj_ = ney - pi_table(tileid) + 1
            end if
            if ( pj_table(tileid) == ney ) then
              pi_ = nex ; pj_ = pi_table(tileid)
            end if
          end if
        case ( 3 )
          if ( mod(f,2) == 0 ) then ! West / East
            if ( pi_table(tileid) == 1   ) pi_ = nex
            if ( pi_table(tileid) == nex ) pi_ = 1
          else                      ! North / South
            if ( pj_table(tileid) == 1   ) then
              pi_ = nex - pi_table(tileid) + 1; pj_ = 1
            end if
            if ( pj_table(tileid) == ney ) then
              pi_ = nex - pi_table(tileid) + 1; pj_ = ney
            end if
          end if
        case ( 4 )
          if ( mod(f,2) == 0 ) then ! West / East
            if ( pi_table(tileid) == 1   ) pi_ = nex
            if ( pi_table(tileid) == nex ) pi_ = 1
          else                      ! North / South 
            if ( pj_table(tileid) == 1   ) then
              pi_ = 1; pj_ = pi_table(tileid)
            end if
            if ( pj_table(tileid) == ney ) then
              pi_ = 1; pj_ = ney - pi_table(tileid) + 1; 
            end if
          end if          
        case ( 5 )
          pj_ = ney
          if ( mod(f,2) == 0 ) then 
            if ( pi_table(tileid) == 1   ) pi_ = ney - pj_table(tileid) + 1  ! West            
            if ( pi_table(tileid) == nex ) pi_ = pj_table(tileid)            ! East
          else
            if ( pj_table(tileid) == 1   ) pi_ = pi_table(tileid)            ! South            
            if ( pj_table(tileid) == ney ) pi_ = nex - pi_table(tileid) + 1  ! North
          end if
        case ( 6 )
          pj_ = 1
          if ( mod(f,2) == 0 ) then 
            if ( pi_table(tileid) == 1   ) pi_ = pj_table(tileid)            ! West            
            if ( pi_table(tileid) == nex ) pi_ = ney - pj_table(tileid) + 1  ! East
          else
            if ( pj_table(tileid) == 1   ) pi_ = nex - pi_table(tileid) + 1  ! South            
            if ( pj_table(tileid) == ney ) pi_ = pi_table(tileid)            ! North
          end if
        end select
 
        tilepanelid_map(f,tileid) = panel_connectivity(f,panelid)
        tileid_map(f,tileid) = pi_ + (pj_ - 1) * nex + (tilepanelid_map(f,tileid) - 1) * nex * ney
        tilefaceid_map(f,tileid) = face_connectivity(f,panelid)
      end do ! loop for f
    end do ! loop for tile
 
    ! if (PRC_myrank==0) then
    !   write(*,*) " MeshUtilCubedSphere2D_modifyConnectivity"
    !   do tileID=1, Ntile
    !     write(*,'(a,i3,a,2i3)') "tileID=", tileID, ":", pi_table(tileID), pj_table(tileID)
    !     write(*,'(a,6i4)') "map_tile:", tileID_map(:,tileID)
    !     write(*,'(a,6i4)') "map_panel:", tilePanelID_map(:,tileID)
    !     write(*,'(a,6i4)') "mac_face:", tileFaceID_map(:,tileID)
    !   end do
    ! end if
 
    return

References meshutilcubedsphere2d_getpanelconnectivity().

Referenced by meshutilcubedsphere2d_buildglobalmap(), and scale_meshutil_cubedsphere3d::meshutilcubedsphere3d_buildglobalmap().

meshutilcubedsphere2d_getpanelconnectivity()

subroutine, public scale_meshutil_cubedsphere2d::meshutilcubedsphere2d_getpanelconnectivity	(	integer, dimension(4,6), intent(out)	panel_connectivity,
		integer, dimension(4,6), intent(out)	face_connectivity )

Definition at line 251 of file scale_meshutil_cubedsphere2d.F90.

 
    implicit none
 
    integer, intent(out) :: panel_connectivity(4,6)
    integer, intent(out) :: face_connectivity(4,6)
 
    integer :: n
    integer :: zonal_panelID_list(0:5)
 
    zonal_panelid_list(:) = (/ 4, 1, 2, 3, 4, 1/)
    do n=1, 4
      panel_connectivity(1,n) = 6
      if (zonal_panelid_list(4-n) > 2) then
        face_connectivity(1,n)  = +zonal_panelid_list(4-n)
      else
        face_connectivity(1,n) =  -zonal_panelid_list(4-n)
      end if
 
      panel_connectivity(2,n) = zonal_panelid_list(n+1)
      face_connectivity(2,n)  = 4
 
      panel_connectivity(3,n) = 5
      face_connectivity(3,n)  = n
      if (n > 2) then
        face_connectivity(3,n)  = -n
      else
        face_connectivity(3,n) = n
      end if
 
      panel_connectivity(4,n) = zonal_panelid_list(n-1)
      face_connectivity(4,n)  = 2
    end do
 
    panel_connectivity(:,5) = (/ 1, 2, 3, 4 /)
    face_connectivity(:,5) = (/ 3, 3, -3, -3 /)
    panel_connectivity(:,6) = (/ 3, 2, 1, 4 /)
    face_connectivity(:,6) = (/ -1, -1, 1, 1 /)
 

Referenced by meshutilcubedsphere2d_modifyconnectivity().

meshutilcubedsphere2d_getpanelid()

subroutine, public scale_meshutil_cubedsphere2d::meshutilcubedsphere2d_getpanelid	(	integer, dimension(np), intent(out)	panelid,
		real(rp), dimension(np), intent(in)	lon,
		real(rp), dimension(np), intent(in)	lat,
		integer, intent(in)	np )

Definition at line 293 of file scale_meshutil_cubedsphere2d.F90.

    use scale_cubedsphere_coord_cnv, only: &
      cubedspherecoordcnv_lonlat2cspos
    implicit none
 
    integer, intent(in) :: Np
    integer, intent(out) :: panelID(Np)
    real(RP), intent(in) :: lon(Np)
    real(RP), intent(in) :: lat(Np)
 
    integer :: p
    integer :: pnl
    real(RP) :: alph(Np), beta(Np)
    real(RP) :: lon_(Np), lat_(Np)
 
    real(RP), parameter :: EPS = 1.0e-64_rp
    !------------------------------------------
 
    !$omp parallel do
    do p=1, np
      if ( abs(cos(lon(p))) < eps ) then
        lon_(p) = lon(p) + eps
      else
        lon_(p) = lon(p)
      end if
      if ( abs( lat(p) - 0.5_rp * pi ) < eps ) then
        lat_(p) = lat(p) - sign(eps, lat(p))
      else
        lat_(p) = lat(p)
      end if
    end do
 
    panelid(:) = -1
    do pnl=1, 6
      call cubedspherecoordcnv_lonlat2cspos( pnl, lon_, lat_, np, &
        alph, beta )
    
      select case(pnl)
      case (5)
        where ( lat(:) > 0.0_rp .and. abs(alph(:)) <= 0.25_rp * pi .and. abs(beta(:)) <= 0.25_rp * pi  )
          panelid(:) = pnl
        end where
      case (6)
        where ( lat(:) < 0.0_rp .and. abs(alph(:)) <= 0.25_rp * pi .and. abs(beta(:)) <= 0.25_rp * pi  )
          panelid(:) = pnl
        end where
      case default 
        where ( abs(alph(:)) <= 0.25_rp * pi .and. abs(beta(:)) <= 0.25_rp * pi  )
          panelid(:) = pnl
        end where
      end select     
    end do
 
    do p=1, np
      if (panelid(p) <  0) then
        log_error("MeshUtilCubedSphere2D_getPanelID",*) 'Fail to search a panel ID of cubed sphere grid!'
        write(*,*) "p=", p, ": (lon,lat)=", lon(p), lat(p), "(alpha,beta)=", alph(p), beta(p) 
        call prc_abort
      end if 
    end do
 
    return

References scale_cubedsphere_coord_cnv::cubedspherecoordcnv_lonlat2cspos().