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