void SolveHarmonicOscillatorAndComputeError3D(benchmark::State& state,
Length& q_error,
Speed& v_error,
Integrator const& integrator) {
using ODE = SpecialSecondOrderDifferentialEquation<Position<World>>;
state.PauseTiming();
Displacement<World> const q_initial({1 * Metre, 0 * Metre, 0 * Metre});
Velocity<World> const v_initial;
Instant const t_initial;
#ifdef _DEBUG
Instant const t_final = t_initial + 100 * Second;
#else
Instant const t_final = t_initial + 1000 * Second;
#endif
Time const step = 3.0e-4 * Second;
std::vector<ODE::SystemState> solution;
solution.reserve(static_cast<int>((t_final - t_initial) / step));
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration3D, _1, _2, _3);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
ODE::SystemState const initial_state = {{World::origin + q_initial},
{v_initial},
t_initial};
problem.initial_state = &initial_state;
auto append_state = [&solution](ODE::SystemState const& state) {
solution.emplace_back(state);
};
auto const instance =
integrator.NewInstance(problem, std::move(append_state), step);
state.ResumeTiming();
integrator.Solve(t_final, *instance);
state.PauseTiming();
q_error = Length();
v_error = Speed();
for (auto const& state : solution) {
q_error = std::max(q_error,
((state.positions[0].value - World::origin) -
q_initial *
Cos((state.time.value - t_initial) *
(Radian / Second))).Norm());
v_error = std::max(v_error,
(state.velocities[0].value +
(q_initial / Second) *
Sin((state.time.value - t_initial) *
(Radian / Second))).Norm());
}
state.ResumeTiming();
}
void TestSymplecticity(Integrator const& integrator,
Energy const& expected_energy_error) {
Length const q_initial = 1 * Metre;
Speed const v_initial = 0 * Metre / Second;
Instant const t_initial;
Instant const t_final = t_initial + 500 * Second;
Time const step = 0.2 * Second;
Mass const m = 1 * Kilogram;
Stiffness const k = SIUnit<Stiffness>();
Energy const initial_energy =
0.5 * m * Pow<2>(v_initial) + 0.5 * k * Pow<2>(q_initial);
std::vector<ODE::SystemState> solution;
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration,
_1, _2, _3, /*evaluations=*/nullptr);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
ODE::SystemState const initial_state = {{q_initial}, {v_initial}, t_initial};
problem.initial_state = &initial_state;
auto append_state = [&solution](ODE::SystemState const& state) {
solution.push_back(state);
};
auto const instance =
integrator.NewInstance(problem, std::move(append_state), step);
integrator.Solve(t_final, *instance);
std::size_t const length = solution.size();
std::vector<Energy> energy_error(length);
std::vector<Time> time(length);
Energy max_energy_error;
for (std::size_t i = 0; i < length; ++i) {
Length const q_i = solution[i].positions[0].value;
Speed const v_i = solution[i].velocities[0].value;
time[i] = solution[i].time.value - t_initial;
energy_error[i] =
AbsoluteError(initial_energy,
0.5 * m * Pow<2>(v_i) + 0.5 * k * Pow<2>(q_i));
max_energy_error = std::max(energy_error[i], max_energy_error);
}
double const correlation =
PearsonProductMomentCorrelationCoefficient(time, energy_error);
LOG(INFO) << "Correlation between time and energy error : " << correlation;
EXPECT_THAT(correlation, Lt(1e-2));
Power const slope = Slope(time, energy_error);
LOG(INFO) << "Slope : " << slope;
EXPECT_THAT(Abs(slope), Lt(2e-6 * SIUnit<Power>()));
LOG(INFO) << "Maximum energy error : " <<
max_energy_error;
EXPECT_EQ(expected_energy_error, max_energy_error);
}
void Test1000SecondsAt1Millisecond(
Integrator const& integrator,
Length const& expected_position_error,
Speed const& expected_velocity_error) {
Length const q_initial = 1 * Metre;
Speed const v_initial = 0 * Metre / Second;
Speed const v_amplitude = 1 * Metre / Second;
AngularFrequency const ω = 1 * Radian / Second;
Instant const t_initial;
#if defined(_DEBUG)
Instant const t_final = t_initial + 1 * Second;
#else
Instant const t_final = t_initial + 1000 * Second;
#endif
Time const step = 1 * Milli(Second);
int const steps = static_cast<int>((t_final - t_initial) / step) - 1;
int evaluations = 0;
std::vector<ODE::SystemState> solution;
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration,
_1, _2, _3, &evaluations);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
ODE::SystemState const initial_state = {{q_initial}, {v_initial}, t_initial};
problem.initial_state = &initial_state;
auto append_state = [&solution](ODE::SystemState const& state) {
solution.push_back(state);
};
auto const instance =
integrator.NewInstance(problem, std::move(append_state), step);
integrator.Solve(t_final, *instance);
EXPECT_EQ(steps, solution.size());
Length q_error;
Speed v_error;
for (int i = 0; i < steps; ++i) {
Length const q = solution[i].positions[0].value;
Speed const v = solution[i].velocities[0].value;
Time const t = solution[i].time.value - t_initial;
EXPECT_THAT(t, AlmostEquals((i + 1) * step, 0));
// TODO(egg): we may need decent trig functions for this sort of thing.
q_error = std::max(q_error, AbsoluteError(q_initial * Cos(ω * t), q));
v_error = std::max(v_error, AbsoluteError(-v_amplitude * Sin(ω * t), v));
}
#if !defined(_DEBUG)
EXPECT_EQ(expected_position_error, q_error);
EXPECT_EQ(expected_velocity_error, v_error);
#endif
}
void TestTermination(Integrator const& integrator) {
Length const q_initial = 1 * Metre;
Speed const v_initial = 0 * Metre / Second;
Instant const t_initial;
Instant const t_final = t_initial + 1630 * Second;
Time const step = 42 * Second;
int const steps = static_cast<int>(std::floor((t_final - t_initial) / step));
int evaluations = 0;
std::vector<ODE::SystemState> solution;
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration,
_1, _2, _3, &evaluations);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
ODE::SystemState const initial_state = {{q_initial}, {v_initial}, t_initial};
problem.initial_state = &initial_state;
auto append_state = [&solution](ODE::SystemState const& state) {
solution.push_back(state);
};
auto const instance =
integrator.NewInstance(problem, std::move(append_state), step);
integrator.Solve(t_final, *instance);
EXPECT_EQ(steps, solution.size());
EXPECT_THAT(solution.back().time.value,
AllOf(Gt(t_final - step), Le(t_final)));
Length q_error;
Speed v_error;
for (int i = 0; i < steps; ++i) {
Time const t = solution[i].time.value - t_initial;
EXPECT_THAT(t, AlmostEquals((i + 1) * step, 0));
}
}
void TestConvergence(Integrator const& integrator,
Time const& beginning_of_convergence) {
Length const q_initial = 1 * Metre;
Speed const v_initial = 0 * Metre / Second;
Speed const v_amplitude = 1 * Metre / Second;
AngularFrequency const ω = 1 * Radian / Second;
Instant const t_initial;
Instant const t_final = t_initial + 100 * Second;
Time step = beginning_of_convergence;
int const step_sizes = 50;
double const step_reduction = 1.1;
std::vector<double> log_step_sizes;
log_step_sizes.reserve(step_sizes);
std::vector<double> log_q_errors;
log_step_sizes.reserve(step_sizes);
std::vector<double> log_p_errors;
log_step_sizes.reserve(step_sizes);
std::vector<ODE::SystemState> solution;
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration,
_1, _2, _3, /*evaluations=*/nullptr);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
ODE::SystemState const initial_state = {{q_initial}, {v_initial}, t_initial};
problem.initial_state = &initial_state;
ODE::SystemState final_state;
auto const append_state = [&final_state](ODE::SystemState const& state) {
final_state = state;
};
for (int i = 0; i < step_sizes; ++i, step /= step_reduction) {
auto const instance = integrator.NewInstance(problem, append_state, step);
integrator.Solve(t_final, *instance);
Time const t = final_state.time.value - t_initial;
Length const& q = final_state.positions[0].value;
Speed const& v = final_state.velocities[0].value;
double const log_q_error = std::log10(
AbsoluteError(q / q_initial, Cos(ω * t)));
double const log_p_error = std::log10(
AbsoluteError(v / v_amplitude, -Sin(ω * t)));
if (log_q_error <= -13 || log_p_error <= -13) {
// If we keep going the effects of finite precision will drown out
// convergence.
break;
}
log_step_sizes.push_back(std::log10(step / Second));
log_q_errors.push_back(log_q_error);
log_p_errors.push_back(log_p_error);
}
double const q_convergence_order = Slope(log_step_sizes, log_q_errors);
double const q_correlation =
PearsonProductMomentCorrelationCoefficient(log_step_sizes, log_q_errors);
LOG(INFO) << "Convergence order in q : " << q_convergence_order;
LOG(INFO) << "Correlation : " << q_correlation;
#if !defined(_DEBUG)
EXPECT_THAT(RelativeError(integrator.order, q_convergence_order),
Lt(0.05));
EXPECT_THAT(q_correlation, AllOf(Gt(0.99), Lt(1.01)));
#endif
double const v_convergence_order = Slope(log_step_sizes, log_p_errors);
double const v_correlation =
PearsonProductMomentCorrelationCoefficient(log_step_sizes, log_p_errors);
LOG(INFO) << "Convergence order in p : " << v_convergence_order;
LOG(INFO) << "Correlation : " << v_correlation;
#if !defined(_DEBUG)
// SPRKs with odd convergence order have a higher convergence order in p.
EXPECT_THAT(
RelativeError(integrator.order + (integrator.order % 2),
v_convergence_order),
Lt(0.03));
EXPECT_THAT(v_correlation, AllOf(Gt(0.99), Lt(1.01)));
#endif
}
