void MoveOrdererTest::test_order()
{
QFETCH(ChessBoard, board);
QFETCH(bool, has_hash_move);
QFETCH(SearchResult, entry);
QFETCH(bool, has_killer_move);
QFETCH(Move, killer_move);
QFETCH(vector<Move>, moves);
QFETCH(vector<Move>, ordered_moves);
SearchContext context;
context.search_depth = 1;
context.board = board;
if (has_hash_move) {
context.put(0, entry);
}
if (has_killer_move) {
context.killers.resize(1);
context.killers[0][0] = killer_move;
}
SearchState state;
state.depth = 1;
m_orderer.order_moves(entry, state, &context, &moves);
QASSERT_THAT(moves, ElementsAreArray(ordered_moves));
}
TEST_F(LocalConnectionTest, send_binary) {
const auto kExpected = ElementsAreArray(&bytes_[0], bytes_.size());
Connection::Ptr conn(LocalConnection::New());
Connection::Ptr other(((LocalConnection*) conn.get())->other());
ConnectionDelegateMock mock;
EXPECT_CALL(mock, OnBinary(other.get(), kExpected));
other->BindDelegate(&mock);
conn->SendBinary(bytes_);
}
TEST_F(SolarSystemTest, Clear) {
solar_system_.Initialize(
SOLUTION_DIR / "astronomy" / "gravity_model.proto.txt",
SOLUTION_DIR / "astronomy" /
"initial_state_jd_2433282_500000000.proto.txt");
solar_system_.RemoveMassiveBody("Io");
solar_system_.RemoveOblateness("Sun");
EXPECT_THAT(solar_system_.names(),
ElementsAreArray({"Ariel",
"Callisto",
"Ceres",
"Charon",
"Deimos",
"Dione",
"Earth",
"Enceladus",
"Eris",
"Europa",
"Ganymede",
"Iapetus",
"Jupiter",
"Mars",
"Mercury",
"Mimas",
"Miranda",
"Moon",
"Neptune",
"Oberon",
"Phobos",
"Pluto",
"Rhea",
"Saturn",
"Sun",
"Tethys",
"Titan",
"Titania",
"Triton",
"Umbriel",
"Uranus",
"Venus",
"Vesta"}));
auto const& sun_initial_state = solar_system_.initial_state_message("Sun");
EXPECT_EQ("+1.309126697236264E+05 km", sun_initial_state.x());
EXPECT_EQ("-7.799754996220354E-03 km/s", sun_initial_state.vx());
auto const& sun_gravity_model = solar_system_.gravity_model_message("Sun");
EXPECT_FALSE(sun_gravity_model.has_axis_right_ascension());
EXPECT_FALSE(sun_gravity_model.has_axis_declination());
}
TEST_F(PullSerializerTest, SerializationSizes) {
auto trajectory = BuildTrajectory();
pull_serializer_->Start(std::move(trajectory));
std::vector<std::int64_t> actual_sizes;
std::vector<std::int64_t> expected_sizes(53, kChunkSize);
expected_sizes.push_back(53);
for (;;) {
Bytes const bytes = pull_serializer_->Pull();
if (bytes.size == 0) {
break;
}
actual_sizes.push_back(bytes.size);
}
EXPECT_THAT(actual_sizes, ElementsAreArray(expected_sizes));
}
TEST_F(EmbeddedExplicitRungeKuttaNyströmIntegratorTest, Restart) {
AdaptiveStepSizeIntegrator<ODE> const& integrator =
EmbeddedExplicitRungeKuttaNyströmIntegrator<
methods::DormandالمكاوىPrince1986RKN434FM,
Length>();
Length const x_initial = 1 * Metre;
Speed const v_initial = 0 * Metre / Second;
Speed const v_amplitude = 1 * Metre / Second;
Time const period = 2 * π * Second;
AngularFrequency const ω = 1 * Radian / Second;
Instant const t_initial;
Time const duration = 10 * period;
Length const length_tolerance = 1 * Milli(Metre);
Speed const speed_tolerance = 1 * Milli(Metre) / Second;
// The number of steps if no step limit is set.
std::int64_t const steps_forward = 132;
auto const step_size_callback = [](bool tolerable) {};
std::vector<ODE::SystemState> solution1;
{
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration1D,
_1, _2, _3, /*evaluations=*/nullptr);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
problem.initial_state = {{x_initial}, {v_initial}, t_initial};
auto const append_state = [&solution1](ODE::SystemState const& state) {
solution1.push_back(state);
};
AdaptiveStepSizeIntegrator<ODE>::Parameters const parameters(
/*first_time_step=*/duration,
/*safety_factor=*/0.9,
/*max_steps=*/std::numeric_limits<std::int64_t>::max(),
/*last_step_is_exact=*/false);
auto const tolerance_to_error_ratio =
std::bind(HarmonicOscillatorToleranceRatio,
_1, _2,
length_tolerance,
speed_tolerance,
step_size_callback);
auto const instance = integrator.NewInstance(problem,
append_state,
tolerance_to_error_ratio,
parameters);
auto outcome = instance->Solve(t_initial + duration);
EXPECT_EQ(termination_condition::Done, outcome.error());
// Check that the time step has been updated.
EXPECT_EQ(131, solution1.size());
EXPECT_THAT(
solution1[solution1.size() - 1].time.value -
solution1[solution1.size() - 2].time.value,
AlmostEquals(0.509'363'975'335'290'320 * Second, 0));
// Restart the integration.
outcome = instance->Solve(t_initial + 2.0 * duration);
EXPECT_EQ(termination_condition::Done, outcome.error());
// Check that the time step has been updated again.
EXPECT_EQ(261, solution1.size());
EXPECT_THAT(
solution1[solution1.size() - 1].time.value -
solution1[solution1.size() - 2].time.value,
AlmostEquals(0.506'410'259'195'249'068 * Second, 0));
}
// Do it again in one call to |Solve| and check associativity.
std::vector<ODE::SystemState> solution2;
{
ODE harmonic_oscillator;
harmonic_oscillator.compute_acceleration =
std::bind(ComputeHarmonicOscillatorAcceleration1D,
_1, _2, _3, /*evaluations=*/nullptr);
IntegrationProblem<ODE> problem;
problem.equation = harmonic_oscillator;
problem.initial_state = {{x_initial}, {v_initial}, t_initial};
auto const append_state = [&solution2](ODE::SystemState const& state) {
solution2.push_back(state);
};
AdaptiveStepSizeIntegrator<ODE>::Parameters const parameters(
/*first_time_step=*/duration,
/*safety_factor=*/0.9,
/*max_steps=*/std::numeric_limits<std::int64_t>::max(),
/*last_step_is_exact=*/false);
auto const tolerance_to_error_ratio =
std::bind(HarmonicOscillatorToleranceRatio,
_1, _2,
length_tolerance,
speed_tolerance,
step_size_callback);
auto const instance = integrator.NewInstance(problem,
append_state,
tolerance_to_error_ratio,
parameters);
auto outcome = instance->Solve(t_initial + 2.0 * duration);
EXPECT_EQ(termination_condition::Done, outcome.error());
}
EXPECT_THAT(solution2, ElementsAreArray(solution1));
}
TEST_F(SolarSystemTest, RealSolarSystem) {
solar_system_.Initialize(
SOLUTION_DIR / "astronomy" / "gravity_model.proto.txt",
SOLUTION_DIR / "astronomy" /
"initial_state_jd_2433282_500000000.proto.txt");
EXPECT_EQ(Instant() - 50 * 365.25 * Day, solar_system_.epoch());
EXPECT_THAT(solar_system_.names(),
ElementsAreArray({"Ariel",
"Callisto",
"Ceres",
"Charon",
"Deimos",
"Dione",
"Earth",
"Enceladus",
"Eris",
"Europa",
"Ganymede",
"Iapetus",
"Io",
"Jupiter",
"Mars",
"Mercury",
"Mimas",
"Miranda",
"Moon",
"Neptune",
"Oberon",
"Phobos",
"Pluto",
"Rhea",
"Saturn",
"Sun",
"Tethys",
"Titan",
"Titania",
"Triton",
"Umbriel",
"Uranus",
"Venus",
"Vesta"}));
EXPECT_EQ(1, solar_system_.index("Callisto"));
EXPECT_EQ(32, solar_system_.index("Venus"));
auto const ephemeris = solar_system_.MakeEphemeris(
/*fitting_tolerance=*/1 * Metre,
Ephemeris<ICRFJ2000Equator>::FixedStepParameters(
integrators::McLachlanAtela1992Order4Optimal<
Position<ICRFJ2000Equator>>(),
/*step=*/1 * Second));
auto const earth = solar_system_.massive_body(*ephemeris, "Earth");
EXPECT_LT(RelativeError(5.97258 * Yotta(Kilogram), earth->mass()), 6E-9);
auto const& earth_trajectory = solar_system_.trajectory(*ephemeris, "Earth");
EXPECT_TRUE(earth_trajectory.empty());
auto const& sun_initial_state = solar_system_.initial_state_message("Sun");
EXPECT_EQ("+1.309126697236264E+05 km", sun_initial_state.x());
EXPECT_EQ("-7.799754996220354E-03 km/s", sun_initial_state.vx());
auto const& sun_gravity_model = solar_system_.gravity_model_message("Sun");
EXPECT_EQ("286.13 deg", sun_gravity_model.axis_right_ascension());
EXPECT_EQ("63.87 deg", sun_gravity_model.axis_declination());
}
