# src/2d/equations/euler/rp/bcouteu2.f

```!-----------------------------------------------------------------------
! Physical boundary conditions for 2d Euler equations.
! Zero order outflow at all sides.
! Interface:
!   mx,my    := shape of grid function
!
!   u(,) := grid function
!
!   lb(2) := lower bound for grid
!   ub(2) := upper bound for grid
!   lbbnd(2) := lower bound for boundary region
!   ubnd(2) := upper bound for boundary region
!   shapebnd(2) := shape of boundary region
!   xc(2) := lower left corner of grid
!   dx(2) := grid spacing
!   dir := at which side of the grid is the boundary?
!   bnd(,2,2) := lower left and upper right corner of global grid and
!      of mb-1 internal boundary regions
!
! The implementation is quite general, because
! - a boundary region can have a width of 1 or 2 ghost cells.
! - corners of a grid might be part of two boundaries and it is NOT
!   guaranteed that ALL cells of a particular corner region are
!   contained in both boundaries.
!
! Copyright (C) 2002 Ralf Deiterding
! Brandenburgische Universitaet Cottbus
!
! Copyright (C) 2003-2007 California Institute of Technology
! Ralf Deiterding, ralf@amroc.net
!
!-----------------------------------------------------------------------

subroutine physbd(u,mx,my,lb,ub,lbbnd,ubbnd,shapebnd,
&     xc,dx,dir,bnd,mb,time,meqn)

implicit none

integer   mx, my, meqn, mb, dir
integer   lb(2), ub(2), lbbnd(2), ubbnd(2), shapebnd(2)
double precision u(meqn, mx, my), xc(2), dx(2), bnd(mb,2,2), time

!      Local variables
integer   i, j, imin, imax, jmin, jmax, m
integer   stride, getindx

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
!      See definition of member-function extents() in BBox.h
!      for calculation of stride

stride = (ub(1) - lb(1))/(mx-1)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
!     Find working domain

imin = getindx(max(lbbnd(1), lb(1)), lb(1), stride)
imax = getindx(min(ubbnd(1), ub(1)), lb(1), stride)

jmin = getindx(max(lbbnd(2), lb(2)), lb(2), stride)
jmax = getindx(min(ubbnd(2), ub(2)), lb(2), stride)

go to (100,200,300,400) dir+1

!        Left Side --- Outflow
!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
100  continue
do 110 i = imax, imin, -1
if (xc(1)+(i-0.5d0)*dx(1).lt.bnd(1,1,1)) then
do 120 j = jmin, jmax
do 120 m = 1, meqn
u(m,i,j) = u(m,i+1,j)
120        continue
endif
110  continue
return

!        Right Side --- Outflow
!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
200  continue
do 210 i = imin, imax
if (xc(1)+(i-0.5d0)*dx(1).gt.bnd(1,2,1)) then
do 220 j = jmin, jmax
do 220 m = 1, meqn
u(m,i,j) = u(m,i-1,j)
220        continue
endif
210  continue
return

!        Bottom Side --- Outflow
!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
300  continue
do 310 j = jmax, jmin, -1
if (xc(2)+(j-0.5d0)*dx(2).lt.bnd(1,1,2)) then
do 320 i = imin, imax
do 320 m = 1, meqn
u(m,i,j) = u(m,i,j+1)
320        continue
endif
310  continue
return

!        Top Side --- Outflow
!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
400  continue
do 410 j = jmin, jmax
if (xc(2)+(j-0.5d0)*dx(2).gt.bnd(1,2,2)) then
do 420 i = imin, imax
do 420 m = 1, meqn
u(m,i,j) = u(m,i,j-1)
420        continue
endif
410  continue
return

end
```

<