def _offline(self):
print(TextBox(self.truth_problem.name() + " " + self.label + " offline phase begins", fill="="))
print("")
for (mu_index, mu) in enumerate(self.training_set):
print(TextLine(str(mu_index), fill="#"))
self.truth_problem.set_mu(mu)
print("truth solve for mu =", self.truth_problem.mu)
snapshot = self.truth_problem.solve()
self.truth_problem.export_solution(self.folder["snapshots"], "truth_" + str(mu_index), snapshot)
snapshot = self.postprocess_snapshot(snapshot, mu_index)
print("update snapshots matrix")
self.update_snapshots_matrix(snapshot)
print("")
mu_index += 1
print(TextLine("perform POD", fill="#"))
self.compute_basis_functions()
print("")
print("build reduced operators")
self.reduced_problem.build_reduced_operators()
print("")
print(TextBox(self.truth_problem.name() + " " + self.label + " offline phase ends", fill="="))
print("")
def _offline(self):
print(
TextBox(self.truth_problem.name() + " " + self.label +
" offline phase begins",
fill="="))
print("")
# Initialize first parameter to be used
self.reduced_problem.build_reduced_operators()
self.reduced_problem.build_error_estimation_operators()
(absolute_error_estimator_max,
relative_error_estimator_max) = self.greedy()
print(
"initial maximum absolute error estimator over training set =",
absolute_error_estimator_max)
print(
"initial maximum relative error estimator over training set =",
relative_error_estimator_max)
print("")
iteration = 0
while self.reduced_problem.N < self.Nmax and relative_error_estimator_max >= self.tol:
print(TextLine("N = " + str(self.reduced_problem.N), fill="#"))
print("truth solve for mu =", self.truth_problem.mu)
snapshot = self.truth_problem.solve()
self.truth_problem.export_solution(self.folder["snapshots"],
"truth_" + str(iteration),
snapshot)
snapshot = self.postprocess_snapshot(snapshot, iteration)
print("update basis matrix")
self.update_basis_matrix(snapshot)
iteration += 1
print("build reduced operators")
self.reduced_problem.build_reduced_operators()
print("reduced order solve")
self.reduced_problem.solve()
print("build operators for error estimation")
self.reduced_problem.build_error_estimation_operators()
(absolute_error_estimator_max,
relative_error_estimator_max) = self.greedy()
print("maximum absolute error estimator over training set =",
absolute_error_estimator_max)
print("maximum relative error estimator over training set =",
relative_error_estimator_max)
print("")
print(
TextBox(self.truth_problem.name() + " " + self.label +
" offline phase ends",
fill="="))
print("")
def _speedup_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator(n):
return n
N = self.SCM_approximation.N
print(TextBox("SCM speedup analysis begins", fill="="))
print("")
speedup_analysis_table = SpeedupAnalysisTable(self.testing_set)
speedup_analysis_table.set_Nmax(N)
speedup_analysis_table.add_column("speedup",
group_name="speedup",
operations=("min", "mean", "max"))
exact_timer = Timer("parallel")
SCM_timer = Timer("serial")
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine("SCM " + str(mu_index), fill="~"))
self.SCM_approximation.set_mu(mu)
exact_timer.start()
self.SCM_approximation.evaluate_stability_factor()
elapsed_exact = exact_timer.stop()
for n in range(1, N + 1): # n = 1, ... N
n_arg = N_generator(n)
if n_arg is not None:
SCM_timer.start()
self.SCM_approximation.get_stability_factor_lower_bound(
n_arg)
self.SCM_approximation.get_stability_factor_upper_bound(
n_arg)
elapsed_SCM = SCM_timer.stop()
speedup_analysis_table[
"speedup", n, mu_index] = elapsed_exact / elapsed_SCM
else:
speedup_analysis_table["speedup", n,
mu_index] = NotImplemented
# Print
print("")
print(speedup_analysis_table)
print("")
print(TextBox("SCM speedup analysis ends", fill="="))
print("")
# Export speedup analysis table
speedup_analysis_table.save(
self.folder["speedup_analysis"],
"speedup_analysis" if filename is None else filename)
def _speedup_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator():
N = self.EIM_approximation.N
for n in range(1, N + 1): # n = 1, ... N
yield n
def N_generator_max():
*_, Nmax = N_generator()
return Nmax
interpolation_method_name = self.EIM_approximation.parametrized_expression.interpolation_method_name()
description = self.EIM_approximation.parametrized_expression.description()
print(TextBox(interpolation_method_name + " speedup analysis begins for" + "\n"
+ "\n".join(description), fill="="))
print("")
speedup_analysis_table = SpeedupAnalysisTable(self.testing_set)
speedup_analysis_table.set_Nmax(N_generator_max())
speedup_analysis_table.add_column("speedup", group_name="speedup", operations=("min", "mean", "max"))
evaluate_timer = Timer("parallel")
EIM_timer = Timer("serial")
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine(interpolation_method_name + " " + str(mu_index), fill=":"))
self.EIM_approximation.set_mu(mu)
# Evaluate the exact function on the truth grid
evaluate_timer.start()
self.EIM_approximation.evaluate_parametrized_expression()
elapsed_evaluate = evaluate_timer.stop()
for n in N_generator():
EIM_timer.start()
self.EIM_approximation.solve(n)
elapsed_EIM = EIM_timer.stop()
speedup_analysis_table["speedup", n, mu_index] = elapsed_evaluate / elapsed_EIM
# Print
print("")
print(speedup_analysis_table)
print("")
print(TextBox(interpolation_method_name + " speedup analysis ends for" + "\n"
+ "\n".join(description), fill="="))
print("")
# Export speedup analysis table
speedup_analysis_table.save(self.folder["speedup_analysis"],
"speedup_analysis" if filename is None else filename)
def _error_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator():
N = self.EIM_approximation.N
for n in range(1, N + 1): # n = 1, ... N
yield n
def N_generator_max():
*_, Nmax = N_generator()
return Nmax
interpolation_method_name = self.EIM_approximation.parametrized_expression.interpolation_method_name()
description = self.EIM_approximation.parametrized_expression.description()
print(TextBox(interpolation_method_name + " error analysis begins for" + "\n"
+ "\n".join(description), fill="="))
print("")
error_analysis_table = ErrorAnalysisTable(self.testing_set)
error_analysis_table.set_Nmax(N_generator_max())
error_analysis_table.add_column("error", group_name="eim", operations=("mean", "max"))
error_analysis_table.add_column("relative_error", group_name="eim", operations=("mean", "max"))
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine(interpolation_method_name + " " + str(mu_index), fill=":"))
self.EIM_approximation.set_mu(mu)
# Evaluate the exact function on the truth grid
self.EIM_approximation.evaluate_parametrized_expression()
for n in N_generator():
self.EIM_approximation.solve(n)
(_, error, _) = self.EIM_approximation.compute_maximum_interpolation_error(n)
(_, relative_error, _) = self.EIM_approximation.compute_maximum_interpolation_relative_error(n)
error_analysis_table["error", n, mu_index] = abs(error)
error_analysis_table["relative_error", n, mu_index] = abs(relative_error)
# Print
print("")
print(error_analysis_table)
print("")
print(TextBox(interpolation_method_name + " error analysis ends for" + "\n"
+ "\n".join(description), fill="="))
print("")
# Export error analysis table
error_analysis_table.save(self.folder["error_analysis"], "error_analysis" if filename is None else filename)
def _error_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator(n):
return n
N = self.SCM_approximation.N
print(TextBox("SCM error analysis begins", fill="="))
print("")
error_analysis_table = ErrorAnalysisTable(self.testing_set)
error_analysis_table.set_Nmax(N)
error_analysis_table.add_column("normalized_error", group_name="scm", operations=("min", "mean", "max"))
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine("SCM " + str(mu_index), fill="~"))
self.SCM_approximation.set_mu(mu)
(exact, _) = self.SCM_approximation.evaluate_stability_factor()
for n in range(1, N + 1): # n = 1, ... N
n_arg = N_generator(n)
if n_arg is not None:
LB = self.SCM_approximation.get_stability_factor_lower_bound(n_arg)
UB = self.SCM_approximation.get_stability_factor_upper_bound(n_arg)
if LB/UB < 0 and not isclose(LB/UB, 0.): # if LB/UB << 0
print("SCM warning at mu = " + str(mu) + ": LB = " + str(LB) + " < 0")
if LB/UB > 1 and not isclose(LB/UB, 1.): # if LB/UB >> 1
print("SCM warning at mu = " + str(mu) + ": LB = " + str(LB) + " > UB = " + str(UB))
if LB/exact > 1 and not isclose(LB/exact, 1.): # if LB/exact >> 1
print("SCM warning at mu = " + str(mu) + ": LB = " + str(LB) + " > exact =" + str(exact))
error_analysis_table["normalized_error", n, mu_index] = (exact - LB)/UB
else:
error_analysis_table["normalized_error", n, mu_index] = NotImplemented
# Print
print("")
print(error_analysis_table)
print("")
print(TextBox("SCM error analysis ends", fill="="))
print("")
# Export error analysis table
error_analysis_table.save(self.folder["error_analysis"], "error_analysis" if filename is None else filename)
def _offline(self):
print(TextBox("SCM offline phase begins", fill="="))
print("")
# Compute the bounding box \mathcal{B}
self.compute_bounding_box()
print("")
# Arbitrarily start from the first parameter in the training set
self.SCM_approximation.set_mu(self.training_set[0])
relative_error_estimator_max = 2. * self.tol
while self.SCM_approximation.N < self.Nmax and relative_error_estimator_max >= self.tol:
print(
TextLine("SCM N = " + str(self.SCM_approximation.N), fill="~"))
# Store the greedy parameter
self.store_greedy_selected_parameters()
# Evaluate the stability factor
print("evaluate the stability factor for mu =",
self.SCM_approximation.mu)
(stability_factor,
eigenvector) = self.SCM_approximation.evaluate_stability_factor()
print("stability factor =", stability_factor)
# Update data structures related to upper bound vectors
upper_bound_vector = self.compute_upper_bound_vector(eigenvector)
self.update_upper_bound_vectors(upper_bound_vector)
# Prepare for next iteration
print("find next mu")
(error_estimator_max, relative_error_estimator_max) = self.greedy()
print("maximum SCM error estimator =", error_estimator_max)
print("maximum SCM relative error estimator =",
relative_error_estimator_max)
print("")
print(TextBox("SCM offline phase ends", fill="="))
print("")
def _offline(self):
interpolation_method_name = self.EIM_approximation.parametrized_expression.interpolation_method_name()
description = self.EIM_approximation.parametrized_expression.description()
# Evaluate the parametrized expression for all parameters in the training set
print(TextBox(interpolation_method_name + " preprocessing phase begins for" + "\n" + "\n".join(description), fill="="))
print("")
for (mu_index, mu) in enumerate(self.training_set):
print(TextLine(interpolation_method_name + " " + str(mu_index), fill=":"))
self.EIM_approximation.set_mu(mu)
print("evaluate parametrized expression at mu =", mu)
self.EIM_approximation.evaluate_parametrized_expression()
self.EIM_approximation.export_solution(self.folder["snapshots"], "truth_" + str(mu_index))
print("add to snapshots")
self.add_to_snapshots(self.EIM_approximation.snapshot)
print("")
# If basis generation is POD, compute the first POD modes of the snapshots
if self.EIM_approximation.basis_generation == "POD":
print("compute basis")
N_POD = self.compute_basis_POD()
print("")
print(TextBox(interpolation_method_name + " preprocessing phase ends for" + "\n" + "\n".join(description), fill="="))
print("")
print(TextBox(interpolation_method_name + " offline phase begins for" + "\n" + "\n".join(description), fill="="))
print("")
if self.EIM_approximation.basis_generation == "Greedy":
# Arbitrarily start from the first parameter in the training set
self.EIM_approximation.set_mu(self.training_set[0])
# Carry out greedy selection
relative_error_max = 2.*self.tol
while self.EIM_approximation.N < self.Nmax and relative_error_max >= self.tol:
print(TextLine(interpolation_method_name + " N = " + str(self.EIM_approximation.N), fill=":"))
self._print_greedy_interpolation_solve_message()
self.EIM_approximation.solve()
print("compute and locate maximum interpolation error")
self.EIM_approximation.snapshot = self.load_snapshot()
(error, maximum_error, maximum_location) = self.EIM_approximation.compute_maximum_interpolation_error()
print("update locations with", maximum_location)
self.update_interpolation_locations(maximum_location)
print("update basis")
self.update_basis_greedy(error, maximum_error)
print("update interpolation matrix")
self.update_interpolation_matrix()
(error_max, relative_error_max) = self.greedy()
print("maximum interpolation error =", error_max)
print("maximum interpolation relative error =", relative_error_max)
print("")
else:
while self.EIM_approximation.N < N_POD:
print(TextLine(interpolation_method_name + " N = " + str(self.EIM_approximation.N), fill=":"))
print("solve interpolation for basis number", self.EIM_approximation.N)
self.EIM_approximation._solve(self.EIM_approximation.basis_functions[self.EIM_approximation.N])
print("compute and locate maximum interpolation error")
self.EIM_approximation.snapshot = self.EIM_approximation.basis_functions[self.EIM_approximation.N]
(error, maximum_error, maximum_location) = self.EIM_approximation.compute_maximum_interpolation_error()
print("update locations with", maximum_location)
self.update_interpolation_locations(maximum_location)
self.EIM_approximation.N += 1
print("update interpolation matrix")
self.update_interpolation_matrix()
print("")
print(TextBox(interpolation_method_name + " offline phase ends for" + "\n" + "\n".join(description), fill="="))
print("")
def _error_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator():
N = self.SCM_approximation.N
for n in range(1, N + 1): # n = 1, ... N
yield n
def N_generator_max():
*_, Nmax = N_generator()
return Nmax
print(TextBox("SCM error analysis begins", fill="="))
print("")
error_analysis_table = ErrorAnalysisTable(self.testing_set)
error_analysis_table.set_Nmax(N_generator_max())
error_analysis_table.add_column("normalized_error",
group_name="scm",
operations=("min", "mean", "max"))
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine("SCM " + str(mu_index), fill="~"))
self.SCM_approximation.set_mu(mu)
(exact_stability_factor,
_) = self.SCM_approximation.evaluate_stability_factor()
for n in N_generator():
stability_factor_lower_bound = self.SCM_approximation.get_stability_factor_lower_bound(
n)
stability_factor_upper_bound = self.SCM_approximation.get_stability_factor_upper_bound(
n)
ratio_lower_bound_to_upper_bound = stability_factor_lower_bound / stability_factor_upper_bound
ratio_lower_bound_to_exact = stability_factor_lower_bound / exact_stability_factor
if ratio_lower_bound_to_upper_bound < 0. and not isclose(
ratio_lower_bound_to_upper_bound, 0.):
# if ratio_lower_bound_to_upper_bound << 0
print("SCM warning at mu = " + str(mu) +
": stability factor lower bound = " +
str(stability_factor_lower_bound) + " < 0")
if ratio_lower_bound_to_upper_bound > 1. and not isclose(
ratio_lower_bound_to_upper_bound, 1.):
# if ratio_lower_bound_to_upper_bound >> 1
print("SCM warning at mu = " + str(mu) +
": stability factor lower bound = " +
str(stability_factor_lower_bound) +
" > stability factor upper bound = " +
str(stability_factor_upper_bound))
if ratio_lower_bound_to_exact > 1. and not isclose(
ratio_lower_bound_to_exact, 1.):
# if ratio_lower_bound_to_exact >> 1
print("SCM warning at mu = " + str(mu) +
": stability factor lower bound = " +
str(stability_factor_lower_bound) +
" > exact stability factor =" +
str(exact_stability_factor))
error_analysis_table["normalized_error", n, mu_index] = (
exact_stability_factor - stability_factor_lower_bound
) / stability_factor_upper_bound
# Print
print("")
print(error_analysis_table)
print("")
print(TextBox("SCM error analysis ends", fill="="))
print("")
# Export error analysis table
error_analysis_table.save(
self.folder["error_analysis"],
"error_analysis" if filename is None else filename)
def _speedup_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator():
N = self.reduced_problem.N
if isinstance(N, dict):
N = min(N.values())
for n in range(1, N + 1): # n = 1, ... N
yield n
def N_generator_items():
for n in N_generator():
assert isinstance(n, (dict, int))
if isinstance(n, int):
yield (n, n)
elif isinstance(n, dict):
assert len(n) == 1
(n_int, n_online_size_dict) = n.popitem()
assert isinstance(n_int, int)
assert isinstance(n_online_size_dict, OnlineSizeDict)
yield (n_int, n_online_size_dict)
else:
raise TypeError(
"Invalid item generated by N_generator")
def N_generator_max():
*_, Nmax = N_generator_items()
assert isinstance(Nmax, tuple)
assert len(Nmax) == 2
assert isinstance(Nmax[0], int)
return Nmax[0]
print(
TextBox(self.truth_problem.name() + " " + self.label +
" speedup analysis begins",
fill="="))
print("")
speedup_analysis_table = SpeedupAnalysisTable(self.testing_set)
speedup_analysis_table.set_Nmax(N_generator_max())
speedup_analysis_table.add_column("speedup_solve",
group_name="speedup_solve",
operations=("min", "mean",
"max"))
speedup_analysis_table.add_column("speedup_output",
group_name="speedup_output",
operations=("min", "mean",
"max"))
truth_timer = Timer("parallel")
reduced_timer = Timer("serial")
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine(str(mu_index), fill="#"))
self.reduced_problem.set_mu(mu)
truth_timer.start()
self.truth_problem.solve(**kwargs)
elapsed_truth_solve = truth_timer.stop()
truth_timer.start()
self.truth_problem.compute_output()
elapsed_truth_output = truth_timer.stop()
for (n_int, n_arg) in N_generator_items():
reduced_timer.start()
solution = self.reduced_problem.solve(n_arg, **kwargs)
elapsed_reduced_solve = reduced_timer.stop()
reduced_timer.start()
output = self.reduced_problem.compute_output()
elapsed_reduced_output = reduced_timer.stop()
if solution is not NotImplemented:
speedup_analysis_table[
"speedup_solve", n_int,
mu_index] = elapsed_truth_solve / elapsed_reduced_solve
else:
speedup_analysis_table["speedup_solve", n_int,
mu_index] = NotImplemented
if output is not NotImplemented:
speedup_analysis_table[
"speedup_output", n_int,
mu_index] = (elapsed_truth_solve +
elapsed_truth_output) / (
elapsed_reduced_solve +
elapsed_reduced_output)
else:
speedup_analysis_table["speedup_output", n_int,
mu_index] = NotImplemented
# Print
print("")
print(speedup_analysis_table)
print("")
print(
TextBox(self.truth_problem.name() + " " + self.label +
" speedup analysis ends",
fill="="))
print("")
# Export speedup analysis table
speedup_analysis_table.save(
self.folder["speedup_analysis"],
"speedup_analysis" if filename is None else filename)
def _error_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator():
N = self.reduced_problem.N
if isinstance(N, dict):
N = min(N.values())
for n in range(1, N + 1): # n = 1, ... N
yield n
if "components" in kwargs:
components = kwargs["components"]
else:
components = self.truth_problem.components
def N_generator_items():
for n in N_generator():
assert isinstance(n, (dict, int))
if isinstance(n, int):
yield (n, n)
elif isinstance(n, dict):
assert len(n) == 1
(n_int, n_online_size_dict) = n.popitem()
assert isinstance(n_int, int)
assert isinstance(n_online_size_dict, OnlineSizeDict)
yield (n_int, n_online_size_dict)
else:
raise TypeError(
"Invalid item generated by N_generator")
def N_generator_max():
*_, Nmax = N_generator_items()
assert isinstance(Nmax, tuple)
assert len(Nmax) == 2
assert isinstance(Nmax[0], int)
return Nmax[0]
print(
TextBox(self.truth_problem.name() + " " + self.label +
" error analysis begins",
fill="="))
print("")
error_analysis_table = ErrorAnalysisTable(self.testing_set)
error_analysis_table.set_Nmax(N_generator_max())
for component in components:
error_analysis_table.add_column("error_" + component,
group_name="solution_" +
component,
operations=("mean", "max"))
error_analysis_table.add_column("relative_error_" + component,
group_name="solution_" +
component,
operations=("mean", "max"))
error_analysis_table.add_column("error_output",
group_name="output",
operations=("mean", "max"))
error_analysis_table.add_column("relative_error_output",
group_name="output",
operations=("mean", "max"))
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine(str(mu_index), fill="#"))
self.reduced_problem.set_mu(mu)
for (n_int, n_arg) in N_generator_items():
self.reduced_problem.solve(n_arg, **kwargs)
error = self.reduced_problem.compute_error(**kwargs)
relative_error = self.reduced_problem.compute_relative_error(
**kwargs)
self.reduced_problem.compute_output()
error_output = self.reduced_problem.compute_error_output(
**kwargs)
relative_error_output = self.reduced_problem.compute_relative_error_output(
**kwargs)
if len(components) > 1:
for component in components:
error_analysis_table["error_" + component, n_int,
mu_index] = error[component]
error_analysis_table[
"relative_error_" + component, n_int,
mu_index] = relative_error[component]
else:
component = components[0]
error_analysis_table["error_" + component, n_int,
mu_index] = error
error_analysis_table["relative_error_" + component,
n_int, mu_index] = relative_error
error_analysis_table["error_output", n_int,
mu_index] = error_output
error_analysis_table["relative_error_output", n_int,
mu_index] = relative_error_output
# Print
print("")
print(error_analysis_table)
print("")
print(
TextBox(self.truth_problem.name() + " " + self.label +
" error analysis ends",
fill="="))
print("")
# Export error analysis table
error_analysis_table.save(
self.folder["error_analysis"],
"error_analysis" if filename is None else filename)
def _speedup_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator(n):
return n
N = self.reduced_problem.N
if isinstance(N, dict):
N = min(N.values())
print(TextBox(self.truth_problem.name() + " " + self.label + " speedup analysis begins", fill="="))
print("")
speedup_analysis_table = SpeedupAnalysisTable(self.testing_set)
speedup_analysis_table.set_Nmax(N)
speedup_analysis_table.add_column("speedup_solve", group_name="speedup_solve", operations=("min", "mean", "max"))
speedup_analysis_table.add_column("speedup_output", group_name="speedup_output", operations=("min", "mean", "max"))
truth_timer = Timer("parallel")
reduced_timer = Timer("serial")
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine(str(mu_index), fill="#"))
self.reduced_problem.set_mu(mu)
truth_timer.start()
self.truth_problem.solve(**kwargs)
elapsed_truth_solve = truth_timer.stop()
truth_timer.start()
self.truth_problem.compute_output()
elapsed_truth_output = truth_timer.stop()
for n in range(1, N + 1): # n = 1, ... N
n_arg = N_generator(n)
if n_arg is not None:
reduced_timer.start()
solution = self.reduced_problem.solve(n_arg, **kwargs)
elapsed_reduced_solve = reduced_timer.stop()
reduced_timer.start()
output = self.reduced_problem.compute_output()
elapsed_reduced_output = reduced_timer.stop()
else:
solution = NotImplemented
output = NotImplemented
if solution is not NotImplemented:
speedup_analysis_table["speedup_solve", n, mu_index] = elapsed_truth_solve/elapsed_reduced_solve
else:
speedup_analysis_table["speedup_solve", n, mu_index] = NotImplemented
if output is not NotImplemented:
speedup_analysis_table["speedup_output", n, mu_index] = (elapsed_truth_solve + elapsed_truth_output)/(elapsed_reduced_solve + elapsed_reduced_output)
else:
speedup_analysis_table["speedup_output", n, mu_index] = NotImplemented
# Print
print("")
print(speedup_analysis_table)
print("")
print(TextBox(self.truth_problem.name() + " " + self.label + " speedup analysis ends", fill="="))
print("")
# Export speedup analysis table
speedup_analysis_table.save(self.folder["speedup_analysis"], "speedup_analysis" if filename is None else filename)
def _error_analysis(self, N_generator=None, filename=None, **kwargs):
if N_generator is None:
def N_generator(n):
return n
if "components" in kwargs:
components = kwargs["components"]
else:
components = self.truth_problem.components
N = self.reduced_problem.N
if isinstance(N, dict):
N = min(N.values())
print(TextBox(self.truth_problem.name() + " " + self.label + " error analysis begins", fill="="))
print("")
error_analysis_table = ErrorAnalysisTable(self.testing_set)
error_analysis_table.set_Nmax(N)
for component in components:
error_analysis_table.add_column("error_" + component, group_name="solution_" + component, operations=("mean", "max"))
error_analysis_table.add_column("relative_error_" + component, group_name="solution_" + component, operations=("mean", "max"))
error_analysis_table.add_column("error_output", group_name="output", operations=("mean", "max"))
error_analysis_table.add_column("relative_error_output", group_name="output", operations=("mean", "max"))
for (mu_index, mu) in enumerate(self.testing_set):
print(TextLine(str(mu_index), fill="#"))
self.reduced_problem.set_mu(mu)
for n in range(1, N + 1): # n = 1, ... N
n_arg = N_generator(n)
if n_arg is not None:
self.reduced_problem.solve(n_arg, **kwargs)
error = self.reduced_problem.compute_error(**kwargs)
relative_error = self.reduced_problem.compute_relative_error(**kwargs)
self.reduced_problem.compute_output()
error_output = self.reduced_problem.compute_error_output(**kwargs)
relative_error_output = self.reduced_problem.compute_relative_error_output(**kwargs)
else:
if len(components) > 1:
error = {component: NotImplemented for component in components}
relative_error = {component: NotImplemented for component in components}
else:
error = NotImplemented
relative_error = NotImplemented
error_output = NotImplemented
relative_error_output = NotImplemented
if len(components) > 1:
for component in components:
error_analysis_table["error_" + component, n, mu_index] = error[component]
error_analysis_table["relative_error_" + component, n, mu_index] = relative_error[component]
else:
component = components[0]
error_analysis_table["error_" + component, n, mu_index] = error
error_analysis_table["relative_error_" + component, n, mu_index] = relative_error
error_analysis_table["error_output", n, mu_index] = error_output
error_analysis_table["relative_error_output", n, mu_index] = relative_error_output
# Print
print("")
print(error_analysis_table)
print("")
print(TextBox(self.truth_problem.name() + " " + self.label + " error analysis ends", fill="="))
print("")
# Export error analysis table
error_analysis_table.save(self.folder["error_analysis"], "error_analysis" if filename is None else filename)
