def visual_test():
window_manager = WindowManager(1, 1)
for op, name in zip([operators.derivative.diff_backward_n1_e1, operators.derivative.diff_n1_e2,
operators.derivative.diff_n1_e4],
["Derivative Order: 1", "Derivative Order: 2", "Derivative Order: 4"]):
print(name)
tracker = error_tracking_tools.ErrorTracker(num_points=None, x_label="Number of Samples", norm="l_inf")
for resolution_exp in range(20):
num_points = 5 * (2 ** resolution_exp)
L = 1
# shifting axis by irrational number e to avoid 'random' perfect results at low resolutions
axis = np.linspace(0, L, num_points + 1)[:-1] - np.e
dx = L * 1.0 / num_points
factor = np.pi * 2 * 10 # 2 pi to have a periodic signal, other factors to increase the frequency
signal = np.sin(axis * factor)
calculated_result = op(signal, dx)
accurate_result = factor * np.cos(axis * factor)
tracker.add_entry(num_points, accurate_result, calculated_result)
print(str(num_points) + "\t" + str(tracker.abs_error[-1]) + "\t" + str(1 / dx ** 2))
window_manager.display_error(1, tracker, double_log=True, line_name=name, clear_axis=False)
window_manager.draw_loglog_oder_line(1, 10, 1e-6, 1, 1)
window_manager.draw_loglog_oder_line(1, 10, 1e-6, 1, 2)
window_manager.draw_loglog_oder_line(1, 10, 1e-6, 1, 4)
plt.grid()
plt.show()
def run_test(test_object, op, expected_order):
tracker = error_tracking_tools.ErrorTracker(num_points=None, x_label="#Samples", norm="l_1norm")
max_res_exp = 7
# take measurements
for resolution_exp in range(max_res_exp):
num_points = 100 * (2 ** resolution_exp)
# shifting axis by irrational number e to avoid 'random' perfect results at low resolutions
axis = np.linspace(0, 1.0, num_points + 1)[:-1] - np.e
dx = 1.0 / num_points
factor = 2 * np.pi * 10
signal = np.sin(axis * factor)
accurate_derivative = factor * np.cos(axis * factor)
calc_derivative = op(signal, dx)
tracker.num_points = num_points
tracker.add_entry(num_points, accurate_derivative, calc_derivative)
# evaluate measurements by comparing every measurement with every other measurement
for span in range(1, max_res_exp):
expected_improvement = 2 ** (span * expected_order)
for i in range(0, max_res_exp - span):
j = i + span
actual_improvement = tracker.abs_error[i] / tracker.abs_error[j]
test_object.assertTrue(expected_improvement * 0.95 < actual_improvement < expected_improvement * 1.05,
msg="Mistake found at resolutions {} x {}. Expected an improvement of {} but got {}".format(
tracker.labels[i], tracker.labels[j], expected_improvement, actual_improvement))
def run_test(test_obj,
integrator_class,
expected_order_power,
test_case,
initial_time_factor,
start_time=0,
end_time=10,
start_value=1):
num_time_res = 6
# simulate until time reaches 10s and store error at every full second at num_time_res different time-resolutions
error_tracking_list = []
for j in range(num_time_res):
time_factor = 2**j
dt = 1.0 / (initial_time_factor * time_factor)
error_tracker = error_tracking_tools.ErrorTracker(1, "time")
error_tracking_list.append(error_tracker)
timer = error_tracking_tools.TimeIterator(start_time, dt)
solution = CaseSolution(dt, start_time, start_value, test_case)
state = solution.get_initial_state()
derivative = DebugTimeDerivative(test_case)
# choose integrator
integrator = integrator_class(state, derivative, start_time, dt)
for (time, state, state_sol) in zip(timer, integrator, solution):
if time >= end_time:
error_tracker.add_entry(time, state_sol.get_state_vars(),
state.get_state_vars())
break
last_error_list = [
error_tracker.abs_error[-1] for error_tracker in error_tracking_list
]
for i in range(num_time_res - 1):
actual_order = last_error_list[i] / last_error_list[i + 1]
dt = 1.0 / (initial_time_factor * (2**i))
test_obj.assertTrue(
(2**expected_order_power) * 0.95 < actual_order <
(2**expected_order_power) * 1.05,
msg=
"Mistake found in test case {} resolutions {} x {}. Expected an improvement of {} but got {}"
.format(test_case, dt, dt * 0.5, (2**expected_order_power),
actual_order))
from math import sqrt
from matplotlib import pyplot as plt
from debug_tools import error_tracking_tools
from debug_tools.visualization import WindowManager
from operators.derivative import *
window_manager = WindowManager(1, 1)
for op, name, ls in zip(
[diff_backward_n1_e1, diff_n1_e2, diff_n1_e4],
["Derivative Order: 1", "Derivative Order: 2", "Derivative Order: 4"],
["-", "--", ":"]):
print(name)
tracker = error_tracking_tools.ErrorTracker(num_points=None,
x_label="Number of Samples",
norm="l_inf")
for resolution_exp in range(40):
num_points = int(5 * (1.5**resolution_exp))
L = 1
# shifting axis by irrational number e to avoid 'random' perfect results at low resolutions
axis = np.linspace(0, L, num_points + 1)[:-1] - np.e
dx = L * 1.0 / num_points
factor = np.pi * 2 * 10 # 2 pi to have a periodic signal, other factors to increase the frequency
signal = np.sin(axis * factor)
calculated_result = op(signal, dx)
accurate_result = factor * np.cos(axis * factor)
def run_visual_with_solution(params, integrator_class, time_derivative_class,
time_derivative_inputs, case_solution_class,
case_sol_inputs):
"""
:param params: dictionary with values for 'num_grid_points', time-step-size 'dt', size of the domain 'domain_size',
every how many steps the state shall be displayed 'sampling_rate'.
:param integrator_class: Class of the integrator to be used.
:param time_derivative_class: Class of the time derivative to be used.
:param time_derivative_inputs: Iterable list of special inputs for the class of the time derivative.
:param case_solution_class: Class for the solution of the case.
:param case_sol_inputs: iterable list of special inputs for the class of the solution.
"""
# choose constants
num_grid_points = params['num_grid_points']
domain_size = params['domain_size']
dt = params['dt']
sampling_rate = params['sampling_rate']
dx = domain_size / num_grid_points
# setup starting condition
solution = case_solution_class(num_grid_points, dt, domain_size,
*case_sol_inputs)
state = solution.get_initial_state()
# choose border condition
derivative = time_derivative_class(dx, *time_derivative_inputs)
# choose integrator
integrator = integrator_class(state, derivative, 0, dt)
# debugging
num_vars = len(state.get_names())
error_trackers = []
for _ in range(num_vars):
error_trackers.append(
error_tracking_tools.ErrorTracker(num_grid_points,
"Time",
norm="l_inf"))
timer = error_tracking_tools.TimeIterator(0, dt)
# set up display window
window_manager = debug_tools.visualization.WindowManager(4, num_vars)
# simulation loop
for i, (time, state,
state_sol) in enumerate(zip(timer, integrator, solution), 1):
if i % sampling_rate == 0:
# print(time, end="\t")
difference = state - state_sol
for j in range(num_vars):
error_trackers[j].add_entry(time,
state_sol.get_state_vars()[j],
state.get_state_vars()[j])
# print(error_trackers[j].abs_error[-1], end="\t")
window_manager.display_state(1 + j + 0 * num_vars, difference,
j)
window_manager.display_state(1 + j + 1 * num_vars, state, j,
-2, 2)
window_manager.display_state(1 + j + 2 * num_vars, state_sol,
j, -2, 2)
window_manager.display_error(1 + j + 3 * num_vars,
error_trackers[j],
double_log=False,
line_name="Error",
clear_axis=True)
print(error_trackers[j].abs_error)