# pylint: disable=invalid-name U, X = sp.symbols('u, X') LA, C, SIGMA = sp.symbols('lambda, c, sigma', constants=True) scheme_cfg = { 'dim': 1, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': U, 'polynomials': [1, X], 'equilibrium': [U, C * U], 'relaxation_parameters': [0, 1 / (0.5 + SIGMA)], }, ], 'parameters': { LA: 1., C: 0.1, SIGMA: 1. / 1.9 - .5, }, } scheme = pylbm.Scheme(scheme_cfg) eq_pde = pylbm.EquivalentEquation(scheme) print(eq_pde)
def run(space_step, final_time, generator="cython", sorder=None, with_plot=True): """ Parameters ---------- space_step: double spatial step final_time: double final time generator: string pylbm generator sorder: list storage order with_plot: boolean if True plot the solution otherwise just compute the solution Returns ------- sol <class 'pylbm.simulation.Simulation'> """ # parameters xmin, xmax = 0., 1. # bounds of the domain gamma = 2. / 3. # exponent in the p-function la = 2. # velocity of the scheme s_1, s_2 = 1.9, 1.9 # relaxation parameters symb_s_1 = 1 / (.5 + SIGMA_1) # symbolic relaxation parameters symb_s_2 = 1 / (.5 + SIGMA_2) # symbolic relaxation parameters # initial values u1_left, u1_right, u2_left, u2_right = 1.50, 0.50, 1.25, 1.50 # fixed bounds of the graphics ymina, ymaxa, yminb, ymaxb = .25, 1.75, 0.75, 1.75 # discontinuity position xmid = .5 * (xmin + xmax) exact_solution = exact_solver({ 'jump abscissa': xmid, 'left state': [u1_left, u2_left], 'right state': [u1_right, u2_right], 'gamma': gamma, }) exact_solution.diagram() simu_cfg = { 'box': { 'x': [xmin, xmax], 'label': 0 }, 'space_step': space_step, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': U1, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_1], 'equilibrium': [U1, -U2], 'init': { U1: (riemann_pb, (xmid, u1_left, u1_right)) }, }, { 'velocities': [1, 2], 'conserved_moments': U2, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_2], 'equilibrium': [U2, U1**(-GAMMA)], 'init': { U2: (riemann_pb, (xmid, u2_left, u2_right)) }, }, ], 'boundary_conditions': { 0: { 'method': { 0: pylbm.bc.Neumann, 1: pylbm.bc.Neumann, }, }, }, 'generator': generator, 'parameters': { LA: la, GAMMA: gamma, SIGMA_1: 1 / s_1 - .5, SIGMA_2: 1 / s_2 - .5, }, } # build the simulation sol = pylbm.Simulation(simu_cfg, sorder=sorder) # build the equivalent PDE eq_pde = pylbm.EquivalentEquation(sol.scheme) print(eq_pde) if with_plot: # create the viewer to plot the solution viewer = pylbm.viewer.matplotlib_viewer fig = viewer.Fig(2, 1) axe1 = fig[0] axe1.axis(xmin, xmax, ymina, ymaxa) axe1.set_label(None, r"$u_1$") axe1.xaxis_set_visible(False) axe2 = fig[1] axe2.axis(xmin, xmax, yminb, ymaxb) axe2.set_label(r"$x$", r"$u_2$") x = sol.domain.x l1a = axe1.CurveScatter( x, sol.m[U1], color='navy', label=r'$D_1Q_2$', ) sole = exact_solution.evaluate(x, sol.t) l1e = axe1.CurveLine( x, sole[0], width=1, color='black', label='exact', ) l2a = axe2.CurveScatter( x, sol.m[U2], color='orange', label=r'$D_1Q_2$', ) l2e = axe2.CurveLine( x, sole[1], width=1, color='black', label='exact', ) axe1.legend(loc='upper right') axe2.legend(loc='upper left') def update(iframe): # pylint: disable=unused-argument if sol.t < final_time: sol.one_time_step() l1a.update(sol.m[U1]) l2a.update(sol.m[U2]) sole = exact_solution.evaluate(x, sol.t) l1e.update(sole[0]) l2e.update(sole[1]) axe1.title = r'p-system at $t = {0:f}$'.format(sol.t) fig.animate(update) fig.show() else: while sol.t < final_time: sol.one_time_step() return sol
def run(space_step, final_time, generator="cython", sorder=None, with_plot=True): """ Parameters ---------- space_step: double spatial step final_time: double final time generator: string pylbm generator sorder: list storage order with_plot: boolean if True plot the solution otherwise just compute the solution Returns ------- sol <class 'pylbm.simulation.Simulation'> """ # parameters xmin, xmax = -1, 1. # bounds of the domain gnum = 1 # numerical value of g la = 2. # velocity of the scheme s_h, s_u = 1.5, 1.5 # relaxation parameters symb_s_h = 1/(.5+SIGMA_H) # symbolic relaxation parameters symb_s_q = 1/(.5+SIGMA_Q) # symbolic relaxation parameters # initial values h_left, h_right, q_left, q_right = 2, 1, .1, 0. # fixed bounds of the graphics ymina, ymaxa = 0.9, 2.1 yminb, ymaxb = -.1, .7 # discontinuity position xmid = .5*(xmin+xmax) exact_solution = exact_solver({ 'jump abscissa': xmid, 'left state': [h_left, q_left], 'right state': [h_right, q_right], 'g': gnum, }) exact_solution.diagram() simu_cfg = { 'box': {'x': [xmin, xmax], 'label': 0}, 'space_step': space_step, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': H, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_h], 'equilibrium': [H, Q], }, { 'velocities': [1, 2], 'conserved_moments': Q, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_q], 'equilibrium': [Q, Q**2/H+.5*G*H**2], }, ], 'init': {H: (riemann_pb, (xmid, h_left, h_right)), Q: (riemann_pb, (xmid, q_left, q_right))}, 'boundary_conditions': { 0: {'method': { 0: pylbm.bc.Neumann, 1: pylbm.bc.Neumann, }, }, }, 'generator': generator, 'parameters': { LA: la, G: gnum, SIGMA_H: 1/s_h-.5, SIGMA_Q: 1/s_u-.5, }, } # build the simulation sol = pylbm.Simulation(simu_cfg, sorder=sorder) # build the equivalent PDE eq_pde = pylbm.EquivalentEquation(sol.scheme) print(eq_pde) if with_plot: # create the viewer to plot the solution viewer = pylbm.viewer.matplotlib_viewer fig = viewer.Fig(2, 1) axe1 = fig[0] axe1.axis(xmin, xmax, ymina, ymaxa) axe1.set_label(None, "height") axe1.xaxis_set_visible(False) axe2 = fig[1] axe2.axis(xmin, xmax, yminb, ymaxb) axe2.set_label(r"$x$", "velocity") x = sol.domain.x l1a = axe1.CurveScatter( x, sol.m[H], color='navy', label=r'$D_1Q_2$', ) sole = exact_solution.evaluate(x, sol.t) l1e = axe1.CurveLine( x, sole[0], width=1, color='black', label='exact', ) l2a = axe2.CurveScatter( x, sol.m[Q]/sol.m[H], color='orange', label=r'$D_1Q_2$', ) l2e = axe2.CurveLine( x, sole[1]/sole[0], width=1, color='black', label='exact', ) axe1.legend(loc='upper right') axe2.legend(loc='upper left') def update(iframe): # pylint: disable=unused-argument if sol.t < final_time: sol.one_time_step() l1a.update(sol.m[H]) l2a.update(sol.m[Q]/sol.m[H]) sole = exact_solution.evaluate(x, sol.t) l1e.update(sole[0]) l2e.update(sole[1]/sole[0]) axe1.title = r'shallow water at $t = {0:f}$'.format(sol.t) fig.animate(update) fig.show() else: while sol.t < final_time: sol.one_time_step() return sol
def run(space_step, final_time, generator="cython", sorder=None, with_plot=True): """ Parameters ---------- space_step: double spatial step final_time: double final time generator: string pylbm generator sorder: list storage order with_plot: boolean if True plot the solution otherwise just compute the solution Returns ------- sol <class 'pylbm.simulation.Simulation'> """ # parameters gamma = 1.4 # ratio of specific heats xmin, xmax = 0., 1. # bounds of the domain la = 3. # velocity of the scheme s_rho, s_u, s_p = 1.9, 1.5, 1.4 # relaxation parameters symb_s_rho = 1 / (.5 + SIGMA_RHO) # symbolic relaxation parameter symb_s_u = 1 / (.5 + SIGMA_U) # symbolic relaxation parameter symb_s_p = 1 / (.5 + SIGMA_P) # symbolic relaxation parameter # initial values rho_left, p_left, u_left = 1, 1, 0 # left state rho_right, p_right, u_right = 1 / 8, 0.1, 0 # right state q_left = rho_left * u_left q_right = rho_right * u_right rhoe_left = rho_left * u_left**2 + p_left / (gamma - 1.) rhoe_right = rho_right * u_right**2 + p_right / (gamma - 1.) # discontinuity position xmid = .5 * (xmin + xmax) exact_solution = exact_solver({ 'jump abscissa': xmid, 'left state': [rho_left, u_left, p_left], 'right state': [rho_right, u_right, p_right], 'gamma': gamma, }) exact_solution.diagram() simu_cfg = { 'box': { 'x': [xmin, xmax], 'label': 0 }, 'space_step': space_step, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': RHO, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_rho], 'equilibrium': [RHO, Q], }, { 'velocities': [1, 2], 'conserved_moments': Q, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_u], 'equilibrium': [Q, (GAMMA - 1) * E + (3 - GAMMA) / 2 * Q**2 / RHO], }, { 'velocities': [1, 2], 'conserved_moments': E, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_p], 'equilibrium': [E, GAMMA * E * Q / RHO - (GAMMA - 1) / 2 * Q**3 / RHO**2], }, ], 'init': { RHO: (riemann_pb, (xmid, rho_left, rho_right)), Q: (riemann_pb, (xmid, q_left, q_right)), E: (riemann_pb, (xmid, rhoe_left, rhoe_right)) }, 'boundary_conditions': { 0: { 'method': { 0: pylbm.bc.Neumann, 1: pylbm.bc.Neumann, 2: pylbm.bc.Neumann, }, }, }, 'parameters': { LA: la, SIGMA_RHO: 1 / s_rho - .5, SIGMA_U: 1 / s_u - .5, SIGMA_P: 1 / s_p - .5, GAMMA: gamma, }, 'generator': generator, } # build the simulation sol = pylbm.Simulation(simu_cfg, sorder=sorder) # build the equivalent PDE eq_pde = pylbm.EquivalentEquation(sol.scheme) print(eq_pde) while sol.t < final_time: sol.one_time_step() if with_plot: x = sol.domain.x rho_n = sol.m[RHO] q_n = sol.m[Q] rhoe_n = sol.m[E] u_n = q_n / rho_n p_n = (gamma - 1.) * (rhoe_n - .5 * rho_n * u_n**2) e_n = rhoe_n / rho_n - .5 * u_n**2 sole = exact_solution.evaluate(x, sol.t) viewer = pylbm.viewer.matplotlib_viewer fig = viewer.Fig(2, 3) fig[0, 0].CurveScatter(x, rho_n, color='navy') fig[0, 0].CurveLine(x, sole[0], color='orange') fig[0, 0].title = 'mass' fig[0, 1].CurveScatter(x, u_n, color='navy') fig[0, 1].CurveLine(x, sole[1], color='orange') fig[0, 1].title = 'velocity' fig[0, 2].CurveScatter(x, p_n, color='navy') fig[0, 2].CurveLine(x, sole[2], color='orange') fig[0, 2].title = 'pressure' fig[1, 0].CurveScatter(x, rhoe_n, color='navy') rhoe_e = .5 * sole[0] * sole[1]**2 + sole[2] / (gamma - 1.) fig[1, 0].CurveLine(x, rhoe_e, color='orange') fig[1, 0].title = 'energy' fig[1, 1].CurveScatter(x, q_n, color='navy') fig[1, 1].CurveLine(x, sole[0] * sole[1], color='orange') fig[1, 1].title = 'momentum' fig[1, 2].CurveScatter(x, e_n, color='navy') fig[1, 2].CurveLine(x, sole[2] / sole[0] / (gamma - 1), color='orange') fig[1, 2].title = 'internal energy' fig.show() return sol
def get_eqpde(self): scheme = pylbm.Scheme(self.get_dictionary()) eqpde = pylbm.EquivalentEquation(scheme) return eqpde
def run(space_step, final_time, generator="cython", sorder=None, with_plot=True): """ Parameters ---------- space_step: double spatial step final_time: double final time generator: string pylbm generator sorder: list storage order with_plot: boolean if True plot the solution otherwise just compute the solution Returns ------- sol <class 'pylbm.simulation.Simulation'> """ # parameters xmin, xmax = 0., 1. # bounds of the domain la = 1. # lattice velocity (la = dx/dt) velocity = 0.25 # velocity of the advection s = 1.9 # relaxation parameter symb_s = 1/(0.5+SIGMA) # symbolic relaxation parameter # initial values u_left, u_right = 1., 0. # discontinuity position if velocity > 0: xmid = 0.75*xmin + .25*xmax elif velocity < 0: xmid = .25*xmin + .75*xmax else: xmid = .5*xmin + .5*xmax # fixed bounds of the graphics ymin = min([u_left, u_right])-.2*abs(u_left-u_right) ymax = max([u_left, u_right])+.2*abs(u_left-u_right) exact_solution = exact_solver({ 'jump abscissa': xmid, 'left state': [u_left], 'right state': [u_right], 'velocity': velocity, }) # dictionary of the simulation simu_cfg = { 'box': {'x': [xmin, xmax], 'label': 0}, 'space_step': space_step, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': U, 'polynomials': [1, X], 'relaxation_parameters': [0., symb_s], 'equilibrium': [U, C*U], 'init': {U: (riemann_pb, (xmid, u_left, u_right))}, }, ], 'boundary_conditions': { 0: {'method': { 0: pylbm.bc.Neumann, }, }, }, 'generator': generator, 'parameters': { LA: la, C: velocity, SIGMA: 1/s-.5 }, 'show_code': False, } # build the simulation sol = pylbm.Simulation(simu_cfg, sorder=sorder) # build the equivalent PDE eq_pde = pylbm.EquivalentEquation(sol.scheme) print(eq_pde) if with_plot: # create the viewer to plot the solution viewer = pylbm.viewer.matplotlib_viewer fig = viewer.Fig() axe = fig[0] axe.axis(xmin, xmax, ymin, ymax) axe.set_label(r'$x$', r'$u$') x = sol.domain.x l1a = axe.CurveScatter( x, sol.m[U], color='navy', label=r'$D_1Q_2$', ) l1e = axe.CurveLine( x, exact_solution.evaluate(x, sol.t)[0], width=1, color='black', label='exact', ) axe.legend(loc='upper right', shadow=False, frameon=False, ) def update(iframe): # pylint: disable=unused-argument if sol.t < final_time: # time loop sol.one_time_step() # increment the solution of one time step l1a.update(sol.m[U]) l1e.update(exact_solution.evaluate(x, sol.t)[0]) axe.title = r'advection at $t = {0:f}$'.format(sol.t) fig.animate(update) fig.show() else: while sol.t < final_time: sol.one_time_step() return sol
def run(space_step, final_time, generator="cython", sorder=None, with_plot=True): """ Parameters ---------- space_step: double spatial step final_time: double final time generator: string pylbm generator sorder: list storage order with_plot: boolean if True plot the solution otherwise just compute the solution Returns ------- sol <class 'pylbm.simulation.Simulation'> """ # parameters xmin, xmax = -1, 1 # bounds of the domain la = 1. # velocity of the scheme c_0 = la / sqrt(3) # velocity of the pressure waves s_rho, s_u = 2., 1.85 # relaxation parameters symb_s_rho = 1 / (.5 + SIGMA_RHO) # symbolic relaxation parameter symb_s_u = 1 / (.5 + SIGMA_U) # symbolic relaxation parameter # initial values rhoo = 1 drho = rhoo / 3 rho_left, u_left = rhoo - drho, 0 # left state rho_right, u_right = rhoo + drho, 0 # right state q_left = rho_left * u_left q_right = rho_right * u_right # fixed bounds of the graphics ymina, ymaxa = rhoo - 2 * drho, rhoo + 2 * drho yminb, ymaxb = -.25, .1 # discontinuity position xmid = .5 * (xmin + xmax) exact_solution = exact_solver({ 'jump abscissa': xmid, 'left state': [rho_left, u_left], 'right state': [rho_right, u_right], 'sound_speed': c_0, }) exact_solution.diagram() simu_cfg = { 'box': { 'x': [xmin, xmax], 'label': 0 }, 'space_step': space_step, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': RHO, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_rho], 'equilibrium': [RHO, Q], 'init': { RHO: (riemann_pb, (xmid, rho_left, rho_right)) }, }, { 'velocities': [1, 2], 'conserved_moments': Q, 'polynomials': [1, X], 'relaxation_parameters': [0, symb_s_u], 'equilibrium': [Q, Q**2 / RHO + CO**2 * RHO], 'init': { Q: (riemann_pb, (xmid, q_left, q_right)) }, }, ], 'boundary_conditions': { 0: { 'method': { 0: pylbm.bc.Neumann, 1: pylbm.bc.Neumann, }, }, }, 'parameters': { LA: la, SIGMA_RHO: 1 / s_rho - .5, SIGMA_U: 1 / s_u - .5, CO: c_0, }, 'generator': generator, } # build the simulation sol = pylbm.Simulation(simu_cfg, sorder=sorder) # build the equivalent PDE eq_pde = pylbm.EquivalentEquation(sol.scheme) print(eq_pde) if with_plot: # create the viewer to plot the solution viewer = pylbm.viewer.matplotlib_viewer fig = viewer.Fig(2, 1) axe1 = fig[0] axe1.axis(xmin, xmax, ymina, ymaxa) axe1.set_label(None, r'$\rho$') axe1.xaxis_set_visible(False) axe2 = fig[1] axe2.axis(xmin, xmax, yminb, ymaxb) axe2.set_label(r"$x$", r"$u$") x = sol.domain.x l1a = axe1.CurveScatter( x, sol.m[RHO], color='navy', label=r'$D_1Q_2$', ) sole = exact_solution.evaluate(x, sol.t) l1e = axe1.CurveLine( x, sole[0], width=1, label='exact', ) l2a = axe2.CurveScatter( x, sol.m[Q] / sol.m[RHO], color='orange', label=r'$D_1Q_2$', ) l2e = axe2.CurveLine( x, sole[1], width=1, label='exact', ) axe1.legend(loc='lower right') axe2.legend(loc='lower right') def update(iframe): # pylint: disable=unused-argument if sol.t < final_time: sol.one_time_step() l1a.update(sol.m[RHO]) l2a.update(sol.m[Q] / sol.m[RHO]) sole = exact_solution.evaluate(x, sol.t) l1e.update(sole[0]) l2e.update(sole[1]) axe1.title = r'isothermal Euler at $t = {0:f}$'.format(sol.t) fig.animate(update) fig.show() else: while sol.t < final_time: sol.one_time_step() return sol