soln_mod.F90

Go to the documentation of this file.

module soln
  use kinds, only : dp
  use size_m
  implicit none

  integer, parameter :: lvt1  = lx1*ly1*lz1*lelv
  integer, parameter :: lvt2  = lx2*ly2*lz2*lelv
  integer, parameter :: lbt1  = lbx1*lby1*lbz1*lbelv
  integer, parameter :: lbt2  = lbx2*lby2*lbz2*lbelv

  integer, parameter :: lptmsk = lvt1*(5+2*ldimt) + 4*lbt1
  integer, parameter :: lptsol &
    = lvt1*(12 + 4*ldimt + 2*ldimt1 + (3+ldimt)*(lorder-1)) &
    + lvt2*(lorder-1) &
    + lbt1*(12 + 3*(lorder-1)) &
    + lbt2*(lorder-1) 

  integer, parameter :: lorder2 = max(1,lorder-2)

!     Solution and data
  real(DP), allocatable :: bq(:,:,:,:,:)
!     Can be used for post-processing runs (SIZE .gt. 10+3*LDIMT flds)
  real(DP), allocatable, dimension(:,:,:,:,:) :: vxlag, vylag, vzlag
  real(DP), allocatable :: tlag(:,:,:,:,:,:)
  real(DP), allocatable, dimension(:,:,:,:,:) :: vgradt1, vgradt2
  real(DP), allocatable, dimension(:,:,:,:) :: abx1, aby1, abz1 
  real(DP), allocatable, dimension(:,:,:,:) :: abx2, aby2, abz2
  real(DP), allocatable, dimension(:,:,:,:) :: vdiff_e
!     Solution data
  real(DP), allocatable, dimension(:,:,:,:) :: vx, vy, vz
  real(DP), allocatable, dimension(:,:,:,:,:) :: t, vtrans, vdiff
  real(DP), allocatable, dimension(:,:,:,:) :: bfx, bfy, bfz
  real(DP), allocatable, dimension(:,:,:,:) :: cflf
  real(DP), allocatable :: c_vx(:,:)
!     Solution data for magnetic field
  real(DP), allocatable, dimension(:,:,:,:) :: bx, by, bz, pm
  real(DP), allocatable, dimension(:,:,:,:) :: bmx, bmy, bmz ! Magnetic field RHS
! Extrapolation terms for magnetic field rhs
  real(DP), allocatable, dimension(:,:,:,:) :: bbx1, bby1, bbz1
  real(DP), allocatable, dimension(:,:,:,:) :: bbx2, bby2, bbz2
  real(DP), allocatable :: bxlag(:,:), bylag(:,:), bzlag(:,:), pmlag(:,:)

  real(DP) ::             nu_star

  real(DP), allocatable :: pr(:,:,:,:), prlag(:,:,:,:,:)

  real(DP), allocatable :: qtl(:,:,:,:), usrdiv(:,:,:,:)

  real(DP), allocatable, target, dimension(:,:,:,:) :: v1mask
  real(DP), pointer, dimension(:,:,:,:) :: v2mask, v3mask, pmask
  real(DP), allocatable, target, dimension(:,:,:,:,:) :: tmask
  real(DP), pointer, dimension(:,:,:,:) :: omask, vmult
  real(DP), allocatable, target, dimension(:,:,:,:,:) :: tmult
  real(DP), allocatable, dimension(:,:,:,:) :: b1mask, b2mask, b3mask! masks for mag. field
  real(DP), allocatable, dimension(:,:,:,:) :: bpmask ! magnetic pressure

!     Solution and data for perturbation fields
  real(DP), allocatable, dimension(:,:) :: vxp, vyp, vzp, prp
  real(DP), allocatable, dimension(:,:,:) :: tp, bqp
  real(DP), allocatable, dimension(:,:) :: bfxp, bfyp, bfzp! perturbation field RHS
  real(DP), allocatable, dimension(:,:,:) :: vxlagp, vylagp, vzlagp, prlagp
  real(DP), allocatable, dimension(:,:,:,:) :: tlagp 
! Extrapolation terms for perturbation field rhs
  real(DP), allocatable, dimension(:,:) :: exx1p, exy1p, exz1p, exx2p, exy2p, exz2p
  real(DP), allocatable, dimension(:,:,:) :: vgradt1p, vgradt2p

  integer :: jp

  contains

  subroutine init_soln()
    use kinds, only : dp
    use size_m
    implicit none 
    
    allocate(bq(lx1,ly1,lz1,lelt,ldimt))
    bq = 0_dp

    allocate( &
!     Can be used for post-processing runs (SIZE .gt. 10+3*LDIMT flds)
    vxlag(lx1,ly1,lz1,lelv,2) &
    , vylag(lx1,ly1,lz1,lelv,2) &
    , vzlag(lx1,ly1,lz1,lelv,2) &
    , tlag(lx1,ly1,lz1,lelt,lorder-1,ldimt))
    vxlag = 0._dp; vylag = 0._dp; vzlag = 0._dp; tlag = 0._dp

    allocate( &
      vgradt1(lx1,ly1,lz1,lelt,ldimt) &
    , vgradt2(lx1,ly1,lz1,lelt,ldimt) )
    allocate( &
      abx1(lx1,ly1,lz1,lelv) &
    , aby1(lx1,ly1,lz1,lelv) &
    , abz1(lx1,ly1,lz1,lelv) &
    , abx2(lx1,ly1,lz1,lelv) &
    , aby2(lx1,ly1,lz1,lelv) &
    , abz2(lx1,ly1,lz1,lelv) &
!    , VDIFF_E(LX1,LY1,LZ1,LELT) &
!     Solution data
    , vx(lx1,ly1,lz1,lelv) &
    , vy(lx1,ly1,lz1,lelv) &
    , vz(lx1,ly1,lz1,lelv) &
    , t(lx1,ly1,lz1,lelt,ldimt) &
    , vtrans(lx1,ly1,lz1,lelt,ldimt1) &
    , vdiff(lx1,ly1,lz1,lelt,ldimt1) &
    , bfx(lx1,ly1,lz1,lelv) &
    , bfy(lx1,ly1,lz1,lelv) &
    , bfz(lx1,ly1,lz1,lelv) &
!    , cflf   (lx1,ly1,lz1,lelv) &
!    , c_vx   (lxd*lyd*lzd*lelv*ldim,lorder+1)  & ! characteristics
!     Solution data for magnetic field
    , bx(lbx1,lby1,lbz1,lbelv) &
    , by(lbx1,lby1,lbz1,lbelv) &
    , bz(lbx1,lby1,lbz1,lbelv) &
    , pm(lbx2,lby2,lbz2,lbelv) &
    , bmx(lbx1,lby1,lbz1,lbelv)   & ! Magnetic field RHS
    , bmy(lbx1,lby1,lbz1,lbelv) &
    , bmz(lbx1,lby1,lbz1,lbelv) &
    , bbx1(lbx1,lby1,lbz1,lbelv)  & ! Extrapolation terms for
    , bby1(lbx1,lby1,lbz1,lbelv)  & ! magnetic field rhs
    , bbz1(lbx1,lby1,lbz1,lbelv) &
    , bbx2(lbx1,lby1,lbz1,lbelv) &
    , bby2(lbx1,lby1,lbz1,lbelv) &
    , bbz2(lbx1,lby1,lbz1,lbelv) &
    , bxlag(lbx1*lby1*lbz1*lbelv,lorder-1) &
    , bylag(lbx1*lby1*lbz1*lbelv,lorder-1) &
    , bzlag(lbx1*lby1*lbz1*lbelv,lorder-1) &
    , pmlag(lbx2*lby2*lbz2*lbelv,lorder2) )

    allocate(pr(lx2,ly2,lz2,lelv))
!    allocate(PRLAG(LX2,LY2,LZ2,LELV,LORDER2)) 

    !allocate(QTL(LX2,LY2,LZ2,LELT))
!    allocate(USRDIV(LX2,LY2,LZ2,LELT))

    allocate(v1mask(lx1,ly1,lz1,lelv) &
    , v2mask(lx1,ly1,lz1,lelv) &
    , v3mask(lx1,ly1,lz1,lelv) &
!    , PMASK  (LX1,LY1,LZ1,LELV) &
    , tmask(lx1,ly1,lz1,lelt,ldimt) &
!    , OMASK  (LX1,LY1,LZ1,LELT) &
!    , VMULT  (LX1,LY1,LZ1,LELV) &
!    , TMULT  (LX1,LY1,LZ1,LELT,LDIMT) &
    , b1mask(lbx1,lby1,lbz1,lbelv)   & ! masks for mag. field
    , b2mask(lbx1,lby1,lbz1,lbelv) &
    , b3mask(lbx1,lby1,lbz1,lbelv) &
    , bpmask(lbx1,lby1,lbz1,lbelv) )  ! magnetic pressure

!     Solution and data for perturbation fields
    allocate(vxp(lpx1*lpy1*lpz1*lpelv,lpert) &
    , vyp(lpx1*lpy1*lpz1*lpelv,lpert) &
    , vzp(lpx1*lpy1*lpz1*lpelv,lpert) &
    , prp(lpx2*lpy2*lpz2*lpelv,lpert) &
    , tp(lpx1*lpy1*lpz1*lpelt,ldimt,lpert) &
    , bqp(lpx1*lpy1*lpz1*lpelt,ldimt,lpert) &
    , bfxp(lpx1*lpy1*lpz1*lpelv,lpert)   & ! perturbation field RHS
    , bfyp(lpx1*lpy1*lpz1*lpelv,lpert) &
    , bfzp(lpx1*lpy1*lpz1*lpelv,lpert) &
    , vxlagp(lpx1*lpy1*lpz1*lpelv,lorder-1,lpert) &
    , vylagp(lpx1*lpy1*lpz1*lpelv,lorder-1,lpert) &
    , vzlagp(lpx1*lpy1*lpz1*lpelv,lorder-1,lpert) &
    , prlagp(lpx2*lpy2*lpz2*lpelv,lorder2,lpert) &
    , tlagp(lpx1*lpy1*lpz1*lpelt,ldimt,lorder-1,lpert) &
    , exx1p(lpx1*lpy1*lpz1*lpelv,lpert)  & ! Extrapolation terms for
    , exy1p(lpx1*lpy1*lpz1*lpelv,lpert)  & ! perturbation field rhs
    , exz1p(lpx1*lpy1*lpz1*lpelv,lpert) &
    , exx2p(lpx1*lpy1*lpz1*lpelv,lpert) &
    , exy2p(lpx1*lpy1*lpz1*lpelv,lpert) &
    , exz2p(lpx1*lpy1*lpz1*lpelv,lpert) &
    ,vgradt1p(lpx1*lpy1*lpz1*lpelt,ldimt,lpert) &
    ,vgradt2p(lpx1*lpy1*lpz1*lpelt,ldimt,lpert) )

  end subroutine init_soln

end module soln