def my_rhs(t, state): cv, tseed = state fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tseed) return make_obj_array( [euler_operator(discr, state=fluid_state, time=t, boundaries=boundaries, gas_model=gas_model), 0*tseed])
def my_rhs(t, state): fluid_state = make_fluid_state(state, gas_model) return euler_operator(discr, state=fluid_state, time=t, boundaries=boundaries, gas_model=gas_model)
def test_lump_rhs(actx_factory, dim, order): """Test the inviscid rhs using the non-trivial mass lump case. The case is tested against the analytic expressions of the RHS. Checks several different orders and refinement levels to check error behavior. """ actx = actx_factory() tolerance = 1e-10 maxxerr = 0.0 from pytools.convergence import EOCRecorder eoc_rec = EOCRecorder() for nel_1d in [4, 8, 12]: from meshmode.mesh.generation import ( generate_regular_rect_mesh, ) mesh = generate_regular_rect_mesh( a=(-5, ) * dim, b=(5, ) * dim, nelements_per_axis=(nel_1d, ) * dim, ) logger.info(f"Number of elements: {mesh.nelements}") discr = EagerDGDiscretization(actx, mesh, order=order) nodes = thaw(actx, discr.nodes()) # Init soln with Lump and expected RHS = 0 center = np.zeros(shape=(dim, )) velocity = np.zeros(shape=(dim, )) lump = Lump(dim=dim, center=center, velocity=velocity) lump_soln = lump(nodes) boundaries = { BTAG_ALL: PrescribedInviscidBoundary(fluid_solution_func=lump) } inviscid_rhs = euler_operator(discr, eos=IdealSingleGas(), boundaries=boundaries, cv=lump_soln, time=0.0) expected_rhs = lump.exact_rhs(discr, cv=lump_soln, time=0) err_max = discr.norm((inviscid_rhs - expected_rhs).join(), np.inf) if err_max > maxxerr: maxxerr = err_max eoc_rec.add_data_point(1.0 / nel_1d, err_max) logger.info(f"Max error: {maxxerr}") logger.info(f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}") assert (eoc_rec.order_estimate() >= order - 0.5 or eoc_rec.max_error() < tolerance)
def test_vortex_rhs(actx_factory, order): """Test the inviscid rhs using the non-trivial 2D isentropic vortex. The case is configured to yield rhs = 0. Checks several different orders and refinement levels to check error behavior. """ actx = actx_factory() dim = 2 from pytools.convergence import EOCRecorder eoc_rec = EOCRecorder() from meshmode.mesh.generation import generate_regular_rect_mesh for nel_1d in [32, 48, 64]: mesh = generate_regular_rect_mesh( a=(-5, ) * dim, b=(5, ) * dim, nelements_per_axis=(nel_1d, ) * dim, ) logger.info(f"Number of {dim}d elements: {mesh.nelements}") discr = EagerDGDiscretization(actx, mesh, order=order) nodes = thaw(actx, discr.nodes()) # Init soln with Vortex and expected RHS = 0 vortex = Vortex2D(center=[0, 0], velocity=[0, 0]) vortex_soln = vortex(nodes) boundaries = { BTAG_ALL: PrescribedInviscidBoundary(fluid_solution_func=vortex) } inviscid_rhs = euler_operator(discr, eos=IdealSingleGas(), boundaries=boundaries, cv=vortex_soln, time=0.0) err_max = discr.norm(inviscid_rhs.join(), np.inf) eoc_rec.add_data_point(1.0 / nel_1d, err_max) logger.info(f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}") assert (eoc_rec.order_estimate() >= order - 0.5 or eoc_rec.max_error() < 1e-11)
def my_rhs(t, state): cv, tseed = state from mirgecom.gas_model import make_fluid_state fluid_state = make_fluid_state(cv=cv, gas_model=gas_model, temperature_seed=tseed) return make_obj_array([ euler_operator(discr, state=fluid_state, time=t, boundaries=boundaries, gas_model=gas_model, quadrature_tag=quadrature_tag) + eos.get_species_source_terms(cv, fluid_state.temperature), 0 * tseed ])
def my_rhs(t, state): # check for some troublesome output types inf_exists = not np.isfinite(discr.norm(state, np.inf)) if inf_exists: if rank == 0: logging.info("Non-finite values detected in simulation, exiting...") # dump right now viz_fields = [("sponge_sigma", gen_sponge())] sim_checkpoint(discr=discr, visualizer=visualizer, eos=eos, q=state, vizname=casename, step=999999999, t=t, dt=current_dt, nviz=1, exittol=exittol, constant_cfl=constant_cfl, comm=comm, vis_timer=vis_timer, overwrite=True,s0=s0_sc,kappa=kappa_sc, viz_fields=viz_fields) exit() return ( euler_operator(discr, q=state, t=t,boundaries=boundaries, eos=eos) + artificial_viscosity(discr,t=t, r=state, eos=eos, boundaries=boundaries, alpha=alpha_sc, s0=s0_sc, kappa=kappa_sc) + sponge(q=state, q_ref=ref_state, sigma=sponge_sigma))
def test_vortex_rhs(actx_factory, order, use_overintegration): """Test the inviscid rhs using the non-trivial 2D isentropic vortex. The case is configured to yield rhs = 0. Checks several different orders and refinement levels to check error behavior. """ actx = actx_factory() dim = 2 from pytools.convergence import EOCRecorder eoc_rec = EOCRecorder() from meshmode.mesh.generation import generate_regular_rect_mesh for nel_1d in [32, 48, 64]: mesh = generate_regular_rect_mesh( a=(-5,) * dim, b=(5,) * dim, nelements_per_axis=(nel_1d,) * dim, ) logger.info( f"Number of {dim}d elements: {mesh.nelements}" ) from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD from meshmode.discretization.poly_element import \ default_simplex_group_factory, QuadratureSimplexGroupFactory discr = EagerDGDiscretization( actx, mesh, discr_tag_to_group_factory={ DISCR_TAG_BASE: default_simplex_group_factory( base_dim=dim, order=order), DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1) } ) if use_overintegration: quadrature_tag = DISCR_TAG_QUAD else: quadrature_tag = None nodes = thaw(discr.nodes(), actx) # Init soln with Vortex and expected RHS = 0 vortex = Vortex2D(center=[0, 0], velocity=[0, 0]) vortex_soln = vortex(nodes) gas_model = GasModel(eos=IdealSingleGas()) fluid_state = make_fluid_state(vortex_soln, gas_model) def _vortex_boundary(discr, btag, gas_model, state_minus, **kwargs): actx = state_minus.array_context bnd_discr = discr.discr_from_dd(btag) nodes = thaw(bnd_discr.nodes(), actx) return make_fluid_state(vortex(x_vec=nodes, **kwargs), gas_model) boundaries = { BTAG_ALL: PrescribedFluidBoundary(boundary_state_func=_vortex_boundary) } inviscid_rhs = euler_operator( discr, state=fluid_state, gas_model=gas_model, boundaries=boundaries, time=0.0, quadrature_tag=quadrature_tag) err_max = max_component_norm(discr, inviscid_rhs, np.inf) eoc_rec.add_data_point(1.0 / nel_1d, err_max) logger.info( f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}" ) assert ( eoc_rec.order_estimate() >= order - 0.5 or eoc_rec.max_error() < 1e-11 )
def my_rhs(t, state): return euler_operator(discr, cv=state, t=t, boundaries=boundaries, eos=eos)
def test_multilump_rhs(actx_factory, dim, order, v0, use_overintegration): """Test the Euler rhs using the non-trivial 1, 2, and 3D mass lump case. The case is tested against the analytic expressions of the RHS. Checks several different orders and refinement levels to check error behavior. """ actx = actx_factory() nspecies = 10 tolerance = 1e-8 maxxerr = 0.0 from pytools.convergence import EOCRecorder eoc_rec = EOCRecorder() for nel_1d in [4, 8, 12]: from meshmode.mesh.generation import ( generate_regular_rect_mesh, ) mesh = generate_regular_rect_mesh( a=(-1,) * dim, b=(1,) * dim, nelements_per_axis=(nel_1d,) * dim, ) logger.info(f"Number of elements: {mesh.nelements}") from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD from meshmode.discretization.poly_element import \ default_simplex_group_factory, QuadratureSimplexGroupFactory discr = EagerDGDiscretization( actx, mesh, discr_tag_to_group_factory={ DISCR_TAG_BASE: default_simplex_group_factory( base_dim=dim, order=order), DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1) } ) if use_overintegration: quadrature_tag = DISCR_TAG_QUAD else: quadrature_tag = None nodes = thaw(discr.nodes(), actx) centers = make_obj_array([np.zeros(shape=(dim,)) for i in range(nspecies)]) spec_y0s = np.ones(shape=(nspecies,)) spec_amplitudes = np.ones(shape=(nspecies,)) velocity = np.zeros(shape=(dim,)) velocity[0] = v0 rho0 = 2.0 lump = MulticomponentLump(dim=dim, nspecies=nspecies, rho0=rho0, spec_centers=centers, velocity=velocity, spec_y0s=spec_y0s, spec_amplitudes=spec_amplitudes) lump_soln = lump(nodes) gas_model = GasModel(eos=IdealSingleGas()) fluid_state = make_fluid_state(lump_soln, gas_model) def _my_boundary(discr, btag, gas_model, state_minus, **kwargs): actx = state_minus.array_context bnd_discr = discr.discr_from_dd(btag) nodes = thaw(bnd_discr.nodes(), actx) return make_fluid_state(lump(x_vec=nodes, **kwargs), gas_model) boundaries = { BTAG_ALL: PrescribedFluidBoundary(boundary_state_func=_my_boundary) } inviscid_rhs = euler_operator( discr, state=fluid_state, gas_model=gas_model, boundaries=boundaries, time=0.0, quadrature_tag=quadrature_tag ) expected_rhs = lump.exact_rhs(discr, cv=lump_soln, time=0) print(f"inviscid_rhs = {inviscid_rhs}") print(f"expected_rhs = {expected_rhs}") err_max = actx.to_numpy( discr.norm((inviscid_rhs-expected_rhs), np.inf)) if err_max > maxxerr: maxxerr = err_max eoc_rec.add_data_point(1.0 / nel_1d, err_max) logger.info(f"Max error: {maxxerr}") logger.info( f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}" ) assert ( eoc_rec.order_estimate() >= order - 0.5 or eoc_rec.max_error() < tolerance )
def op(state): fluid_state = make_fluid_state(state, gas_model) return euler_operator(discr, gas_model=gas_model, boundaries=boundaries, state=fluid_state)
def test_uniform_rhs(actx_factory, nspecies, dim, order): """Test the inviscid rhs using a trivial constant/uniform state. This state should yield rhs = 0 to FP. The test is performed for 1, 2, and 3 dimensions, with orders 1, 2, and 3, with and without passive species. """ actx = actx_factory() tolerance = 1e-9 from pytools.convergence import EOCRecorder eoc_rec0 = EOCRecorder() eoc_rec1 = EOCRecorder() # for nel_1d in [4, 8, 12]: for nel_1d in [4, 8]: from meshmode.mesh.generation import generate_regular_rect_mesh mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim, b=(0.5, ) * dim, nelements_per_axis=(nel_1d, ) * dim) logger.info(f"Number of {dim}d elements: {mesh.nelements}") discr = EagerDGDiscretization(actx, mesh, order=order) zeros = discr.zeros(actx) ones = zeros + 1.0 mass_input = discr.zeros(actx) + 1 energy_input = discr.zeros(actx) + 2.5 mom_input = make_obj_array( [discr.zeros(actx) for i in range(discr.dim)]) mass_frac_input = flat_obj_array( [ones / ((i + 1) * 10) for i in range(nspecies)]) species_mass_input = mass_input * mass_frac_input num_equations = dim + 2 + len(species_mass_input) cv = make_conserved(dim, mass=mass_input, energy=energy_input, momentum=mom_input, species_mass=species_mass_input) expected_rhs = make_conserved( dim, q=make_obj_array([discr.zeros(actx) for i in range(num_equations)])) boundaries = {BTAG_ALL: DummyBoundary()} inviscid_rhs = euler_operator(discr, eos=IdealSingleGas(), boundaries=boundaries, cv=cv, time=0.0) rhs_resid = inviscid_rhs - expected_rhs rho_resid = rhs_resid.mass rhoe_resid = rhs_resid.energy mom_resid = rhs_resid.momentum rhoy_resid = rhs_resid.species_mass rho_rhs = inviscid_rhs.mass rhoe_rhs = inviscid_rhs.energy rhov_rhs = inviscid_rhs.momentum rhoy_rhs = inviscid_rhs.species_mass logger.info(f"rho_rhs = {rho_rhs}\n" f"rhoe_rhs = {rhoe_rhs}\n" f"rhov_rhs = {rhov_rhs}\n" f"rhoy_rhs = {rhoy_rhs}\n") assert discr.norm(rho_resid, np.inf) < tolerance assert discr.norm(rhoe_resid, np.inf) < tolerance for i in range(dim): assert discr.norm(mom_resid[i], np.inf) < tolerance for i in range(nspecies): assert discr.norm(rhoy_resid[i], np.inf) < tolerance err_max = discr.norm(rho_resid, np.inf) eoc_rec0.add_data_point(1.0 / nel_1d, err_max) # set a non-zero, but uniform velocity component for i in range(len(mom_input)): mom_input[i] = discr.zeros(actx) + (-1.0)**i cv = make_conserved(dim, mass=mass_input, energy=energy_input, momentum=mom_input, species_mass=species_mass_input) boundaries = {BTAG_ALL: DummyBoundary()} inviscid_rhs = euler_operator(discr, eos=IdealSingleGas(), boundaries=boundaries, cv=cv, time=0.0) rhs_resid = inviscid_rhs - expected_rhs rho_resid = rhs_resid.mass rhoe_resid = rhs_resid.energy mom_resid = rhs_resid.momentum rhoy_resid = rhs_resid.species_mass assert discr.norm(rho_resid, np.inf) < tolerance assert discr.norm(rhoe_resid, np.inf) < tolerance for i in range(dim): assert discr.norm(mom_resid[i], np.inf) < tolerance for i in range(nspecies): assert discr.norm(rhoy_resid[i], np.inf) < tolerance err_max = discr.norm(rho_resid, np.inf) eoc_rec1.add_data_point(1.0 / nel_1d, err_max) logger.info(f"V == 0 Errors:\n{eoc_rec0}" f"V != 0 Errors:\n{eoc_rec1}") assert (eoc_rec0.order_estimate() >= order - 0.5 or eoc_rec0.max_error() < 1e-9) assert (eoc_rec1.order_estimate() >= order - 0.5 or eoc_rec1.max_error() < 1e-9)
def rhs(t, q): fluid_state = make_fluid_state(q, gas_model) return euler_operator(discr, fluid_state, boundaries=boundaries, gas_model=gas_model, time=t, quadrature_tag=quadrature_tag)
def rhs(t, q): return euler_operator(discr, eos=eos, boundaries=boundaries, cv=q, time=t)
def test_multilump_rhs(actx_factory, dim, order, v0): """Test the Euler rhs using the non-trivial 1, 2, and 3D mass lump case. The case is tested against the analytic expressions of the RHS. Checks several different orders and refinement levels to check error behavior. """ actx = actx_factory() nspecies = 10 tolerance = 1e-8 maxxerr = 0.0 from pytools.convergence import EOCRecorder eoc_rec = EOCRecorder() for nel_1d in [4, 8, 16]: from meshmode.mesh.generation import ( generate_regular_rect_mesh, ) mesh = generate_regular_rect_mesh( a=(-1, ) * dim, b=(1, ) * dim, nelements_per_axis=(nel_1d, ) * dim, ) logger.info(f"Number of elements: {mesh.nelements}") discr = EagerDGDiscretization(actx, mesh, order=order) nodes = thaw(actx, discr.nodes()) centers = make_obj_array( [np.zeros(shape=(dim, )) for i in range(nspecies)]) spec_y0s = np.ones(shape=(nspecies, )) spec_amplitudes = np.ones(shape=(nspecies, )) velocity = np.zeros(shape=(dim, )) velocity[0] = v0 rho0 = 2.0 lump = MulticomponentLump(dim=dim, nspecies=nspecies, rho0=rho0, spec_centers=centers, velocity=velocity, spec_y0s=spec_y0s, spec_amplitudes=spec_amplitudes) lump_soln = lump(nodes) boundaries = { BTAG_ALL: PrescribedInviscidBoundary(fluid_solution_func=lump) } inviscid_rhs = euler_operator(discr, eos=IdealSingleGas(), boundaries=boundaries, cv=lump_soln, time=0.0) expected_rhs = lump.exact_rhs(discr, cv=lump_soln, time=0) print(f"inviscid_rhs = {inviscid_rhs}") print(f"expected_rhs = {expected_rhs}") err_max = discr.norm((inviscid_rhs - expected_rhs).join(), np.inf) if err_max > maxxerr: maxxerr = err_max eoc_rec.add_data_point(1.0 / nel_1d, err_max) logger.info(f"Max error: {maxxerr}") logger.info(f"Error for (dim,order) = ({dim},{order}):\n" f"{eoc_rec}") assert (eoc_rec.order_estimate() >= order - 0.5 or eoc_rec.max_error() < tolerance)
def my_rhs(t, state): return (euler_operator( discr, cv=state, time=t, boundaries=boundaries, eos=eos) + eos.get_species_source_terms(state))
def test_uniform_rhs(actx_factory, nspecies, dim, order, use_overintegration): """Test the inviscid rhs using a trivial constant/uniform state. This state should yield rhs = 0 to FP. The test is performed for 1, 2, and 3 dimensions, with orders 1, 2, and 3, with and without passive species. """ actx = actx_factory() tolerance = 1e-9 from pytools.convergence import EOCRecorder eoc_rec0 = EOCRecorder() eoc_rec1 = EOCRecorder() # for nel_1d in [4, 8, 12]: for nel_1d in [4, 8]: from meshmode.mesh.generation import generate_regular_rect_mesh mesh = generate_regular_rect_mesh( a=(-0.5,) * dim, b=(0.5,) * dim, nelements_per_axis=(nel_1d,) * dim ) logger.info( f"Number of {dim}d elements: {mesh.nelements}" ) from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD from meshmode.discretization.poly_element import \ default_simplex_group_factory, QuadratureSimplexGroupFactory discr = EagerDGDiscretization( actx, mesh, discr_tag_to_group_factory={ DISCR_TAG_BASE: default_simplex_group_factory( base_dim=dim, order=order), DISCR_TAG_QUAD: QuadratureSimplexGroupFactory(2*order + 1) } ) if use_overintegration: quadrature_tag = DISCR_TAG_QUAD else: quadrature_tag = None zeros = discr.zeros(actx) ones = zeros + 1.0 mass_input = discr.zeros(actx) + 1 energy_input = discr.zeros(actx) + 2.5 mom_input = make_obj_array( [discr.zeros(actx) for i in range(discr.dim)] ) mass_frac_input = flat_obj_array( [ones / ((i + 1) * 10) for i in range(nspecies)] ) species_mass_input = mass_input * mass_frac_input num_equations = dim + 2 + len(species_mass_input) cv = make_conserved( dim, mass=mass_input, energy=energy_input, momentum=mom_input, species_mass=species_mass_input) gas_model = GasModel(eos=IdealSingleGas()) fluid_state = make_fluid_state(cv, gas_model) expected_rhs = make_conserved( dim, q=make_obj_array([discr.zeros(actx) for i in range(num_equations)]) ) boundaries = {BTAG_ALL: DummyBoundary()} inviscid_rhs = euler_operator(discr, state=fluid_state, gas_model=gas_model, boundaries=boundaries, time=0.0, quadrature_tag=quadrature_tag) rhs_resid = inviscid_rhs - expected_rhs rho_resid = rhs_resid.mass rhoe_resid = rhs_resid.energy mom_resid = rhs_resid.momentum rhoy_resid = rhs_resid.species_mass rho_rhs = inviscid_rhs.mass rhoe_rhs = inviscid_rhs.energy rhov_rhs = inviscid_rhs.momentum rhoy_rhs = inviscid_rhs.species_mass logger.info( f"rho_rhs = {rho_rhs}\n" f"rhoe_rhs = {rhoe_rhs}\n" f"rhov_rhs = {rhov_rhs}\n" f"rhoy_rhs = {rhoy_rhs}\n" ) def inf_norm(x): return actx.to_numpy(discr.norm(x, np.inf)) assert inf_norm(rho_resid) < tolerance assert inf_norm(rhoe_resid) < tolerance for i in range(dim): assert inf_norm(mom_resid[i]) < tolerance for i in range(nspecies): assert inf_norm(rhoy_resid[i]) < tolerance err_max = inf_norm(rho_resid) eoc_rec0.add_data_point(1.0 / nel_1d, err_max) # set a non-zero, but uniform velocity component for i in range(len(mom_input)): mom_input[i] = discr.zeros(actx) + (-1.0) ** i cv = make_conserved( dim, mass=mass_input, energy=energy_input, momentum=mom_input, species_mass=species_mass_input) gas_model = GasModel(eos=IdealSingleGas()) fluid_state = make_fluid_state(cv, gas_model) boundaries = {BTAG_ALL: DummyBoundary()} inviscid_rhs = euler_operator(discr, state=fluid_state, gas_model=gas_model, boundaries=boundaries, time=0.0) rhs_resid = inviscid_rhs - expected_rhs rho_resid = rhs_resid.mass rhoe_resid = rhs_resid.energy mom_resid = rhs_resid.momentum rhoy_resid = rhs_resid.species_mass assert inf_norm(rho_resid) < tolerance assert inf_norm(rhoe_resid) < tolerance for i in range(dim): assert inf_norm(mom_resid[i]) < tolerance for i in range(nspecies): assert inf_norm(rhoy_resid[i]) < tolerance err_max = inf_norm(rho_resid) eoc_rec1.add_data_point(1.0 / nel_1d, err_max) logger.info( f"V == 0 Errors:\n{eoc_rec0}" f"V != 0 Errors:\n{eoc_rec1}" ) assert ( eoc_rec0.order_estimate() >= order - 0.5 or eoc_rec0.max_error() < 1e-9 ) assert ( eoc_rec1.order_estimate() >= order - 0.5 or eoc_rec1.max_error() < 1e-9 )
def op(state): return euler_operator(discr, eos, boundaries, state)