module FElib / Mesh / Base 3D More...

Data Types
type	meshbase3d

interface	meshbase3d_generate

Functions/Subroutines
subroutine, public	meshbase3d_init (this, refelem, nlocalmeshperprc, nsidetile, nproc, myrank)

subroutine, public	meshbase3d_final (this)

subroutine, public	meshbase3d_setgeometricinfo (lcmesh, coord_conv, calc_normal)

Variables
integer, public	meshbase3d_dimtype_num = 8

integer, public	meshbase3d_dimtypeid_x = 1

integer, public	meshbase3d_dimtypeid_y = 2

integer, public	meshbase3d_dimtypeid_z = 3

integer, public	meshbase3d_dimtypeid_zt = 4

integer, public	meshbase3d_dimtypeid_xy = 5

integer, public	meshbase3d_dimtypeid_xyt = 6

integer, public	meshbase3d_dimtypeid_xyz = 7

integer, public	meshbase3d_dimtypeid_xyzt = 8

Detailed Description

module FElib / Mesh / Base 3D

Description: Base module to manage 3D meshes for element-based methods

Author: Yuta Kawai, Team SCALE

Function/Subroutine Documentation

◆ meshbase3d_init()

subroutine, public scale_mesh_base3d::meshbase3d_init	(	class(meshbase3d), intent(inout)	this,
		class(elementbase3d), intent(in), target	refelem,
		integer, intent(in)	nlocalmeshperprc,
		integer, intent(in)	nsidetile,
		integer, intent(in), optional	nproc,
		integer, intent(in), optional	myrank )

Definition at line 100 of file scale_mesh_base3d.F90.

    
    implicit none
 
    class(MeshBase3D), intent(inout) :: this
    class(ElementBase3D), intent(in), target :: refElem
    integer, intent(in) :: NLocalMeshPerPrc
    integer, intent(in) :: NsideTile
    integer, intent(in), optional :: nproc
    integer, intent(in), optional :: myrank
 
    integer :: n
    !-----------------------------------------------------------------------------
    
    this%refElem3D => refelem
    call meshbase_init( this,            &
      meshbase3d_dimtype_num, refelem,   &
      nlocalmeshperprc, nsidetile, nproc )
 
    allocate( this%lcmesh_list(this%LOCAL_MESH_NUM) )
    do n=1, this%LOCAL_MESH_NUM
      call localmesh3d_init( this%lcmesh_list(n), n, refelem, myrank )
    end do
 
    call this%SetDimInfo( meshbase3d_dimtypeid_x, "x", "m", "X-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_y, "y", "m", "Y-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_z, "z", "m", "Z-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_zt, "z", "m", "Z-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_xy, "xy", "m", "XY-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_xyt, "xyt", "m", "XY-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_xyz, "xyz", "m", "XYZ-coordinate" )
    call this%SetDimInfo( meshbase3d_dimtypeid_xyzt, "xyzt", "m", "XYZ-coordinate" )
 
    return

References scale_localmesh_3d::localmesh3d_init(), meshbase3d_dimtype_num, meshbase3d_dimtypeid_x, meshbase3d_dimtypeid_xy, meshbase3d_dimtypeid_xyt, meshbase3d_dimtypeid_xyz, meshbase3d_dimtypeid_xyzt, meshbase3d_dimtypeid_y, meshbase3d_dimtypeid_z, meshbase3d_dimtypeid_zt, and scale_mesh_base::meshbase_init().

Referenced by scale_mesh_base3d::meshbase3d_generate::meshbase3d_generate(), scale_mesh_cubedom3d::meshcubedom3d_init(), and scale_mesh_cubedspheredom3d::meshcubedspheredom3d_init().

◆ meshbase3d_final()

subroutine, public scale_mesh_base3d::meshbase3d_final ( class(meshbase3d), intent(inout) this )

Definition at line 139 of file scale_mesh_base3d.F90.

    implicit none
    class(MeshBase3D), intent(inout) :: this
 
    integer :: n
    !-----------------------------------------------------------------------------
    
    if ( allocated ( this%lcmesh_list ) ) then 
      do n=1, this%LOCAL_MESH_NUM
        call localmesh3d_final( this%lcmesh_list(n), this%isGenerated )
      end do
  
      deallocate( this%lcmesh_list )
    end if
    
    call meshbase_final(this)
 
    return

References scale_localmesh_3d::localmesh3d_final(), and scale_mesh_base::meshbase_final().

Referenced by scale_mesh_base3d::meshbase3d_generate::meshbase3d_generate(), scale_mesh_cubedom3d::meshcubedom3d_init(), and scale_mesh_cubedspheredom3d::meshcubedspheredom3d_init().

◆ meshbase3d_setgeometricinfo()

subroutine, public scale_mesh_base3d::meshbase3d_setgeometricinfo	(	type(localmesh3d), intent(inout)	lcmesh,
		external subroutine(real(rp), dimension(elem%np), intent(out) x, real(rp), dimension(elem%np), intent(out) y, real(rp), dimension(elem%np), intent(out) z, real(rp), dimension(elem%np), intent(out) xx, real(rp), dimension(elem%np), intent(out) xy, real(rp), dimension(elem%np), intent(out) xz, real(rp), dimension(elem%np), intent(out) yx, real(rp), dimension(elem%np), intent(out) yy, real(rp), dimension(elem%np), intent(out) yz, real(rp), dimension(elem%np), intent(out) zx, real(rp), dimension(elem%np), intent(out) zy, real(rp), dimension(elem%np), intent(out) zz, real(rp), dimension(elem%nv), intent(in) vx, real(rp), dimension(elem%nv), intent(in) vy, real(rp), dimension(elem%nv), intent(in) vz, type(elementbase3d), intent(in) elem)	coord_conv,
		external subroutine(real(rp), dimension(elem%nfptot,3), intent(out) normal_fn, real(rp), dimension(elem%nfptot,3,3), intent(in) escale_f, integer, dimension(elem%nfp_h,elem%nfaces_h), intent(in) fid_h, integer, dimension(elem%nfp_v,elem%nfaces_v), intent(in) fid_v, type(elementbase3d), intent(in) elem)	calc_normal )

Definition at line 174 of file scale_mesh_base3d.F90.

    implicit none
    
    type(LocalMesh3D), intent(inout) :: lcmesh
    interface
      subroutine coord_conv( x, y, z, xX, xY, xZ, yX, yY, yZ, zX, zY, zZ, &
        vx, vy, vz, elem )
        import elementbase3d
        import rp
        type(ElementBase3D), intent(in) :: elem
        real(RP), intent(out) :: x(elem%Np), y(elem%Np), z(elem%Np)
        real(RP), intent(out) :: xX(elem%Np), xY(elem%Np), xZ(elem%Np)
        real(RP), intent(out) :: yX(elem%Np), yY(elem%Np), yZ(elem%Np)
        real(RP), intent(out) :: zX(elem%Np), zY(elem%Np), zZ(elem%Np)
        real(RP), intent(in) :: vx(elem%Nv), vy(elem%Nv), vz(elem%Nv)        
      end subroutine coord_conv
      subroutine calc_normal( normal_fn, &
        Escale_f, fid_h, fid_v, elem )
        import elementbase3d
        import rp
        type(ElementBase3D), intent(in) :: elem
        real(RP), intent(out) :: normal_fn(elem%NfpTot,3)
        integer, intent(in) :: fid_h(elem%Nfp_h,elem%Nfaces_h)
        integer, intent(in) :: fid_v(elem%Nfp_v,elem%Nfaces_v)        
        real(RP), intent(in) :: Escale_f(elem%NfpTot,3,3)
      end subroutine calc_normal
    end interface
 
    class(ElementBase3D), pointer :: refElem
    integer :: ke, ke2D
    integer :: f
    integer :: i, j
    integer :: d
    integer :: fmask(lcmesh%refElem%NfpTot)
    integer :: fid_h(lcmesh%refElem3D%Nfp_h,lcmesh%refElem3D%Nfaces_h)
    integer :: fid_v(lcmesh%refElem3D%Nfp_v,lcmesh%refElem3D%Nfaces_v)
    real(RP) :: Escale_f(lcmesh%refElem%NfpTot,3,3)
 
    integer :: node_ids(lcmesh%refElem%Nv)
    real(RP) :: vx(lcmesh%refElem%Nv), vy(lcmesh%refElem%Nv), vz(lcmesh%refElem%Nv)    
    real(RP) :: xX(lcmesh%refElem%Np), xY(lcmesh%refElem%Np), xZ(lcmesh%refElem%Np)
    real(RP) :: yX(lcmesh%refElem%Np), yY(lcmesh%refElem%Np), yZ(lcmesh%refElem%Np)
    real(RP) :: zX(lcmesh%refElem%Np), zY(lcmesh%refElem%Np), zZ(lcmesh%refElem%Np)
    !-----------------------------------------------------------------------------
 
    refelem => lcmesh%refElem3D
 
    allocate( lcmesh%pos_en(refelem%Np,lcmesh%Ne,3) )
    !allocate( mesh%fx(refElem%Nfaces*refElem%Nfp,mesh%Ne) )
    !allocate( mesh%fy(refElem%Nfaces*refElem%Nfp,mesh%Ne) )
    allocate( lcmesh%normal_fn(refelem%NfpTot,lcmesh%Ne,3) )
    allocate( lcmesh%sJ(refelem%NfpTot,lcmesh%Ne) )
    allocate( lcmesh%J(refelem%Np,lcmesh%Ne) )
    allocate( lcmesh%Fscale(refelem%NfpTot,lcmesh%Ne) )
    allocate( lcmesh%Escale(refelem%Np,lcmesh%Ne,3,3) )
    allocate( lcmesh%zS(refelem%Np,lcmesh%Ne) )
    allocate( lcmesh%Sz(refelem%Np,lcmesh%Ne) )
    allocate( lcmesh%Gsqrt(refelem%Np,lcmesh%NeA) )
    allocate( lcmesh%GsqrtH(refelem%Nfp_v,lcmesh%Ne2D) )
    allocate( lcmesh%G_ij(refelem%Nfp_v,lcmesh%Ne2D,2,2) )
    allocate( lcmesh%GIJ (refelem%Nfp_v,lcmesh%Ne2D,2,2) )
    allocate( lcmesh%GI3 (refelem%Np,lcmesh%NeA,2) )
    allocate( lcmesh%zlev(refelem%Np,lcmesh%Ne) )
    allocate( lcmesh%gam(refelem%Np,lcmesh%NeA) )
 
    allocate( lcmesh%lon2D(refelem%Nfp_v,lcmesh%Ne2D) )
    allocate( lcmesh%lat2D(refelem%Nfp_v,lcmesh%Ne2D) )
    
    do f=1, refelem%Nfaces_h
    do i=1, refelem%Nfp_h
      fid_h(i,f) = i + (f-1)*refelem%Nfp_h
      fmask(fid_h(i,f)) = refelem%Fmask_h(i,f)
    end do
    end do
    do f=1, refelem%Nfaces_v
    do i=1, refelem%Nfp_v
      fid_v(i,f) = i + refelem%Nfaces_h*refelem%Nfp_h + (f-1)*refelem%Nfp_v
      fmask(fid_v(i,f)) = refelem%Fmask_v(i,f)
    end do
    end do
 
    !$omp parallel private( ke, node_ids, vx, vy, vz,    &
    !$omp xX, xY, xZ, yX, yY, yZ, zX, zY, zZ,            &
    !$omp i, j, Escale_f, d                              )
 
    !$omp do
    do ke=1, lcmesh%Ne
      node_ids(:) = lcmesh%EToV(ke,:)
      vx(:) = lcmesh%pos_ev(node_ids(:),1)
      vy(:) = lcmesh%pos_ev(node_ids(:),2)
      vz(:) = lcmesh%pos_ev(node_ids(:),3)
      call coord_conv( &
        lcmesh%pos_en(:,ke,1), lcmesh%pos_en(:,ke,2), lcmesh%pos_en(:,ke,3), & ! (out)
        xx, xy, xz, yx, yy, yz, zx, zy, zz,                                  & ! (out)
        vx, vy, vz, refelem )                                                  ! (in)
 
      lcmesh%J(:,ke) =   xx(:)*(yy(:)*zz(:) - zy(:)*yz) & 
                       - yx(:)*(xy(:)*zz(:) - zy(:)*xz) &
                       + zx(:)*(xy(:)*yz(:) - yy(:)*xz)
 
      lcmesh%Escale(:,ke,1,1) =   (yy(:)*zz(:) - zy(:)*yz(:))/lcmesh%J(:,ke)
      lcmesh%Escale(:,ke,1,2) = - (xy(:)*zz(:) - zy(:)*xz(:))/lcmesh%J(:,ke)
      lcmesh%Escale(:,ke,1,3) =   (xy(:)*yz(:) - yy(:)*xz(:))/lcmesh%J(:,ke)
      
      lcmesh%Escale(:,ke,2,1) = - (yx(:)*zz(:) - zx(:)*yz(:))/lcmesh%J(:,ke)
      lcmesh%Escale(:,ke,2,2) =   (xx(:)*zz(:) - zx(:)*xz(:))/lcmesh%J(:,ke)
      lcmesh%Escale(:,ke,2,3) = - (xx(:)*yz(:) - yx(:)*xz(:))/lcmesh%J(:,ke)
      
      lcmesh%Escale(:,ke,3,1) =   (yx(:)*zy(:) - zx(:)*yy(:))/lcmesh%J(:,ke)
      lcmesh%Escale(:,ke,3,2) = - (xx(:)*zy(:) - zx(:)*xy(:))/lcmesh%J(:,ke)
      lcmesh%Escale(:,ke,3,3) =   (xx(:)*yy(:) - yx(:)*xy(:))/lcmesh%J(:,ke)
      
      !* Face
 
      !
      !mesh%fx(:,n) = mesh%x(fmask(:),n)
      !mesh%fy(:,n) = mesh%y(fmask(:),n)
 
      ! Calculate normal vectors
      do j=1, 3
      do i=1, 3
        escale_f(:,i,j) = lcmesh%Escale(fmask(:),ke,i,j)
      end do
      end do
      call calc_normal( lcmesh%normal_fn(:,ke,:), & ! (out)
         escale_f, fid_h, fid_v, refelem )          ! (in)
 
      lcmesh%sJ(:,ke) = sqrt( &
        lcmesh%normal_fn(:,ke,1)**2 + lcmesh%normal_fn(:,ke,2)**2 + lcmesh%normal_fn(:,ke,3)**2 )
      do d=1, 3
        lcmesh%normal_fn(:,ke,d) = lcmesh%normal_fn(:,ke,d)/lcmesh%sJ(:,ke)
      end do
      lcmesh%sJ(:,ke) = lcmesh%sJ(:,ke)*lcmesh%J(fmask(:),ke)
 
      lcmesh%Fscale(:,ke) = lcmesh%sJ(:,ke)/lcmesh%J(fmask(:),ke)
      lcmesh%zlev(:,ke) = lcmesh%pos_en(:,ke,3)
    end do
    !$omp end do
 
    !$omp workshare
    lcmesh%Gsqrt (:,:)   = 1.0_rp
    lcmesh%GsqrtH(:,:)   = 1.0_rp
    lcmesh%GIJ   (:,:,1,1) = 1.0_rp
    lcmesh%GIJ   (:,:,2,1) = 0.0_rp
    lcmesh%GIJ   (:,:,1,2) = 0.0_rp
    lcmesh%GIJ   (:,:,2,2) = 1.0_rp
    lcmesh%G_ij  (:,:,1,1) = 1.0_rp
    lcmesh%G_ij  (:,:,2,1) = 0.0_rp
    lcmesh%G_ij  (:,:,1,2) = 0.0_rp
    lcmesh%G_ij  (:,:,2,2) = 1.0_rp
    lcmesh%GI3   (:,:,1)   = 0.0_rp
    lcmesh%GI3   (:,:,2)   = 0.0_rp
    lcmesh%gam   (:,:)     = 1.0_rp
    !$omp end workshare
 
    !$omp end parallel
 
    return