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

Data Types
type	meshbase1d
	Derived type to manage a computational mesh (base type for 1D domain) More...
interface	meshbase1d_generate

Functions/Subroutines
subroutine, public	meshbase1d_init (this, neg, dom_xmin, dom_xmax, refelem, nlocalmeshperprc, nprocs, myrank, fx)
	Initialize an object to manage a 1D computational mesh.
subroutine, public	meshbase1d_final (this)
	Finalize an object to manage a 1D computational mesh.
subroutine, public	meshbase1d_setgeometricinfo (lcmesh)
subroutine, public	meshbase1d_assigndomid (this, tileid_table, panelid_table, pi_table)
subroutine, public	meshbase1d_setuplocaldom (lcmesh, tileid, panelid, i, nprc, dom_xmin, dom_xmax, ne, fx)

Variables
integer, public	meshbase1d_dimtype_num = 2
integer, public	meshbase1d_dimtypeid_x = 1
integer, public	meshbase1d_dimtypeid_xt = 2

Detailed Description

module FElib / Mesh / Base 1D

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

Author: Yuta Kawai, Team SCALE

Function/Subroutine Documentation

◆ meshbase1d_init()

subroutine, public scale_mesh_base1d::meshbase1d_init	(	class(meshbase1d), intent(inout)	this,
		integer, intent(in)	neg,
		real(rp), intent(in)	dom_xmin,
		real(rp), intent(in)	dom_xmax,
		class(elementbase1d), intent(in), target	refelem,
		integer, intent(in)	nlocalmeshperprc,
		integer, intent(in), optional	nprocs,
		integer, intent(in), optional	myrank,
		real(rp), dimension(neg+1), intent(in), optional	fx )

Initialize an object to manage a 1D computational mesh.

Definition at line 84 of file scale_mesh_base1d.F90.

    
    implicit none
 
    class(MeshBase1D), intent(inout) :: this
    integer, intent(in) :: NeG
    real(RP), intent(in) :: dom_xmin
    real(RP), intent(in) :: dom_xmax   
    class(ElementBase1D), intent(in), target :: refElem
    integer, intent(in) :: NLocalMeshPerPrc
    integer, intent(in), optional :: nprocs
    integer, intent(in), optional :: myrank
    real(RP), intent(in), optional :: FX(NeG+1)
 
    integer :: n
    integer :: k
    real(RP) :: dx
    !-----------------------------------------------------------------------------
    
    this%NeG = neg
 
    this%xmin_gl       = dom_xmin
    this%xmax_gl       = dom_xmax
 
    !- Fx
    allocate( this%FX(neg+1) )
    if ( present(fx) ) then
      this%FX(:) = fx(:)
    else
      this%FX(1    ) = dom_xmin
      this%FX(neg+1) = dom_xmax
      dx = (dom_xmax - dom_xmin) / dble(neg)
      do k=2, neg
        this%FX(k) = this%FX(k-1) + dx
      end do
    end if
    !$acc enter data create(this%FX)
 
    this%refElem1D => refelem
    call meshbase_init( this,          &
      meshbase1d_dimtype_num, refelem, &
      nlocalmeshperprc, 2,             &
      nprocs                           )
 
    this%Nprc = this%PRC_NUM
         
    allocate( this%lcmesh_list(this%LOCAL_MESH_NUM) )
    do n=1, this%LOCAL_MESH_NUM
      call localmesh1d_init( this%lcmesh_list(n), n, refelem, myrank )
    end do
 
    call this%SetDimInfo( meshbase1d_dimtypeid_x, "x", "m", "X-coordinate" )
    call this%SetDimInfo( meshbase1d_dimtypeid_xt, "xt", "m", "X-coordinate" )
 
    return

References scale_localmesh_1d::localmesh1d_init(), meshbase1d_dimtype_num, meshbase1d_dimtypeid_x, meshbase1d_dimtypeid_xt, and scale_mesh_base::meshbase_init().

Referenced by scale_mesh_base1d::meshbase1d_generate::meshbase1d_generate(), and scale_mesh_linedom1d::meshlinedom1d_init().

◆ meshbase1d_final()

subroutine, public scale_mesh_base1d::meshbase1d_final ( class(meshbase1d), intent(inout) this )

Finalize an object to manage a 1D computational mesh.

Definition at line 147 of file scale_mesh_base1d.F90.

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

References scale_localmesh_1d::localmesh1d_final(), and scale_mesh_base::meshbase_final().

Referenced by scale_mesh_base1d::meshbase1d_generate::meshbase1d_generate(), and scale_mesh_linedom1d::meshlinedom1d_final().

◆ meshbase1d_setgeometricinfo()

subroutine, public scale_mesh_base1d::meshbase1d_setgeometricinfo ( type(localmesh1d), intent(inout) lcmesh )

Definition at line 182 of file scale_mesh_base1d.F90.

    implicit none
    
    type(LocalMesh1D), intent(inout) :: lcmesh
 
    class(ElementBase1D), pointer :: refElem
    integer :: ke
    integer :: f
    integer :: i
 
    integer :: node_ids(lcmesh%refElem%Nv)
    real(RP) :: vx(lcmesh%refElem%Nv)
    real(RP) :: xr(lcmesh%refElem%Np)
    real(DP) :: Escale(1,1,lcmesh%refElem%Np)
    integer :: fmask(lcmesh%refElem%NfpTot)
    integer :: fid(lcmesh%refElem1D%Nfp,lcmesh%refElem1D%Nfaces)
 
  !-----------------------------------------------------------------------------
 
    call meshbase_setgeometricinfo(lcmesh, 1)
    refelem => lcmesh%refElem1D
    
    fmask(:) = reshape(refelem%Fmask, shape(fmask))
    do f=1, refelem%Nfaces
    do i=1, refelem%Nfp
       fid(i,f) = i + (f-1)*refelem%Nfp
    end do
    end do
  
    do ke=1, lcmesh%Ne
      node_ids(:) = lcmesh%EToV(ke,:)
      vx(:) = lcmesh%pos_ev(node_ids(:),1)
      lcmesh%pos_en(:,ke,1) = vx(1) + 0.5_rp*(refelem%x1(:) + 1.0_rp)*(vx(2) - vx(1))
      
      xr(:) = 0.5_rp*(vx(2) - vx(1)) !matmul(refElem%Dr,mesh%x(:,n))
 
      lcmesh%J(:,ke) = xr
      lcmesh%Escale(:,ke,1,1) =   1.0_rp/lcmesh%J(:,ke)
 
      !* Face
 
      !
      !mesh%fx(:,n) = mesh%x(fmask(:),n)
      !mesh%fy(:,n) = mesh%y(fmask(:),n)
 
      ! Calculate normal vectors
      lcmesh%normal_fn(fid(:,1),ke,1) = - 1.0_rp
      lcmesh%normal_fn(fid(:,2),ke,1) = + 1.0_rp
      lcmesh%sJ(:,ke) = 1.0_rp
      lcmesh%Fscale(:,ke) = lcmesh%sJ(:,ke)/lcmesh%J(fmask(:),ke)
      lcmesh%Gsqrt(:,ke) = 1.0_rp
    end do
    !$acc update device(lcmesh%pos_en, lcmesh%normal_fn, lcmesh%sJ, lcmesh%J, lcmesh%Escale, lcmesh%Fscale, lcmesh%Gsqrt)
 
    return

References scale_mesh_base::meshbase_setgeometricinfo().

Referenced by scale_mesh_base1d::meshbase1d_generate::meshbase1d_generate(), and meshbase1d_setuplocaldom().

◆ meshbase1d_assigndomid()

subroutine, public scale_mesh_base1d::meshbase1d_assigndomid	(	class(meshbase1d), intent(inout)	this,
		integer, dimension(this%local_mesh_num, this%prc_num), intent(out)	tileid_table,
		integer, dimension(this%local_mesh_num*this%prc_num), intent(out)	panelid_table,
		integer, dimension(this%local_mesh_num*this%prc_num), intent(out)	pi_table )

Definition at line 240 of file scale_mesh_base1d.F90.

  
    use scale_meshutil_1d, only: &       
      meshutil1d_buildglobalmap
    implicit none
    
    class(MeshBase1D), intent(inout) :: this    
    integer, intent(out) :: tileID_table(this%LOCAL_MESH_NUM, this%PRC_NUM)
    integer, intent(out) :: panelID_table(this%LOCAL_MESH_NUM*this%PRC_NUM)
    integer, intent(out) :: pi_table(this%LOCAL_MESH_NUM*this%PRC_NUM)
    
    integer :: n
    integer :: p
    integer :: tileID
    !-----------------------------------------------------------------------------
    
    call meshutil1d_buildglobalmap( &
      panelid_table, pi_table,                                                      & ! (out)
      this%tileID_globalMap, this%tileFaceID_globalMap, this%tilePanelID_globalMap, & ! (out)
      this%LOCAL_MESH_NUM_global )                                                    ! (in)
 
    do p=1, this%PRC_NUM
    do n=1, this%LOCAL_MESH_NUM
      tileid = n + (p-1)*this%LOCAL_MESH_NUM
 
      tileid_table(n,p)                   = tileid
      this%tileID_global2localMap(tileid) = n
      this%PRCRank_globalMap(tileid)      = p - 1
    end do
    end do
    !$acc update device(this%tileID_globalMap, this%tileFaceID_globalMap,                  &
    !$acc   this%tilePanelID_globalMap, this%tileID_global2localMap, this%PRCRank_globalMap)
 
    return

References scale_meshutil_1d::meshutil1d_buildglobalmap().

Referenced by scale_mesh_base1d::meshbase1d_generate::meshbase1d_generate(), and scale_mesh_linedom1d::meshlinedom1d_generate().

◆ meshbase1d_setuplocaldom()

subroutine, public scale_mesh_base1d::meshbase1d_setuplocaldom	(	type(localmesh1d), intent(inout)	lcmesh,
		integer, intent(in)	tileid,
		integer, intent(in)	panelid,
		integer, intent(in)	i,
		integer, intent(in)	nprc,
		real(rp)	dom_xmin,
		real(rp)	dom_xmax,
		integer, intent(in)	ne,
		real(rp), dimension(ne*nprc+1), intent(in)	fx )

Definition at line 279 of file scale_mesh_base1d.F90.

 
    use scale_meshutil_1d, only: &
      meshutil1d_genconnectivity,   &
      meshutil1d_genlinedomain,     &
      meshutil1d_buildinteriormap,  &
      meshutil1d_genpatchboundarymap
 
    use scale_localmesh_base, only: bctype_interior
    implicit none
      
    type(LocalMesh1D), intent(inout) :: lcmesh
    integer, intent(in) :: tileID
    integer, intent(in) :: panelID
    integer, intent(in) :: i
    integer, intent(in) :: Nprc
    real(RP) :: dom_xmin, dom_xmax
    integer, intent(in) ::Ne
    real(RP), intent(in) :: FX(Ne*Nprc+1)
    
    class(ElementBase1D), pointer :: elem
    real(RP) :: delx
    real(RP) :: FX_lc(Ne+1)    
    !-----------------------------------------------------------------------------
 
    elem => lcmesh%refElem1D
    lcmesh%tileID = tileid
    lcmesh%panelID = panelid
    !$acc update device(lcmesh%tileID, lcmesh%panelID)
    
    !--
 
    lcmesh%Ne  = ne
    lcmesh%Nv  = ne + 1
    lcmesh%NeS = 1
    lcmesh%NeE = lcmesh%Ne
    lcmesh%NeA = lcmesh%Ne + 2
    !$acc update device(lcmesh%Ne, lcmesh%Nv, lcmesh%NeS, lcmesh%NeE, lcmesh%NeA)
 
    !delx = (dom_xmax - dom_xmin)/dble(Nprc)
    fx_lc(:) = fx((i-1)*ne+1:i*ne+1)
    lcmesh%xmin = fx_lc(1)
    lcmesh%xmax = fx_lc(ne+1)
    !$acc update device(lcmesh%xmin, lcmesh%xmax)
 
    allocate( lcmesh%pos_ev(lcmesh%Nv,1) )
    allocate( lcmesh%EToV(lcmesh%Ne,2) )
    allocate( lcmesh%EToE(lcmesh%Ne,elem%Nfaces) )
    allocate( lcmesh%EToF(lcmesh%Ne,elem%Nfaces) )
    allocate( lcmesh%BCType(lcmesh%refElem%Nfaces,lcmesh%Ne) )
    allocate( lcmesh%VMapM(elem%NfpTot, lcmesh%Ne) )
    allocate( lcmesh%VMapP(elem%NfpTot, lcmesh%Ne) )
    allocate( lcmesh%MapM(elem%NfpTot, lcmesh%Ne) )
    allocate( lcmesh%MapP(elem%NfpTot, lcmesh%Ne) )
    !$acc enter data create(lcmesh%pos_ev, lcmesh%EToV, lcmesh%EToE, lcmesh%EToF, lcmesh%BCType, &
    !$acc   lcmesh%VMapM, lcmesh%VMapP, lcmesh%MapM, lcmesh%MapP)
 
    lcmesh%BCType(:,:) = bctype_interior
    !$acc update device(lcmesh%BCType)
 
    !----
 
    call meshutil1d_genlinedomain( lcmesh%pos_ev, lcmesh%EToV,   & ! (out)
        lcmesh%Ne, lcmesh%xmin, lcmesh%xmax, fx=fx_lc   )          ! (in)
    !$acc update device(lcmesh%pos_ev, lcmesh%EToV)
 
    !---
    call meshbase1d_setgeometricinfo( lcmesh )
    
    !---
 
    call meshutil1d_genconnectivity( lcmesh%EToE, lcmesh%EToF, & ! (out)
        & lcmesh%EToV, lcmesh%Ne, elem%Nfaces )                  ! (in)
    !$acc update device(lcmesh%EToE, lcmesh%EToF)
 
    !---
    call meshutil1d_buildinteriormap( lcmesh%VmapM, lcmesh%VMapP, lcmesh%MapM, lcmesh%MapP,  & ! (out)
      & lcmesh%pos_en, lcmesh%pos_ev, lcmesh%EToE, lcmesh%EtoF, lcmesh%EtoV,                 & ! (in)
      & elem%Fmask, lcmesh%Ne, elem%Np, elem%Nfp, elem%Nfaces, lcmesh%Nv )                     ! (in)
 
    call meshutil1d_genpatchboundarymap( lcmesh%VMapB, lcmesh%MapB, lcmesh%VMapP, & ! (inout)
      & lcmesh%pos_en, lcmesh%xmin, lcmesh%xmax,                                  & ! (in)
      & elem%Fmask, lcmesh%Ne, elem%Np, elem%Nfp, elem%Nfaces, lcmesh%Nv )          ! (in)
    !$acc update device(lcmesh%VMapM, lcmesh%VMapP, lcmesh%MapM, lcmesh%MapP)
    !$acc enter data copyin(lcmesh%VMapB, lcmesh%MapB)
 
    return