bound.f90 File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	bound (time, nvar, ng, valbig, mitot, mjtot, mptr, aux, naux)
	This routine sets the boundary values for a given grid at level level. More...

Function/Subroutine Documentation

bound()

subroutine bound	(	real(kind=8), intent(in)	time,
		integer, intent(in)	nvar,
		integer, intent(in)	ng,
		real(kind=8), dimension(nvar,mitot,mjtot), intent(inout)	valbig,
		integer, intent(in)	mitot,
		integer, intent(in)	mjtot,
		integer, intent(in)	mptr,
		real(kind=8), dimension(naux,mitot,mjtot), intent(inout)	aux,
		integer, intent(in)	naux
	)

This routine sets the boundary values for a given grid at level level.

It sets the values for a strip ng zones wide all the way around the border, in 4 rectangular strips.

This routine calls the routine filpatch() which for any block of mesh points on a given level, intersects that block with all grids on that level, copies the values into the appropriate intersecting regions, and interpolates the remaining cells from coarser grids as required. After calling filpatch for four regions around the border, call bc2amr() to set any regions that are outside physical boundary.

Output:

The values around the border of the grid are inserted directly into the enlarged valbig array.

Parameters

time	the grid mptr needs ghost cell values at time t
nvar	number of equations for the system
ng	width of ghost regions on each side
valbig	data array for solution (cover the whole grid msrc)
mitot	number of cells in i direction on grid mptr
mjtot	number of cells in j direction on grid mptr
mptr	index of the grid to be processed
aux	data array for auxiliary variables
naux	number of auxiliary variables

Definition at line 52 of file bound.f90.

References bc2amr(), amr_module::cornxhi, amr_module::cornxlo, amr_module::cornyhi, amr_module::cornylo, filrecur(), amr_module::hxposs, amr_module::hyposs, amr_module::ndihi, amr_module::ndilo, amr_module::ndjhi, amr_module::ndjlo, amr_module::nestlevel, amr_module::node, prefilrecur(), amr_module::rnode, amr_module::spheredom, amr_module::xlower, amr_module::xperdom, amr_module::xupper, amr_module::ylower, amr_module::yperdom, and amr_module::yupper.

Referenced by advanc(), flagger(), prepbigstep(), and spest2().

  use amr_module, only: rnode, node, hxposs, hyposs, cornxlo, cornxhi
  use amr_module, only: cornylo, cornyhi, ndilo, ndihi, ndjlo, ndjhi
  use amr_module, only: nestlevel, xlower, xupper, ylower, yupper
  use amr_module, only: xperdom, yperdom, spheredom

  implicit none

  ! Input
  integer, intent(in) :: nvar, ng, mitot, mjtot, mptr, naux
  real(kind=8), intent(in) :: time
  real(kind=8), intent(in out) :: valbig(nvar,mitot,mjtot)
  real(kind=8), intent(in out) :: aux(naux,mitot,mjtot)

  ! Locals
  integer :: ilo, ihi, jlo, jhi, level  ! rect(4)
  real(kind=8) :: xleft, xright, ybot, ytop, hx, hy, xl, xr, yb, yt
  real(kind=8) :: xlowithghost,  xhiwithghost,  ylowithghost, yhiwithghost
  logical      :: patchonly

  xleft  = rnode(cornxlo, mptr)
  xright = rnode(cornxhi, mptr)
  ybot   = rnode(cornylo, mptr)
  ytop   = rnode(cornyhi, mptr)
  ilo    = node(ndilo, mptr)
  ihi    = node(ndihi, mptr)
  jlo    = node(ndjlo, mptr)
  jhi    = node(ndjhi, mptr)
  level  = node(nestlevel, mptr)
  hx     = hxposs(level)
  hy     = hyposs(level)

  xlowithghost = xleft  - ng*hx
  xhiwithghost = xright + ng*hx
  ylowithghost =  ybot  - ng*hy
  yhiwithghost =  ytop  + ng*hy
  ! used in filaptch for bc2amr: for patches it is called. for full grids called from bound below
  patchonly = .false.  




  ! left boundary
  xl = xleft - ng*hx
  xr = xleft
  yb = ybot 
  yt = ytop
  if ((xl < xlower) .and. xperdom) then
     call  prefilrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot,1,ng+1, &
          ilo-ng,ilo-1,jlo,jhi,ilo-ng,ihi+ng,jlo-ng,jhi+ng,patchonly)
  else
     call filrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot,1,ng+1,ilo-ng,ilo-1,jlo,jhi,patchonly,mptr)
  endif

  ! right boundary
  xl = xright
  xr = xright + ng*hx
  yb = ybot
  yt = ytop

  if ((xr .gt. xupper) .and. xperdom) then
     call  prefilrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot, &
          mitot-ng+1,ng+1,ihi+1,ihi+ng,jlo,jhi,ilo-ng,ihi+ng,jlo-ng,jhi+ng,patchonly)
  else
     call filrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot, &
          mitot-ng+1,ng+1,ihi+1,ihi+ng,jlo,jhi,patchonly,mptr)
  endif

  ! bottom boundary
  xl = xleft  - ng*hx
  xr = xright + ng*hx
  yb = ybot - ng*hy
  yt = ybot

  if ( ((yb < ylower) .and. (yperdom .or. spheredom)) .or. &
       ( ((xl < xlower) .or. (xr > xupper)) .and. xperdom) ) then
     call prefilrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot,   &
                      1,1,ilo-ng,ihi+ng,jlo-ng,jlo-1,                &
                      ilo-ng,ihi+ng,jlo-ng,jhi+ng,patchonly)
  else
     call filrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot,1,1,ilo-ng,ihi+ng,jlo-ng,jlo-1,patchonly,mptr)
  endif


  ! top boundary
  xl = xleft - ng*hx
  xr = xright + ng*hx
  yb = ytop
  yt = ytop + ng*hy

  if ( ((yt .gt. yupper) .and. (yperdom .or. spheredom)) .or. &
       (((xl .lt. xlower) .or. (xr .gt. xupper)) .and. xperdom) ) then
     call prefilrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot, &
          1,mjtot-ng+1,ilo-ng,ihi+ng,jhi+1,jhi+ng,ilo-ng,ihi+ng,jlo-ng,jhi+ng,patchonly)
  else
     call filrecur(level,nvar,valbig,aux,naux,time,mitot,mjtot, &
          1,mjtot-ng+1,ilo-ng,ihi+ng,jhi+1,jhi+ng,patchonly,mptr)
  endif


  ! set all exterior (physical)  boundary conditions for this grid at once
  ! used to be done from filpatch, but now only for recursive calls with new patch
  ! where the info matches. more efficient to do whole grid at once, and avoid copying
  call bc2amr(valbig,aux,mitot,mjtot,nvar,naux,hx,hy,level,time,    &
              xlowithghost,xhiwithghost,ylowithghost,yhiwithghost)

Here is the call graph for this function:

Here is the caller graph for this function: