def solve_with_pt0_rtt0(self, pt0, rtt0):
def dpt(p):
return self._pt0_from_pstar_rtt0(p, rtt0) - pt0
self._pstar = fsolve(dpt,
self._pstar_estimate_expansion(pt0),
xtol=1e-10)
self._ustar = self._qR.u + self._delta_uR(self._pstar)
# finalize qstarR state
if (self._pstar > self._qR.p):
_rho = self._qR.rho_through_shock(self._pstar)
self._qstarR = uq.unsteady_state(rho=_rho,
u=self._ustar,
p=self._pstar,
gamma=self._qR._gamma)
else:
_rho = self._qR.rho_through_isentropic(self._pstar)
self._qstarR = uq.unsteady_state(rho=_rho,
u=self._ustar,
p=self._pstar,
gamma=self._qR._gamma)
#
self._qstarL = self._qR.copy()
self._qstarL.compute_from_pt_rtt_u(pt0, rtt0, self._ustar)
return
def __init__(self, qL, qR): self._qL = qL.copy() self._qR = qR.copy() self._waves = 5*[0] # define _pstar self._solve() self._ustar = self._ustar_from_pstar(self._pstar) self._waves[2] = self._ustar # # finalize qstarL state if (self._pstar > self._qL.p): _rho = self._qL.rho_through_shock(self._pstar) _wsh = (self._qL.massflow()-_rho*self._ustar)/(self._qL.rho-_rho) self._waves[0] = _wsh self._waves[1] = _wsh self._qstarL = uq.unsteady_state(rho=_rho, u=self._ustar, p=self._pstar, gamma=self._qL._gamma) else: _rho = self._qL.rho_through_isentropic(self._pstar) self._qstarL = uq.unsteady_state(rho=_rho, u=self._ustar, p=self._pstar, gamma=self._qL._gamma) self._waves[0] = self._qL.u - self._qL.asound() self._waves[1] = self._ustar - self._qstarL.asound() # # finalize qstarR state if (self._pstar > self._qR.p): _rho = self._qR.rho_through_shock(self._pstar) _wsh = (self._qR.massflow()-_rho*self._ustar)/(self._qR.rho-_rho) self._waves[3] = _wsh self._waves[4] = _wsh self._qstarR = uq.unsteady_state(rho=_rho, u=self._ustar, p=self._pstar, gamma=self._qR._gamma) else: _rho = self._qR.rho_through_isentropic(self._pstar) self._qstarR = uq.unsteady_state(rho=_rho, u=self._ustar, p=self._pstar, gamma=self._qR._gamma) self._waves[3] = self._ustar + self._qstarR.asound() self._waves[4] = self._qR.u + self._qR.asound()
def test_expansion_shock():
qL = uq.unsteady_state(rho=2., u=0., p=10.)
qR = uq.unsteady_state(rho=1., u=0., p=1.)
pb = riem.riemann_pb(qL, qR)
assert pb.left_fastest() == pytest.approx(
qL.left_acoustic(), rel=1e-10) # expansion has C- from qL
assert pb.right_fastest() > qR.right_acoustic(
) # shock wave is faster than qR C+
def test_expansion_expansion():
qL = uq.unsteady_state(rho=1., u=-.3, p=1.2)
qR = uq.unsteady_state(rho=1., u=.2, p=1.)
pb = riem.riemann_pb(qL, qR)
assert pb.left_fastest() == pytest.approx(
qL.left_acoustic(), rel=1e-10) # expansion has C- from qL
assert pb.right_fastest() == pytest.approx(
qR.right_acoustic(), rel=1e-10) # expansion has C+ from qR
def test_expansion_shock_symmetry():
qL = uq.unsteady_state(rho=2., u=0., p=10.)
qR = uq.unsteady_state(rho=1., u=0., p=1.)
pb1 = riem.riemann_pb(qL, qR)
pb2 = riem.riemann_pb(qR, qL)
assert pb2.pstar() == pytest.approx(pb1.pstar(), rel=1e-10)
assert pb2.left_fastest() == pytest.approx(-pb1.right_fastest(), rel=1e-10)
assert pb2.right_fastest() == pytest.approx(-pb1.left_fastest(), rel=1e-10)
def __init__(self, model, primL, primR):
self.model = model
self.rhoL, self.uL, self.pL = primL
self.rhoR, self.uR, self.pR = primR
gam = self.model.gamma
qL = uq.unsteady_state(self.rhoL, self.uL, self.pL, gam)
qR = uq.unsteady_state(self.rhoR, self.uR, self.pR, gam)
# Riemann problem
self.riempb = riem.riemann_pb(qL, qR)
def test_expansion_expansion_shift():
qL1 = uq.unsteady_state(rho=2., u=-1.2, p=1.2)
qR1 = uq.unsteady_state(rho=1., u=0.3, p=1.3)
pb1 = riem.riemann_pb(qL1, qR1)
qL2 = uq.unsteady_state(rho=2., u=-0.2, p=1.2)
qR2 = uq.unsteady_state(rho=1., u=1.3, p=1.3)
pb2 = riem.riemann_pb(qL2, qR2)
assert pb2.pstar() == pytest.approx(pb1.pstar(), rel=1e-10)
assert pb2.left_fastest() - pb1.left_fastest() == pytest.approx(
1., rel=1e-10) # shift u = 1
assert pb2.right_fastest() - pb1.right_fastest() == pytest.approx(
1., rel=1e-10)
assert pb2.ustar() - pb1.ustar() == pytest.approx(1., rel=1e-10)
def test_shock_shock():
qL = uq.unsteady_state(rho=1., u=.3, p=1.)
qR = uq.unsteady_state(rho=1., u=-.2, p=1.1)
pb = riem.riemann_pb(qL, qR)
assert pb.left_fastest() < qL.left_acoustic(
) # shock wave is faster than qL C-
assert pb.right_fastest() > qR.right_acoustic(
) # shock wave is faster than qR C+
for Ws, q0, q1 in ((pb.left_fastest(), qL, pb.qstarL()),
(pb.right_fastest(), qR, pb.qstarR())):
# mass balance
assert q1.massflow() - q0.massflow() == pytest.approx(
Ws * (q1.rho - q0.rho))
# momentum balance
assert q1.u * q1.massflow() - q0.u * q0.massflow(
) + q1.p - q0.p == pytest.approx(Ws * (q1.massflow() - q0.massflow()))
def qsol(self, xot): """ xot: x/t numpy array """ # left uniform part (initialization) rho = self._qL.rho * np.ones(len(xot)) u = self._qL.u * np.ones(len(xot)) p = self._qL.p * np.ones(len(xot)) # left star uniform part i = np.logical_and((xot >= self._waves[1]), (xot < self._waves[2])) rho[i] = self._qstarL.rho u[i] = self._qstarL.u p[i] = self._qstarL.p # right star uniform part i = np.logical_and((xot >= self._waves[2]), (xot < self._waves[3])) rho[i] = self._qstarR.rho u[i] = self._qstarR.u p[i] = self._qstarR.p # right uniform part i = (xot >= self._waves[4]) rho[i] = self._qR.rho u[i] = self._qR.u p[i] = self._qR.p # if left expansion if (self._pstar < self._qL.p): i = np.logical_and((xot > self._waves[0]), (xot < self._waves[1])) gam = self._qL._gamma gp1 = gam+1. gm1 = gam-1. u[i] = gm1/gp1*(self._qL.u + 2./gm1*(self._qL.asound()+xot[i])) p[i] = self._qL.p * ( (u[i] - xot[i])/self._qL.asound() )**(2.*gam/gm1) rho[i] = self._qL.rho_through_isentropic(p[i]) # if right expansion if (self._pstar < self._qR.p): i = np.logical_and((xot > self._waves[3]), (xot < self._waves[4])) gam = self._qR._gamma gp1 = gam+1. gm1 = gam-1. u[i] = gm1/gp1*(self._qR.u + 2./gm1*(-self._qR.asound()+xot[i])) p[i] = self._qR.p * ( (xot[i] - u[i] )/self._qR.asound() )**(2.*gam/gm1) rho[i] = self._qR.rho_through_isentropic(p[i]) return uq.unsteady_state(rho, u, p, np.where(xot<0., self._qL._gamma, self._qR._gamma))
def test_init_q():
q = uq.unsteady_state(rho=1.4, u=2., p=1.)
assert q.asound() == pytest.approx(1., rel=1e-10)
assert q.Mach() == pytest.approx(2., rel=1e-10)
def test_init_Pt_rTt_p():
q = uq.unsteady_state(1., 0., 1.)
q.compute_from_pt_rtt_p(pt=1.5, rtt=2., p=1.)
assert q.rTtot() == pytest.approx(2., rel=1e-10)
assert q.Ptot() == pytest.approx(1.5, rel=1e-10)
def test_init_Pt_rTt_u():
q = uq.unsteady_state(1., 0., 1.)
q.compute_from_pt_rtt_u(pt=4., rtt=2., u=-.3)
assert q.rTtot() == pytest.approx(2., rel=1e-10)
assert q.Ptot() == pytest.approx(4., rel=1e-10)
from flowdyn.mesh import unimesh
from flowdyn.field import *
from flowdyn.xnum import *
from flowdyn.integration import rk3ssp
import flowdyn.modelphy.euler as euler
import flowdyn.modeldisc as modeldisc
#import flowdyn.solution.euler_riemann as sol
meshsim = unimesh(ncell=200, length=10., x0=-4.)
meshref = unimesh(ncell=1000, length=10., x0=-4.)
model1 = euler.model()
model2 = euler.model()
# upstream state with Mach number = normalized velocity
uL = uq.unsteady_state(rho=1.4, u=1.8, p=1.)
uR = uL._rankinehugoniot_from_ushock(ushock=0.)
#
bcL = { 'type': 'dirichlet', 'prim': [uL.rho, uL.u, uL.p] }
bcR = { 'type': 'dirichlet', 'prim': [uR.rho, uR.u, uR.p] }
def initdata(x, uL, uR):
rho = uL.rho + (uR.rho-uL.rho)*(x>0.)
u = uL.u + (uR.u-uL.u)*(x>0.)
p = uL.p + (uR.p-uL.p)*(x>0.)
return [rho, u, p]
xnum1 = muscl(minmod) #
xnum2 = muscl(vanalbada) #
rhs1 = modeldisc.fvm(model1, meshsim, xnum1, numflux='rusanov', bcL=bcL, bcR=bcR)
def test_riemann():
pbriem = oldRiem.riemann_pb(uq.unsteady_state(1., -10., 100.),
uq.unsteady_state(1., -20., 1000.))
assert True
