// Tests that serialization and deserialization work. TEST_P(SymmetricLinearMultistepIntegratorTest, Serialization) { LOG(INFO) << GetParam(); Length const q_initial = 1 * Metre; Speed const v_initial = 0 * Metre / Second; Instant const t_initial; 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(ComputeHarmonicOscillatorAcceleration1D, _1, _2, _3, /*evaluations=*/nullptr); IntegrationProblem<ODE> problem; problem.equation = harmonic_oscillator; problem.initial_state = {{q_initial}, {v_initial}, t_initial}; auto const append_state = [&solution](ODE::SystemState const& state) { solution.push_back(state); }; auto const instance1 = GetParam().integrator.NewInstance(problem, append_state, step); serialization::IntegratorInstance message1; instance1->WriteToMessage(&message1); auto const instance2 = FixedStepSizeIntegrator<ODE>::Instance::ReadFromMessage( message1, harmonic_oscillator, append_state); serialization::IntegratorInstance message2; instance2->WriteToMessage(&message2); EXPECT_THAT(message1, EqualsProto(message2)); }
TEST_F(EmbeddedExplicitRungeKuttaNyströmIntegratorTest, Serialization) { AdaptiveStepSizeIntegrator<ODE> const& integrator = EmbeddedExplicitRungeKuttaNyströmIntegrator< methods::DormandالمكاوىPrince1986RKN434FM, Length>(); Length const x_initial = 1 * Metre; Speed const v_initial = 0 * Metre / Second; Time const period = 2 * π * Second; Instant const t_initial; Instant const t_final = t_initial + 10 * period; Length const length_tolerance = 1 * Milli(Metre); Speed const speed_tolerance = 1 * Milli(Metre) / Second; auto const step_size_callback = [](bool tolerable) {}; std::vector<ODE::SystemState> solution; 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 = [&solution](ODE::SystemState const& state) { solution.push_back(state); }; AdaptiveStepSizeIntegrator<ODE>::Parameters const parameters( /*first_time_step=*/t_final - t_initial, /*safety_factor=*/0.9); auto const tolerance_to_error_ratio = std::bind(HarmonicOscillatorToleranceRatio, _1, _2, length_tolerance, speed_tolerance, step_size_callback); auto const instance1 = integrator.NewInstance(problem, append_state, tolerance_to_error_ratio, parameters); serialization::IntegratorInstance message1; instance1->WriteToMessage(&message1); auto const instance2 = AdaptiveStepSizeIntegrator<ODE>::Instance::ReadFromMessage( message1, harmonic_oscillator, append_state, tolerance_to_error_ratio); serialization::IntegratorInstance message2; instance2->WriteToMessage(&message2); EXPECT_THAT(message1, EqualsProto(message2)); }
void TestRotatingBody() { using F = Frame<Tag, tag, true>; AngularVelocity<F> const angular_velocity = AngularVelocity<F>({-1 * Radian / Second, 2 * Radian / Second, 5 * Radian / Second}); auto const rotating_body = RotatingBody<F>(17 * SIUnit<GravitationalParameter>(), typename RotatingBody<F>::Parameters( 3 * Radian, Instant() + 4 * Second, angular_velocity)); serialization::Body message; RotatingBody<F> const* cast_rotating_body; rotating_body.WriteToMessage(&message); EXPECT_TRUE(message.has_massive_body()); EXPECT_FALSE(message.has_massless_body()); EXPECT_TRUE(message.massive_body().HasExtension( serialization::RotatingBody::rotating_body)); not_null<std::unique_ptr<MassiveBody const>> const massive_body = MassiveBody::ReadFromMessage(message); EXPECT_EQ(rotating_body.gravitational_parameter(), massive_body->gravitational_parameter()); cast_rotating_body = dynamic_cast<RotatingBody<F> const*>(&*massive_body); EXPECT_THAT(cast_rotating_body, NotNull()); }
TEST_F(PluginCompatibilityTest, PreBourbaki) { // Read the entire hex data. std::fstream file = std::fstream( SOLUTION_DIR / "ksp_plugin_test" / "pre_bourbaki.proto.hex"); CHECK(file.good()); std::string hex; while (!file.eof()) { std::string line; std::getline(file, line); for (auto const c : line) { if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')) { hex.append(1, c); } } } file.close(); // Parse it and convert to binary data. UniqueBytes bin(hex.size() / 2); HexadecimalDecode(Array<std::uint8_t const>( reinterpret_cast<const std::uint8_t*>(hex.c_str()), hex.size()), bin.get()); // Construct a protocol buffer from the binary data. google::protobuf::io::CodedInputStream coded_input_stream( bin.data.get(), static_cast<int>(bin.size)); serialization::Plugin pre_bourbaki_serialized_plugin; CHECK(pre_bourbaki_serialized_plugin.MergeFromCodedStream( &coded_input_stream)); // Construct a plugin from the protocol buffer. auto plugin = TestablePlugin::ReadFromMessage(pre_bourbaki_serialized_plugin); // Do some operations on the plugin. plugin->KeepAllVessels(); plugin->AdvanceTime(plugin->current_time() + 1 * Second, 2 * Radian); plugin->AdvanceTime(plugin->current_time() + 1 * Hour, 3 * Radian); // Serialize and deserialize it in the new format. serialization::Plugin post_bourbaki_serialized_plugin; plugin->WriteToMessage(&post_bourbaki_serialized_plugin); plugin = TestablePlugin::ReadFromMessage(post_bourbaki_serialized_plugin); }
void Identity<FromFrame, ToFrame>::WriteToMessage( not_null<serialization::LinearMap*> const message) const { LinearMap<FromFrame, ToFrame>::WriteToMessage(message); WriteToMessage(message->MutableExtension(serialization::Identity::identity)); }
inline void MassiveBody::WriteToMessage( not_null<serialization::Body*> const message) const { WriteToMessage(message->mutable_massive_body()); }
void Permutation<FromFrame, ToFrame>::WriteToMessage( not_null<serialization::LinearMap*> const message) const { LinearMap<FromFrame, ToFrame>::WriteToMessage(message); WriteToMessage( message->MutableExtension(serialization::Permutation::extension)); }