scale_element_base Module Reference

module FElib / Element / Base More...

Data Types
type	elementbase
	Derived type representing an arbitrary finite element. More...
type	elementbase1d
	Derived type representing a 1D reference element. More...
type	elementbase2d
	Derived type representing a 2D reference element. More...
interface	elementbase2d_genintgausslegendreintrpmat
type	elementbase3d
	Derived type representing a 3D reference element. More...

Functions/Subroutines
subroutine, public	elementbase_construct_massmat (v, np, massmat, invmassmat)
	Construct mass matrix M^-1 = V V^T M = ( M^-1 )^-1.
subroutine, public	elementbase_construct_stiffmat (massmat, invmassmat, dmat, np, stiffmat)
	Construct stiffness matrix StiffMat_i = M^-1 ( M D_xi )^T.
subroutine, public	elementbase_construct_liftmat (invm, emat, np, nfptot, liftmat)
	Construct stiffness matrix StiffMat_i = M^-1 ( M D_xi )^T.
subroutine, public	elementbase1d_init (elem, lumpedmat_flag)
	Initialize an object to manage a 1D reference element.
subroutine, public	elementbase1d_final (elem)
	Finalize an object to manage a 1D reference element.
subroutine, public	elementbase2d_init (elem, lumpedmat_flag)
	Initialize an object to manage a 2D reference element.
subroutine, public	elementbase2d_final (elem)
	Finalize an object to manage a 2D reference element.
subroutine, public	elementbase3d_init (elem, lumpedmat_flag)
	Initialize an object to manage a 3D reference element.
subroutine, public	elementbase3d_final (elem)
	Finalize an object to manage a 3D reference element.

Detailed Description

module FElib / Element / Base

Description

A base module for finite element

Author

Yuta Kawai, Team SCALE

Function/Subroutine Documentation

elementbase_construct_massmat()

subroutine, public scale_element_base::elementbase_construct_massmat	(	real(rp), dimension(np,np), intent(in)	v,
		integer, intent(in)	np,
		real(rp), dimension(np,np), intent(out)	massmat,
		real(rp), dimension(np,np), intent(out), optional	invmassmat )

Construct mass matrix M^-1 = V V^T M = ( M^-1 )^-1.

Definition at line 221 of file scale_element_base.F90.

    use scale_linalgebra, only: linalgebra_inv
    implicit none
    integer, intent(in) :: Np
    real(RP), intent(in) :: V(Np,Np)
    real(RP), intent(out) :: MassMat(Np,Np)
    real(RP), intent(out), optional :: invMassMat(Np,Np)
 
    real(RP) :: tmpMat(Np,Np)
    real(RP) :: invM(Np,Np)
    !------------------------------------
 
    tmpmat(:,:) = transpose(v)
    invm(:,:) = matmul( v, tmpmat )
    massmat(:,:) = linalgebra_inv( invm )
 
    if ( present(invmassmat) ) invmassmat(:,:) = invm(:,:)
    return

References scale_linalgebra::linalgebra_inv().

Referenced by scale_element_hexahedral::hexhedralelement_init(), scale_element_base::elementbase::islumpedmatrix(), scale_element_line::lineelement_init(), and scale_element_quadrilateral::quadrilateralelement_init().

elementbase_construct_stiffmat()

subroutine, public scale_element_base::elementbase_construct_stiffmat	(	real(rp), dimension(np,np), intent(in)	massmat,
		real(rp), dimension(np,np), intent(in)	invmassmat,
		real(rp), dimension(np,np), intent(in)	dmat,
		integer, intent(in)	np,
		real(rp), dimension(np,np), intent(out)	stiffmat )

Construct stiffness matrix StiffMat_i = M^-1 ( M D_xi )^T.

Definition at line 245 of file scale_element_base.F90.

    implicit none
    integer, intent(in) :: Np
    real(RP), intent(in) :: MassMat(Np,Np)
    real(RP), intent(in) :: invMassMat(Np,Np)
    real(RP), intent(in) :: DMat(Np,Np)
    real(RP), intent(out) :: StiffMat(Np,Np)
 
    real(RP) :: tmpMat1(Np,Np)
    real(RP) :: tmpMat2(Np,Np)
    !------------------------------------
 
    tmpmat1(:,:) = matmul( massmat, dmat )
    tmpmat2(:,:) = transpose( tmpmat1 )
    stiffmat(:,:) = matmul( invmassmat, tmpmat2 )
 
    return

Referenced by scale_element_hexahedral::hexhedralelement_init(), scale_element_base::elementbase::islumpedmatrix(), scale_element_line::lineelement_init(), and scale_element_quadrilateral::quadrilateralelement_init().

elementbase_construct_liftmat()

subroutine, public scale_element_base::elementbase_construct_liftmat	(	real(rp), dimension(np,np), intent(in)	invm,
		real(rp), dimension(np,nfptot), intent(in)	emat,
		integer, intent(in)	np,
		integer, intent(in)	nfptot,
		real(rp), dimension(np,nfptot), intent(out)	liftmat )

Construct stiffness matrix StiffMat_i = M^-1 ( M D_xi )^T.

Definition at line 268 of file scale_element_base.F90.

    implicit none
    integer, intent(in) :: Np
    integer, intent(in) :: NfpTot
    real(RP), intent(in) :: invM(Np,Np)
    real(RP), intent(in) :: EMat(Np,NfpTot)
    real(RP), intent(out) :: LiftMat(Np,NfpTot)
    !------------------------------------
 
    liftmat(:,:) = matmul( invm, emat )
    return

Referenced by scale_element_hexahedral::hexhedralelement_init(), scale_element_base::elementbase::islumpedmatrix(), scale_element_line::lineelement_init(), and scale_element_quadrilateral::quadrilateralelement_init().

elementbase1d_init()

subroutine, public scale_element_base::elementbase1d_init	(	class(elementbase1d), intent(inout)	elem,
		logical, intent(in)	lumpedmat_flag )

Initialize an object to manage a 1D reference element.

Parameters

elem	Object of finite element
elem	Flag whether mass lumping is considered

Definition at line 289 of file scale_element_base.F90.

    implicit none
    class(ElementBase1D), intent(inout) :: elem
    logical, intent(in) :: lumpedmat_flag    
    !-----------------------------------------------------------------------------
 
    call elementbase_init( elem, lumpedmat_flag )
 
    !$acc enter data create( elem )
    !$acc update device( elem%Np, elem%Nfaces, elem%NfpTot, elem%Nv )
 
    allocate( elem%x1(elem%Np) )  
    allocate( elem%Fmask(elem%Nfp, elem%Nfaces) )
    
    allocate( elem%Dx1(elem%Np, elem%Np) )
    allocate( elem%Sx1(elem%Np, elem%Np) )
    !$acc enter data create( elem%x1, elem%Dx1, elem%Sx1, elem%Fmask )
    return

Referenced by scale_element_line::lineelement_init().

elementbase1d_final()

subroutine, public scale_element_base::elementbase1d_final

(

class(elementbase1d), intent(inout)

elem

)

Finalize an object to manage a 1D reference element.

Definition at line 311 of file scale_element_base.F90.

    implicit none
    class(ElementBase1D), intent(inout) :: elem
    !-----------------------------------------------------------------------------
 
    if ( allocated( elem%x1 ) )  then
      !$acc exit data delete( elem%x1, elem%Dx1, elem%Sx1, elem%Fmask )
      !$acc exit data delete( elem )
      deallocate( elem%x1 )
      deallocate( elem%Dx1 )
      deallocate( elem%Sx1 )
      deallocate( elem%Fmask )
    end if
 
    call elementbase_final( elem )
 
    return

Referenced by scale_element_line::lineelement_init().

elementbase2d_init()

subroutine, public scale_element_base::elementbase2d_init	(	class(elementbase2d), intent(inout)	elem,
		logical, intent(in)	lumpedmat_flag )

Initialize an object to manage a 2D reference element.

Parameters

elem	Object of finite element
elem	Flag whether mass lumping is considered

Definition at line 337 of file scale_element_base.F90.

    implicit none
    class(ElementBase2D), intent(inout) :: elem
    logical, intent(in) :: lumpedmat_flag    
    !-----------------------------------------------------------------------------
 
    call elementbase_init( elem, lumpedmat_flag )
 
    !$acc enter data create( elem )
    !$acc update device( elem%Np, elem%Nfaces, elem%NfpTot, elem%Nv )
 
    allocate( elem%x1(elem%Np), elem%x2(elem%Np) )
    allocate( elem%Fmask(elem%Nfp, elem%Nfaces) )
 
    allocate( elem%Dx1(elem%Np, elem%Np), elem%Dx2(elem%Np, elem%Np) )
    allocate( elem%Sx1(elem%Np, elem%Np), elem%Sx2(elem%Np, elem%Np) )
    !$acc enter data create( elem%x1, elem%x2, elem%Dx1, elem%Dx2, elem%Sx1, elem%Sx2, elem%Fmask )
 
    return

Referenced by scale_element_base::elementbase2d::generate_modaltruncationmat(), and scale_element_quadrilateral::quadrilateralelement_init().

elementbase2d_final()

subroutine, public scale_element_base::elementbase2d_final

(

class(elementbase2d), intent(inout)

elem

)

Finalize an object to manage a 2D reference element.

Definition at line 360 of file scale_element_base.F90.

    implicit none
    class(ElementBase2D), intent(inout) :: elem
    !-----------------------------------------------------------------------------
 
    if ( allocated( elem%x1 ) )  then
      !$acc exit data delete( elem%x1, elem%x2, elem%Dx1, elem%Dx2, elem%Sx1, elem%Sx2, elem%Fmask )
      !$acc exit data delete( elem )
      deallocate( elem%x1, elem%x2 )
      deallocate( elem%Fmask )
 
      deallocate( elem%Dx1, elem%Dx2 )
      deallocate( elem%Sx1, elem%Sx2 )
    end if
 
    call elementbase_final( elem )
 
    return

Referenced by scale_element_base::elementbase2d::generate_modaltruncationmat(), and scale_element_quadrilateral::quadrilateralelement_init().

elementbase3d_init()

subroutine, public scale_element_base::elementbase3d_init	(	class(elementbase3d), intent(inout)	elem,
		logical, intent(in)	lumpedmat_flag )

Initialize an object to manage a 3D reference element.

Parameters

elem	Object of finite element
elem	Flag whether mass lumping is considered

Definition at line 445 of file scale_element_base.F90.

    implicit none
    class(ElementBase3D), intent(inout) :: elem
    logical, intent(in) :: lumpedmat_flag
    !-----------------------------------------------------------------------------
 
    call elementbase_init( elem, lumpedmat_flag )
 
    !$acc enter data create( elem )
    !$acc update device( elem%Np, elem%Nfaces, elem%NfpTot, elem%Nv )
 
    allocate( elem%x1(elem%Np), elem%x2(elem%Np), elem%x3(elem%Np) )
    allocate( elem%Dx1(elem%Np, elem%Np), elem%Dx2(elem%Np, elem%Np), elem%Dx3(elem%Np, elem%Np) )
    allocate( elem%Sx1(elem%Np, elem%Np), elem%Sx2(elem%Np, elem%Np), elem%Sx3(elem%Np, elem%Np) )
    allocate( elem%Fmask_h(elem%Nfp_h, elem%Nfaces_h), elem%Fmask_v(elem%Nfp_v, elem%Nfaces_v) )
    allocate( elem%Colmask(elem%Nnode_v,elem%Nfp_v))
    allocate( elem%Hslice(elem%Nfp_v,elem%Nnode_v) )
    allocate( elem%IndexH2Dto3D(elem%Np) )
    allocate( elem%IndexH2Dto3D_bnd(elem%NfpTot) )
    allocate( elem%IndexZ1Dto3D(elem%Np) )
    !$acc enter data create( elem%x1, elem%x2, elem%x3,                &
    !$acc  elem%Dx1, elem%Dx2, elem%Dx3, elem%Sx1, elem%Sx2, elem%Sx3, &
    !$acc  elem%Fmask_h, elem%Fmask_v, elem%Colmask, elem%Hslice,      &
    !$acc  elem%IndexH2Dto3D, elem%IndexH2Dto3D_bnd, elem%IndexZ1Dto3D )
    return

Referenced by scale_element_base::elementbase3d::generate_modaltruncationmat(), and scale_element_hexahedral::hexhedralelement_init().

elementbase3d_final()

subroutine, public scale_element_base::elementbase3d_final

(

class(elementbase3d), intent(inout)

elem

)

Finalize an object to manage a 3D reference element.

Definition at line 474 of file scale_element_base.F90.

    implicit none
    class(ElementBase3D), intent(inout) :: elem
    !-----------------------------------------------------------------------------
 
    if ( allocated( elem%x1 ) )  then
      !$acc exit data delete( elem%x1, elem%x2, elem%x3,                 &
      !$acc  elem%Dx1, elem%Dx2, elem%Dx3, elem%Sx1, elem%Sx2, elem%Sx3, &
      !$acc  elem%Fmask_h, elem%Fmask_v, elem%Colmask, elem%Hslice,      &
      !$acc  elem%IndexH2Dto3D, elem%IndexH2Dto3D_bnd, elem%IndexZ1Dto3D )
      !$acc exit data delete( elem )
      deallocate( elem%x1, elem%x2, elem%x3 )
      deallocate( elem%Dx1, elem%Dx2, elem%Dx3 )
      deallocate( elem%Sx1, elem%Sx2, elem%Sx3 )
      deallocate( elem%Fmask_h, elem%Fmask_v )
      deallocate( elem%Colmask, elem%Hslice )
      deallocate( elem%IndexH2Dto3D, elem%IndexH2Dto3D_bnd )
      deallocate( elem%IndexZ1Dto3D )
    end if
 
    call elementbase_final( elem )    
 
    return

Referenced by scale_element_base::elementbase3d::generate_modaltruncationmat(), and scale_element_hexahedral::hexhedralelement_init().