def exact_operator(self, q, t=None): exact_operator = ExactOperator( q, self.flux_function, self.diffusion_function, self.source_function ) if t is not None: return x_functions.FrozenT(exact_operator, t) return exact_operator
def linearized_manufactured_solution(exact_solution, diffusion_function=None): if diffusion_function is None: diffusion_function = flux_functions.Polynomial(degree=0) # source_function could be computed with original diffusion function # or with linearized diffusion function # ? Would that make a difference? source_function = ExactOperator( exact_solution, flux_functions.Zero(), diffusion_function, flux_functions.Zero(), ) initial_condition = x_functions.FrozenT(exact_solution, 0.0) # linearize diffusion function new_diffusion_function = xt_functions.LinearizedAboutQ( diffusion_function, exact_solution ) problem = NonlinearDiffusion( new_diffusion_function, source_function, initial_condition ) problem.exact_solution = exact_solution return problem
def linearized_manufactured_solution( exact_solution, flux_function=None, diffusion_function=None, max_wavespeed=1.0 ): if flux_function is None: flux_function = flux_functions.Identity() if diffusion_function is None: diffusion_function = flux_functions.Polynomial(degree=0) # source_function could be computed with original diffusion function # or with linearized diffusion function # ? Would that make a difference? source_function = ExactOperator( exact_solution, flux_function, diffusion_function, flux_functions.Zero() ) initial_condition = x_functions.FrozenT(exact_solution, 0.0) linearized_diffusion_function = xt_functions.LinearizedAboutQ( diffusion_function, exact_solution ) problem = ConvectionDiffusion( flux_function, linearized_diffusion_function, source_function, initial_condition, max_wavespeed, ) problem.exact_solution = exact_solution return problem
def linearized_manufactured_solution( exact_solution, flux_function=None, diffusion_function=None, max_wavespeed=1.0 ): if flux_function is None: flux_function = flux_functions.Identity() if diffusion_function is None: diffusion_function = flux_functions.Polynomial(degree=0) source_function = ExactOperator( exact_solution, flux_function, diffusion_function, flux_functions.Zero() ) initial_condition = x_functions.FrozenT(exact_solution, 0.0) linearized_diffusion_function = flux_functions.LinearizedAboutQ( diffusion_function, exact_solution ) problem = ConvectionHyperDiffusion( flux_function, linearized_diffusion_function, source_function, initial_condition, max_wavespeed, ) problem.exact_solution = exact_solution return problem
def exact_time_derivative(self, q, t=None): exact_time_derivative = ExactTimeDerivative( q, self.flux_function, self.diffusion_function, self.source_function ) if t is not None: return x_functions.FrozenT(exact_time_derivative, t) return exact_time_derivative
def test_evaluate_weak_form(): periodic_bc = boundary.Periodic() t = 0.0 for problem in test_problems: exact_time_derivative = problem.exact_time_derivative initial_time_derivative = x_functions.FrozenT(exact_time_derivative, 0.0) riemann_solver = riemann_solvers.LocalLaxFriedrichs(problem) for basis_class in basis.BASIS_LIST: for num_basis_cpts in range(1, 4): error_list = [] basis_ = basis_class(num_basis_cpts) for num_elems in [20, 40]: mesh_ = mesh.Mesh1DUniform(0.0, 1.0, num_elems) dg_solution = basis_.project(initial_condition, mesh_) result = dg_utils.evaluate_weak_form( dg_solution, t, problem.app_.flux_function, riemann_solver, periodic_bc, problem.app_.nonconservative_function, problem.app_.regularization_path, problem.app_.source_function) error = math_utils.compute_error(result, initial_time_derivative) error_list.append(error) order = utils.convergence_order(error_list) if num_basis_cpts == 1: assert order >= 1 else: assert order >= num_basis_cpts - 1
def __init__( self, num_moments=swme.DEFAULT_NUM_MOMENTS, wavespeed=None, gravity_constant=swme.DEFAULT_GRAVITY_CONSTANT, kinematic_viscosity=swme.DEFAULT_KINEMATIC_VISCOSITY, slip_length=swme.DEFAULT_SLIP_LENGTH, ): exact_solution = ExactSolution(num_moments, wavespeed) additional_source = swlme.ExactOperator( exact_solution, num_moments, gravity_constant, kinematic_viscosity, slip_length, ) app_ = swlme.ShallowWaterLinearizedMomentEquations( num_moments, gravity_constant, kinematic_viscosity, slip_length, additional_source, ) max_wavespeed = app_.estimate_max_wavespeed( exact_solution.max_h, exact_solution.max_u, exact_solution.max_v, exact_solution.max_a, exact_solution.max_b, ) initial_condition = x_functions.FrozenT(exact_solution, 0) exact_operator = swlme.ExactOperator( exact_solution, num_moments, gravity_constant, kinematic_viscosity, slip_length, additional_source, ) exact_time_derivative = swlme.ExactTimeDerivative( exact_solution, num_moments, gravity_constant, kinematic_viscosity, slip_length, additional_source, ) super().__init__( app_, initial_condition, max_wavespeed, exact_solution, exact_operator, exact_time_derivative, )
def manufactured_solution(exact_solution): source_function = convection_hyper_diffusion.ExactOperator( exact_solution, default_flux_function, default_diffusion_function, flux_functions.Zero(), ) initial_condition = x_functions.FrozenT(exact_solution, 0.0) problem = ThinFilm(source_function, initial_condition) problem.exact_solution = exact_solution return problem
def manufactured_solution(exact_solution, diffusion_function=None): if diffusion_function is None: diffusion_function = flux_functions.Polynomial(degree=0) source_function = ExactOperator( exact_solution, flux_functions.Zero(), diffusion_function, flux_functions.Zero(), ) initial_condition = x_functions.FrozenT(exact_solution, 0.0) problem = NonlinearDiffusion( diffusion_function, source_function, initial_condition ) problem.exact_solution = exact_solution return problem
def single_run( problem, basis_, mesh_, bc, t_final, delta_t, num_picard_iterations=None ): if num_picard_iterations is None: num_picard_iterations = basis_.num_basis_cpts imex = imex_runge_kutta.get_time_stepper(basis_.num_basis_cpts) dg_solution = basis_.project(problem.initial_condition, mesh_) # weak dg form with flux_function and source term explicit_operator = problem.get_explicit_operator(bc) # ldg discretization of diffusion_function implicit_operator = problem.get_implicit_operator( bc, bc, bc, bc, include_source=False ) matrix_function = lambda t, q: problem.ldg_matrix( q, t, bc, bc, bc, bc, include_source=False ) solve_operator = time_stepping.get_solve_function_picard( matrix_function, num_picard_iterations, mesh_.num_elems * basis_.num_basis_cpts ) error_dict = dict() # def after_step_hook(dg_solution, time): # error = math_utils.compute_error( # dg_solution, lambda x: problem.exact_solution(x, time) # ) # error_dict[round(time, 8)] = error final_solution = time_stepping.time_step_loop_imex( dg_solution, 0.0, t_final, delta_t, imex, explicit_operator, implicit_operator, solve_operator, # after_step_hook ) exact_solution_final = x_functions.FrozenT(problem.exact_solution, t_final) error = math_utils.compute_error(final_solution, exact_solution_final) return (final_solution, error, error_dict)
def __init__( self, exact_solution, max_wavespeed, gravity_constant=sw.DEFAULT_GRAVITY_CONSTANT, include_v=False, ): source_function = sw.ExactOperator( exact_solution, gravity_constant, None, include_v, ) app_ = sw.ShallowWater( gravity_constant, source_function, ) initial_condition = x_functions.FrozenT(exact_solution, 0) exact_operator = sw.ExactOperator( exact_solution, gravity_constant, source_function, ) exact_time_derivative = sw.ExactTimeDerivative( exact_solution, gravity_constant, source_function, ) super().__init__( app_, initial_condition, max_wavespeed, exact_solution, exact_operator, exact_time_derivative, )
def __init__(self, exact_solution, max_wavespeed): # exact_solution should be XTFunction - preferably smooth # max_wavespeed - maximum speed of exact_solution # Either both given or both None initial_condition = x_functions.FrozenT(exact_solution, 0) source_function = burgers.ExactOperator(exact_solution) app_ = burgers.Burgers(source_function) exact_operator = burgers.ExactOperator(exact_solution, source_function) exact_time_derivative = burgers.ExactTimeDerivative( exact_solution, source_function) super().__init__( app_, initial_condition, max_wavespeed, exact_solution, exact_operator, exact_time_derivative, )
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 test_dg_operator(): # test that dg_operator converges to exact_time_derivative in smooth case initial_condition = x_functions.Sine(offset=2.0) max_wavespeed = 3.0 problem = smooth_example.SmoothExample(initial_condition, max_wavespeed) riemann_solver = riemann_solvers.LocalLaxFriedrichs(problem) boundary_condition = boundary.Periodic() x_left = 0.0 x_right = 1.0 exact_time_derivative = burgers.ExactTimeDerivative( problem.initial_condition) exact_time_derivative_initial = x_functions.FrozenT( exact_time_derivative, 0.0) 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 [40, 80]: mesh_ = mesh.Mesh1DUniform(x_left, x_right, num_elems) dg_solution = basis_.project(problem.initial_condition, mesh_) explicit_operator = problem.app_.get_explicit_operator( riemann_solver, boundary_condition) dg_time_derivative = explicit_operator(0.0, dg_solution) error = math_utils.compute_error( dg_time_derivative, exact_time_derivative_initial) error_list.append(error) order = test_utils.convergence_order(error_list) if num_basis_cpts > 1: assert order >= num_basis_cpts - 1 else: assert order >= 1
def test_frozen_t(): xt_function = xt_functions.AdvectingSine() t_value = 0.0 x_function = x_functions.FrozenT(xt_function, t_value) check_x_function(x_function)