def __init__(self, wavespeed=1.0, initial_condition=None, source_function=None): self.wavespeed = wavespeed if initial_condition is None: self.initial_condition = x_functions.Sine() else: self.initial_condition = initial_condition app = advection.Advection(wavespeed, source_function) max_wavespeed = wavespeed exact_solution = advection.ExactSolution(initial_condition, wavespeed) super().__init__( app, initial_condition, max_wavespeed, exact_solution )
def test_advection_finite_time(): def initial_condition(x): return np.sin(2.0 * np.pi * x) advection_ = advection.Advection(initial_condition=initial_condition) riemann_solver = riemann_solvers.LocalLaxFriedrichs( advection_.flux_function, advection_.wavespeed_function ) boundary_condition = boundary.Periodic() time_initial = 0.0 time_final = 0.5 def test_function(dg_solution): explicit_time_stepper = explicit_runge_kutta.get_time_stepper( dg_solution.basis.num_basis_cpts ) cfl = dg_utils.standard_cfls(dg_solution.basis.num_basis_cpts) delta_t = dg_utils.get_delta_t( cfl, advection_.wavespeed, dg_solution.mesh.delta_x ) rhs_function = lambda time, q: dg_utils.dg_weak_formulation( q, advection_.flux_function, riemann_solver, boundary_condition ) return time_stepping.time_step_loop_explicit( dg_solution, time_initial, time_final, delta_t, explicit_time_stepper, rhs_function, ) order_check_function = lambda order, num_basis_cpts: order >= num_basis_cpts utils.basis_convergence( test_function, initial_condition, lambda x: advection_.exact_solution(x, time_final), order_check_function, basis_list=[basis.LegendreBasis1D], basis_cpt_list=[4], )
def test_advection_one_time_step(): def initial_condition(x): return np.sin(2.0 * np.pi * x) advection_ = advection.Advection(initial_condition=initial_condition) riemann_solver = riemann_solvers.LocalLaxFriedrichs( advection_.flux_function, advection_.wavespeed_function ) explicit_time_stepper = explicit_runge_kutta.ForwardEuler() boundary_condition = boundary.Periodic() cfl = 1.0 for basis_class in basis.BASIS_LIST: basis_ = basis_class(1) error_list = [] for num_elems in [20, 40]: mesh_ = mesh.Mesh1DUniform(0.0, 1.0, num_elems) dg_solution = basis_.project(advection_.initial_condition, mesh_) delta_t = dg_utils.get_delta_t(cfl, advection_.wavespeed, mesh_.delta_x) time_initial = 0.0 time_final = delta_t rhs_function = lambda time, q: dg_utils.dg_weak_formulation( q, advection_.flux_function, riemann_solver, boundary_condition ) final_solution = time_stepping.time_step_loop_explicit( dg_solution, time_initial, time_final, delta_t, explicit_time_stepper, rhs_function, ) error = math_utils.compute_error( final_solution, lambda x: advection_.exact_solution(x, time_final) ) error_list.append(error) order = utils.convergence_order(error_list) assert order >= 1
def __init__( self, wavespeed=1.0, left_states=None, right_states=None, discontinuity_locations=None, source_function=None, ): self.wavespeed = wavespeed # left_state, right_state, and discontinuity_location should be arrays or lists if left_states is None: self.left_states = [1.0, 2.0] else: self.left_states = left_states if right_states is None: self.right_states = [-1.0, 1.0] else: self.right_states = right_states if discontinuity_locations is None: self.discontinuity_locations = [-0.6, -0.4] else: self.discontinuity_locations = discontinuity_locations app_ = advection.Advection(wavespeed, source_function) riemann_problems = [] for i in range(len(left_states)): riemann_problems.append(x_functions.RiemannProblem( left_states[i], right_states[i], discontinuity_locations[i] )) initial_condition = x_functions.ComposedVector(riemann_problems) max_wavespeed = wavespeed exact_solution = advection.ExactSolution(initial_condition, self.wavespeed) super().__init__( app_, initial_condition, max_wavespeed, exact_solution )
def __init__( self, wavespeed=1.0, left_state=1.0, right_state=-1.0, discontinuity_location=0.0, source_function=None, ): self.wavespeed = wavespeed self.left_state = left_state self.right_state = right_state self.discontinuity_location = discontinuity_location app_ = advection.Advection(wavespeed, source_function) initial_condition = x_functions.RiemannProblem(left_state, right_state, discontinuity_location) max_wavespeed = wavespeed exact_solution = advection.ExactSolution(initial_condition, self.wavespeed) super().__init__(app_, initial_condition, max_wavespeed, exact_solution)
def test_advection_operator(): # test that dg_operator acting on projected initial condition converges to # exact time derivative # will lose one order of accuracy for i in range(2): if i == 0: sin = x_functions.Sine() cos = x_functions.Cosine() initial_condition = x_functions.ComposedVector([sin, cos]) else: initial_condition = x_functions.Sine() wavespeed = 1.0 exact_solution = advection.ExactSolution(initial_condition, wavespeed) exact_time_derivative = advection.ExactTimeDerivative(exact_solution, wavespeed) initial_time_derivative = x_functions.FrozenT(exact_time_derivative, 0.0) app_ = advection.Advection(wavespeed) riemann_solver = riemann_solvers.LocalLaxFriedrichs(app_.flux_function) boundary_condition = boundary.Periodic() for basis_class in basis.BASIS_LIST: for num_basis_cpts in range(1, 5): basis_ = basis_class(num_basis_cpts) error_list = [] for num_elems in [20, 40]: mesh_ = mesh.Mesh1DUniform(0.0, 1.0, num_elems) dg_sol = basis_.project(initial_condition, mesh_) dg_operator = app_.get_explicit_operator( riemann_solver, boundary_condition ) F = dg_operator(0.0, dg_sol) error = math_utils.compute_error(F, initial_time_derivative) error_list.append(error) order = utils.convergence_order(error_list) assert order >= max([1.0, num_basis_cpts - 1])
def __init__(self, wavespeed=1.0, initial_condition=None, source_function=None): self.wavespeed = wavespeed if initial_condition is None: initial_condition = x_functions.Sine() app = advection.Advection(wavespeed, source_function) max_wavespeed = wavespeed exact_solution = advection.ExactSolution(initial_condition, wavespeed) exact_operator = advection.ExactOperator(exact_solution, wavespeed, source_function) exact_time_derivative = advection.ExactTimeDerivative( exact_solution, wavespeed, source_function) super().__init__( app, initial_condition, max_wavespeed, exact_solution, exact_operator, exact_time_derivative, )