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)