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)
