mod_refine.t

Go to the documentation of this file.

module mod_refine
 
  implicit none
  private
 
  public :: refine_grids
 
contains
 
 
  !> refine one block to its children blocks
  subroutine refine_grids(child_igrid,child_ipe,igrid,ipe,active)
    use mod_global_parameters
    use mod_initialize_amr, only: initial_condition
    use mod_amr_solution_node, only: alloc_node, dealloc_node
  
    integer, dimension(2^D&), intent(in) :: child_igrid, child_ipe
    integer, intent(in) :: igrid, ipe
    logical, intent(in) :: active
  
    integer :: ic^d
  
    ! allocate solution space for new children
    {do ic^db=1,2\}
       call alloc_node(child_igrid(ic^d))
    {end do\}
  
    if ((time_advance .and. active).or.convert.or.reset_grid) then
       ! prolong igrid to new children
       call prolong_grid(child_igrid,child_ipe,igrid,ipe)
    else
       ! Fill new created children with initial condition
       {do ic^db=1,2\}
          call initial_condition(child_igrid(ic^d))
       {end do\}
    end if
  
    ! remove solution space of igrid to save memory when converting data
    if(convert) call dealloc_node(igrid)
  end subroutine refine_grids
  
  !> prolong one block
  subroutine prolong_grid(child_igrid,child_ipe,igrid,ipe)
    use mod_physics, only: phys_to_primitive, phys_to_conserved
    use mod_global_parameters
    use mod_amr_fct, only: old_neighbors
  
    integer, dimension(2^D&), intent(in) :: child_igrid, child_ipe
    integer, intent(in) :: igrid, ipe
  
    double precision :: dxCo^D, xComin^D, dxFi^D, xFimin^D
    integer :: ix^L, ichild, ixCo^L, ic^D
  
    ix^l=ixm^ll^ladd1;
  
    if(prolongprimitive) call phys_to_primitive(ixg^ll,ix^l,ps(igrid)%w,ps(igrid)%x)
  
    xcomin^d=rnode(rpxmin^d_,igrid)\
    dxco^d=rnode(rpdx^d_,igrid)\
  
    if(stagger_grid) call old_neighbors(child_igrid,child_ipe,igrid,ipe)
  
    {do ic^db=1,2\}
      ichild=child_igrid(ic^d)
  
      ixcomin^d=ixmlo^d+(ic^d-1)*block_nx^d/2\
      ixcomax^d=ixmhi^d+(ic^d-2)*block_nx^d/2\
  
      xfimin^d=rnode(rpxmin^d_,ichild)\
      dxfi^d=rnode(rpdx^d_,ichild)\
      call prolong_2nd(ps(igrid),ixco^l,ps(ichild), &
           dxco^d,xcomin^d,dxfi^d,xfimin^d,igrid,ichild)
      !call prolong_1st(ps(igrid)%w,ixCo^L,ps(ichild)%w,ps(ichild)%x)
    {end do\}
  
    if (prolongprimitive) call phys_to_conserved(ixg^ll,ix^l,ps(igrid)%w,ps(igrid)%x)
  
  end subroutine prolong_grid
  
  !> do 2nd order prolongation
  subroutine prolong_2nd(sCo,ixCo^L,sFi,dxCo^D,xComin^D,dxFi^D,xFimin^D,igridCo,igridFi)
    use mod_physics, only: phys_to_conserved, phys_handle_small_values
    use mod_global_parameters
    use mod_amr_fct, only: already_fine, prolong_2nd_stg
  
    integer, intent(in) :: ixCo^L, igridFi, igridCo
    double precision, intent(in) :: dxCo^D, xComin^D, dxFi^D, xFimin^D
    type(state), intent(in)      :: sCo
    type(state), intent(inout)   :: sFi
  
    double precision :: slopeL, slopeR, slopeC, signC, signR
    double precision :: slope(nw,ndim)
    double precision :: eta^D
    integer :: ixCo^D, jxCo^D, hxCo^D, ixFi^D, ix^D, idim, iw, ixCg^L, el
    logical :: fine_^L
  
    associate(wco=>sco%w, wfi=>sfi%w)
    ixcg^l=ixco^l;
    {do ixco^db = ixcg^lim^db
       ! lower left grid index in finer child block
       ixfi^db=2*(ixco^db-ixcomin^db)+ixmlo^db\}
  
       do idim=1,ndim
          hxco^d=ixco^d-kr(^d,idim)\
          jxco^d=ixco^d+kr(^d,idim)\
  
          do iw=1,nw
             slopel=wco(ixco^d,iw)-wco(hxco^d,iw)
             sloper=wco(jxco^d,iw)-wco(ixco^d,iw)
             slopec=half*(sloper+slopel)
  
             ! get limited slope
             signr=sign(one,sloper)
             signc=sign(one,slopec)
             !select case(prolong_limiter)
             !case(1)
             !  ! unlimited
             !  slope(iw,idim)=slopeC
             !case(2)
             !  ! minmod
             !  slope(iw,idim)=signR*max(zero,min(dabs(slopeR), &
             !                                    signR*slopeL))
             !case(3)
             !  ! woodward
             !  slope(iw,idim)=two*signR*max(zero,min(dabs(slopeR), &
             !                     signR*slopeL,signR*half*slopeC))
             !case(4)
             !  ! koren
             !  slope(iw,idim)=signR*max(zero,min(two*signR*slopeL, &
             !   (dabs(slopeR)+two*slopeL*signR)*third,two*dabs(slopeR)))
             !case default
               slope(iw,idim)=signc*max(zero,min(dabs(slopec), &
                                 signc*slopel,signc*sloper))
             !end select
          end do
       end do
       ! cell-centered coordinates of coarse grid point
       !^D&xCo^D=xCo({ixCo^DD},^D)
       {do ix^db=ixfi^db,ixfi^db+1 \}
          ! cell-centered coordinates of fine grid point
          !^D&xFi^D=xFi({ix^DD},^D)
          if(slab_uniform) then
            ! normalized distance between fine/coarse cell center
            ! in coarse cell: ranges from -0.5 to 0.5 in each direction
            ! (origin is coarse cell center)
            ! hence this is +1/4 or -1/4 on cartesian mesh
            !eta^D=(xFi^D-xCo^D)*invdxCo^D;
            eta^d=0.5d0*(dble(ix^d-ixfi^d)-0.5d0);
          else
            {! forefactor is -0.5d0 when ix=ixFi and +0.5d0 for ixFi+1
            eta^d=(dble(ix^d-ixfi^d)-0.5d0)*(one-sfi%dvolume(ix^dd) &
                  /sum(sfi%dvolume(ixfi^d:ixfi^d+1^d%ix^dd)))  \}
          end if
          wfi(ix^d,1:nw) = wco(ixco^d,1:nw) &
                                + {(slope(1:nw,^d)*eta^d)+}
       {end do\}
    {end do\}
    if(stagger_grid) then
      call already_fine(sfi,igridfi,fine_^l)
      call prolong_2nd_stg(sco,sfi,ixco^l,ixm^ll,dxco^d,xcomin^d,dxfi^d,xfimin^d,.false.,fine_^l)
    end if
  
    if(fix_small_values) call phys_handle_small_values(prolongprimitive,wfi,sfi%x,ixg^ll,ixm^ll,'prolong_2nd')
    if(prolongprimitive) call phys_to_conserved(ixg^ll,ixm^ll,wfi,sfi%x)
    end associate
  
  end subroutine prolong_2nd
  
  !> do 1st order prolongation
  subroutine prolong_1st(wCo,ixCo^L,wFi,xFi)
    use mod_global_parameters
  
    integer, intent(in) :: ixCo^L
    double precision, intent(in) :: wCo(ixG^T,nw), xFi(ixG^T,1:ndim)
    double precision, intent(out) :: wFi(ixG^T,nw)
  
    integer :: ixCo^D, ixFi^D, iw
    integer :: ixFi^L
  
    {do ixco^db = ixco^lim^db
       ixfi^db=2*(ixco^db-ixcomin^db)+ixmlo^db\}
       forall(iw=1:nw) wfi(ixfi^d:ixfi^d+1,iw)=wco(ixco^d,iw)
    {end do\}
  
  end subroutine prolong_1st
 
end module mod_refine