c
c =========================================================
subroutine rpn2euznd(ixy,maxm,meqn,mwaves,mbc,mx,ql,qr,maux,
& auxl,auxr,wave,s,amdq,apdq)
c =========================================================
c
c # Riemann solver for the 2D ZND-Euler equations.
c # The waves are computed using the Roe approximation.
c
c # On input, ql contains the state vector at the left edge of each cell
c # qr contains the state vector at the right edge of each cell
c
c # This data is along a slice in the x-direction if ixy=1
c # or the y-direction if ixy=2.
c # On output, wave contains the waves,
c # s the speeds,
c # amdq the left-going flux difference A^- \Delta q
c # apdq the right-going flux difference A^+ \Delta q
c
c # Note that the i'th Riemann problem has left state qr(i-1,:)
c # and right state ql(i,:)
c # From the basic clawpack routines, this routine is called with ql = qr
c
c # Author: Ralf Deiterding (based on rpn2euexact.f)
c
implicit double precision (a-h,o-z)
c
dimension wave(1-mbc:maxm+mbc, meqn, mwaves)
dimension s(1-mbc:maxm+mbc, mwaves)
dimension ql(1-mbc:maxm+mbc, meqn)
dimension qr(1-mbc:maxm+mbc, meqn)
dimension apdq(1-mbc:maxm+mbc, meqn)
dimension amdq(1-mbc:maxm+mbc, meqn)
c
c local arrays -- common block comroe is passed to rpt2eu
c ------------
parameter (maxm2 = 10005) !# assumes at most 10000x10000 grid with mbc=5
parameter (minm2 = -4) !# assumes at most mbc=5
dimension delta(5)
dimension f0(minm2:maxm2,5), fl(minm2:maxm2,5), fr(minm2:maxm2,5)
dimension sl(2), sr(2)
common /param/ gamma,gamma1,q0
common /comroe/ u2v2(minm2:maxm2),u(minm2:maxm2),v(minm2:maxm2),
& enth(minm2:maxm2),a(minm2:maxm2),Y(2,minm2:maxm2)
c
c # Riemann solver returns flux differences
c ------------
common /rpnflx/ mrpnflx
mrpnflx = 0
c
if (minm2.gt.1-mbc .or. maxm2 .lt. maxm+mbc) then
write(6,*) 'need to increase maxm2 in rpA'
stop
endif
c
c # set mu to point to the component of the system that corresponds
c # to momentum in the direction of this slice, mv to the orthogonal
c # momentum:
c
if (ixy.eq.1) then
mu = 3
mv = 4
else
mu = 4
mv = 3
endif
c
c # note that notation for u and v reflects assumption that the
c # Riemann problems are in the x-direction with u in the normal
c # direciton and v in the orthogonal direcion, but with the above
c # definitions of mu and mv the routine also works with ixy=2
c # and returns, for example, f0 as the Godunov flux g0 for the
c # Riemann problems u_t + g(u)_y = 0 in the y-direction.
c
c
c # compute the Roe-averaged variables needed in the Roe solver.
c # These are stored in the common block comroe since they are
c # later used in routine rpt2eu to do the transverse wave splitting.
c
do 10 i=2-mbc,mx+mbc
c
pl = gamma1*(qr(i-1,5) - qr(i-1,2)*q0 -
& 0.5d0*(qr(i-1,mu)**2+qr(i-1,mv)**2)/(qr(i-1,1)+qr(i-1,2)))
pr = gamma1*(ql(i, 5) - ql(i, 2)*q0 -
& 0.5d0*(ql(i, mu)**2+ql(i, mv)**2)/(ql(i, 1)+ql(i, 2)))
rhsqrtl = dsqrt(qr(i-1,1) + qr(i-1,2))
rhsqrtr = dsqrt(ql(i, 1) + ql(i, 2))
rhsq2 = rhsqrtl + rhsqrtr
u(i) = (qr(i-1,mu)/rhsqrtl + ql(i,mu)/rhsqrtr) / rhsq2
v(i) = (qr(i-1,mv)/rhsqrtl + ql(i,mv)/rhsqrtr) / rhsq2
u2v2(i) = u(i)**2 + v(i)**2
enth(i) = (((qr(i-1,5)+pl)/rhsqrtl
& + (ql(i ,5)+pr)/rhsqrtr)) / rhsq2
Y(1,i) = (qr(i-1,1)/rhsqrtl + ql(i,1)/rhsqrtr) / rhsq2
Y(2,i) = (qr(i-1,2)/rhsqrtl + ql(i,2)/rhsqrtr) / rhsq2
c # speed of sound
a2 = gamma1*(enth(i) - 0.5d0*u2v2(i) - Y(2,i)*q0)
a(i) = dsqrt(a2)
c
10 continue
c
do 30 i=2-mbc,mx+mbc
c
c # find a1 thru a3, the coefficients of the 4 eigenvectors:
c
do k = 1, 5
delta(k) = ql(i,k) - qr(i-1,k)
enddo
drho = delta(1) + delta(2)
c
a2 = gamma1/a(i)**2 * (drho*0.5d0*u2v2(i) - delta(2)*q0
& - (u(i)*delta(mu)+v(i)*delta(mv)) + delta(5))
a3 = delta(mv) - v(i)*drho
a4 = 0.5d0*( a2 - ( u(i)*drho - delta(mu) )/a(i) )
a1 = a2 - a4
c
c # Compute the waves.
c
c # 1-wave
wave(i,1,1) = a1*Y(1,i)
wave(i,2,1) = a1*Y(2,i)
wave(i,mu,1) = a1*(u(i) - a(i))
wave(i,mv,1) = a1*v(i)
wave(i,5,1) = a1*(enth(i) - u(i)*a(i))
s(i,1) = u(i)-a(i)
c
c # 2-wave
wave(i,1,2) = delta(1) - Y(1,i)*a2
wave(i,2,2) = delta(2) - Y(2,i)*a2
wave(i,mu,2) = (drho - a2)*u(i)
wave(i,mv,2) = (drho - a2)*v(i) + a3
wave(i,5,2) = (drho - a2)*0.5d0*u2v2(i) +
& q0*(delta(2) - Y(2,i)*a2) + a3*v(i)
s(i,2) = u(i)
c
c # 3-wave
wave(i,1,3) = a4*Y(1,i)
wave(i,2,3) = a4*Y(2,i)
wave(i,mu,3) = a4*(u(i) + a(i))
wave(i,mv,3) = a4*v(i)
wave(i,5,3) = a4*(enth(i) + u(i)*a(i))
s(i,3) = u(i)+a(i)
c
30 continue
c
c # compute Godunov flux f0:
c --------------------------
c
c # compute Godunov flux f0 at each interface.
c # Uses exact Riemann solver
c
do 200 i = 2-mbc, mx+mbc
c
rhol = qr(i-1,1) + qr(i-1,2)
rhor = ql(i ,1) + qr(i ,2)
Y2l = qr(i-1,2)/rhol
Y2r = ql(i ,2)/rhor
ul = qr(i-1,mu)/rhol
ur = ql(i ,mu)/rhor
vl = qr(i-1,mv)/rhol
vr = ql(i ,mv)/rhor
pl = gamma1*(qr(i-1,5) - qr(i-1,2)*q0 - 0.5d0*(ul**2+vl**2)*rhol)
pr = gamma1*(ql(i, 5) - ql(i, 2)*q0 - 0.5d0*(ur**2+vr**2)*rhor)
c
c # iterate to find pstar, ustar:
c
alpha = 1.
pstar = 0.5*(pl+pr)
wr = dsqrt(pr*rhor) * phi(pstar/pr)
wl = dsqrt(pl*rhol) * phi(pstar/pl)
c if (pl.eq.pr .and. rhol.eq.rhor) go to 60
c
40 do 50 iter=1,20
p1 = (ul-ur+pr/wr+pl/wl) / (1./wr + 1./wl)
pstar = dmax1(p1,1d-6)*alpha + (1.-alpha)*pstar
wr1 = wr
wl1 = wl
wr = dsqrt(pr*rhor) * phi(pstar/pr)
wl = dsqrt(pl*rhol) * phi(pstar/pl)
if (dmax1(abs(wr1-wr),dabs(wl1-wl)) .lt. 1d-6)
& go to 60
50 continue
c
c # nonconvergence:
alpha = alpha/2.
if (alpha .gt. 0.001) go to 40
write(6,*) 'no convergence',wr1,wr,wl1,wl
wr = .5*(wr+wr1)
wl = .5*(wl+wl1)
c
60 continue
ustar = (pl-pr+wr*ur+wl*ul) / (wr+wl)
c
c # left wave:
c ============
c
if (pstar .gt. pl) then
c
c # shock:
sl(1) = ul - wl/rhol
sr(1) = sl(1)
rho1 = wl/(ustar-sl(1))
c
else
c
c # rarefaction:
cl = dsqrt(gamma*pl/rhol)
cstar = cl + 0.5*gamma1*(ul-ustar)
sl(1) = ul-cl
sr(1) = ustar-cstar
rho1 = (pstar/pl)**(1./gamma) * rhol
endif
c
c # right wave:
c =============
c
if (pstar .ge. pr) then
c
c # shock
sl(2) = ur + wr/rhor
sr(2) = sl(2)
rho2 = wr/(sl(2)-ustar)
c
else
c
c # rarefaction:
cr = dsqrt(gamma*pr/rhor)
cstar = cr + 0.5*gamma1*(ustar-ur)
sr(2) = ur+cr
sl(2) = ustar+cstar
rho2 = (pstar/pr)**(1./gamma)*rhor
endif
c
c # compute flux:
c ===============
c
c # compute state (rhos,us,ps) at x/t = 0:
c
if (sl(1).gt.0) then
rhos = rhol
us = ul
ps = pl
vs = vl
Y2s = Y2l
else if (sr(1).le.0. .and. ustar.ge. 0.) then
rhos = rho1
us = ustar
ps = pstar
vs = vl
Y2s = Y2l
else if (ustar.lt.0. .and. sl(2).ge. 0.) then
rhos = rho2
us = ustar
ps = pstar
vs = vr
Y2s = Y2r
else if (sr(2).lt.0) then
rhos = rhor
us = ur
ps = pr
vs = vr
Y2s = Y2r
else if (sl(1).le.0. .and. sr(1).ge.0.) then
c # transonic 1-rarefaction
us = (gamma1*ul + 2.*cl)/(gamma+1.)
e0 = pl/(rhol**gamma)
rhos = (us**2/(gamma*e0))**(1./gamma1)
ps = e0*rhos**gamma
vs = vl
Y2s = Y2l
else if (sl(2).le.0. .and. sr(2).ge.0.) then
c # transonic 3-rarefaction
us = (gamma1*ur - 2.*cr)/(gamma+1.)
e0 = pr/(rhor**gamma)
rhos = (us**2/(gamma*e0))**(1./gamma1)
ps = e0*rhos**gamma
vs = vr
Y2s = Y2r
endif
c
f0(i,1) = (1.d0-Y2s)*rhos*us
f0(i,2) = Y2s*rhos*us
f0(i,mu) = rhos*us**2 + ps
f0(i,mv) = rhos*us*vs
f0(i,5) = us*(gamma*ps/gamma1 + Y2s*rhos*q0 +
& 0.5*rhos*(us**2+vs**2))
200 continue
c
c # compute fluxes in each cell:
c
do 210 i = 1-mbc, mx+mbc
c
c # at left edge of cell:
rho = ql(i,1)+ql(i,2)
ul = ql(i,mu)/rho
p = gamma1*(ql(i,5) - ql(i,2)*q0 -
& 0.5d0*(ql(i,mu)**2+ql(i,mv)**2)/rho)
fl(i,1) = ql(i,1)*ul
fl(i,2) = ql(i,2)*ul
fl(i,mu) = ql(i,mu)*ul + p
fl(i,mv) = ql(i,mv)*ul
fl(i,5) = ul*(ql(i,5) + p)
c
c # at right edge of cell:
rho = qr(i,1)+qr(i,2)
ur = qr(i,mu)/rho
p = gamma1*(qr(i,5) - qr(i,2)*q0 -
& 0.5d0*(qr(i,mu)**2+qr(i,mv)**2)/rho)
fr(i,1) = qr(i,1)*ur
fr(i,2) = qr(i,2)*ur
fr(i,mu) = qr(i,mu)*ur + p
fr(i,mv) = qr(i,mv)*ur
fr(i,5) = ur*(qr(i,5) + p)
c
210 continue
c
c # compute the leftgoing and rightgoing flux differences:
do 220 m=1,meqn
do 220 i = 2-mbc, mx+mbc
amdq(i,m) = f0(i,m) - fr(i-1,m)
apdq(i,m) = fl(i,m) - f0(i,m)
220 continue
c
return
end
c
c
double precision function phi(w)
implicit double precision (a-h,o-z)
common /param/ gamma,gamma1,q0
c
sqg = dsqrt(gamma)
if (w .gt. 1.) then
phi = dsqrt(w*(gamma+1.)/2. + gamma1/2.)
else if (w .gt. 0.99999) then
phi = sqg
else if (w .gt. .999) then
phi = sqg + (2*gamma**2 - 3.*gamma + 1)
& *(w-1.) / (4.*sqg)
else
phi = gamma1*(1.-w) / (2.*sqg*(1.-w**(gamma1/(2.*gamma))))
endif
return
end