def get_stability(self, state, markers1=None, markers2=None): dico = deepcopy(self.get_dictionary()) param = self.get_required_param() for p in param: dico['parameters'][p] = state[p] scheme = pylbm.Scheme(dico) stab = pylbm.Stability(scheme) consm0 = [0.] * len(stab.consm) for k, moment in enumerate(stab.consm): consm0[k] = state.get(moment, 0.) n_wv = 1024 v_xi, eigs = stab.eigenvalues(consm0, n_wv) nx = v_xi.shape[1] if markers1 is not None: pos0 = np.empty((nx * stab.nvtot, 2)) for k in range(stab.nvtot): pos0[nx * k:nx * (k + 1), 0] = np.real(eigs[:, k]) pos0[nx * k:nx * (k + 1), 1] = np.imag(eigs[:, k]) markers1.set_offsets(pos0) if markers2 is not None: pos1 = np.empty((nx * stab.nvtot, 2)) for k in range(stab.nvtot): pos1[nx * k:nx * (k + 1), 0] = np.max(v_xi, axis=0) pos1[nx * k:nx * (k + 1), 1] = np.abs(eigs[:, k]) markers2.set_offsets(pos1) return stab
def scheme_constructor(ux, uy, s_mu, s_eta): rhoo = 1. la = 1. s3 = s_mu s4 = s3 s5 = s4 s6 = s4 s7 = s_eta s8 = s7 s = [0., 0., 0., s3, s4, s5, s6, s7, s8] dummy = 1. / (LA**2 * rhoo) qx2 = dummy * qx**2 qy2 = dummy * qy**2 q2 = qx2 + qy2 qxy = dummy * qx * qy dico = { 'dim': 2, 'scheme_velocity': la, 'parameters': { LA: la }, 'schemes': [ { 'velocities': list(range(9)), 'conserved_moments': [rho, qx, qy], 'polynomials': [ 1, LA * X, LA * Y, 3 * (X**2 + Y**2) - 4, 0.5 * (9 * (X**2 + Y**2)**2 - 21 * (X**2 + Y**2) + 8), 3 * X * (X**2 + Y**2) - 5 * X, 3 * Y * (X**2 + Y**2) - 5 * Y, X**2 - Y**2, X * Y ], 'relaxation_parameters': s, 'equilibrium': [ rho, qx, qy, -2 * rho + 3 * q2, rho + 1.5 * q2, -qx / LA, -qy / LA, qx2 - qy2, qxy ], }, ], 'stability': { 'linearization': { rho: rhoo, qx: ux, qy: uy }, 'test_maximum_principle': False, 'test_L2_stability': False, }, } return pylbm.Scheme(dico)
def __call__(self, config, extra_config=None): scheme = pylbm.Scheme(config) stab = pylbm.Stability(scheme) n_wv = 1024 for state in self.states: consm0 = [0.] * len(stab.consm) for k, moment in enumerate(stab.consm): consm0[k] = state.get(moment, 0.) stab.eigenvalues(consm0, n_wv, extra_config) if not stab.is_stable_l2: return False return True
def scheme_constructor(ux, sq, sE): dico = { 'dim': 1, 'scheme_velocity': 1., 'schemes': [ { 'velocities': list(range(3)), 'conserved_moments': u, 'polynomials': [1, X, X**2], 'equilibrium': [u, ux * u, (2 * ux**2 + 1) / 3 * u], 'relaxation_parameters': [0., sq, sE], }, ], 'stability': { 'test_maximum_principle': False, 'test_L2_stability': False, }, } return pylbm.Scheme(dico)
# 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)
# Authors: # Loic Gouarin <*****@*****.**> # Benjamin Graille <*****@*****.**> # # License: BSD 3 clause """ Example of a D1Q3 for the wave equation """ import sympy as sp import pylbm u, v, X = sp.symbols('u, v, X') c = 0.5 d = { 'dim': 1, 'scheme_velocity': 1., 'schemes': [{ 'velocities': [0, 1, 2], 'conserved_moments': [u, v], 'polynomials': [1, X, 0.5*X**2], 'equilibrium': [u, v, .5*c**2*u], 'relaxation_parameters': [0., 0., 1.9], }, ], } s = pylbm.Scheme(d) print(s)
def get_information(self): scheme = pylbm.Scheme(self.get_dictionary()) return scheme
def get_eqpde(self): scheme = pylbm.Scheme(self.get_dictionary()) eqpde = pylbm.EquivalentEquation(scheme) return eqpde
'polynomials': [1, X, Y, X**2 - Y**2], 'relaxation_parameters': [0, S_1, S_1, S_2], 'equilibrium': [U, CX * U, CY * U, (CX**2 - CY**2) * U], }, ], 'parameters': { LA: la, S_1: s_1, S_2: s_2, CX: c_x, CY: c_y, }, 'relative_velocity': [CX, CY], } scheme = pylbm.Scheme(dico) stab = pylbm.Stability(scheme) stab.visualize({ 'parameters': { CX: { 'range': [0, 1], 'init': c_x, 'step': 0.01, }, CY: { 'range': [0, 1], 'init': c_y, 'step': 0.01, }, S_1: { 'name': r"$s_1$",
import sympy as sp import pylbm # pylint: disable=invalid-name U, X = sp.symbols('u, X') LA, SIGMA = sp.symbols('lambda, sigma', constants=True) scheme_cfg = { 'dim': 1, 'scheme_velocity': LA, 'schemes': [ { 'velocities': [1, 2], 'conserved_moments': U, 'polynomials': [1, X], 'equilibrium': [U, U**2/2], 'relaxation_parameters': [0, 1/(0.5+SIGMA)], }, ], 'parameters': { LA: 1., SIGMA: 1./1.9-.5, }, } scheme = pylbm.Scheme(scheme_cfg, formal=True) eq_pde = pylbm.EquivalentEquation(scheme) print(eq_pde)
'polynomials': [1, X], 'relaxation_parameters': [0, S_P], 'equilibrium': [E, GAMMA * E * Q / RHO - (GAMMA - 1) / 2 * Q**3 / RHO**2], }, ], 'parameters': { LA: la, S_RHO: s_rho, S_U: s_u, S_P: s_p, GAMMA: gamma, }, } scheme = pylbm.Scheme(dico, formal=True) stab = pylbm.Stability(scheme) # linearization around a state rhoo = 1 uo = 0.5 po = 1 qo = rhoo * uo Eo = .5 * rhoo * uo**2 + po / (gamma - 1.) stab.visualize({ 'linearization': { RHO: rhoo, Q: qo, E: Eo, },