void Ephemeris<Frame>::WriteToMessage(
not_null<serialization::Ephemeris*> const message) const {
LOG(INFO) << __FUNCTION__;
// The bodies are serialized in the order in which they were given at
// construction.
for (auto const& unowned_body : unowned_bodies_) {
unowned_body->WriteToMessage(message->add_body());
}
// The trajectories are serialized in the order resulting from the separation
// between oblate and spherical bodies.
if (checkpoints_.empty()) {
for (auto const& trajectory : trajectories_) {
trajectory->WriteToMessage(message->add_trajectory());
}
last_state_.WriteToMessage(message->mutable_last_state());
} else {
auto const& checkpoints = checkpoints_.front().checkpoints;
CHECK_EQ(trajectories_.size(), checkpoints.size());
for (int i = 0; i < trajectories_.size(); ++i) {
trajectories_[i]->WriteToMessage(message->add_trajectory(),
checkpoints[i]);
}
checkpoints_.front().system_state.WriteToMessage(
message->mutable_last_state());
t_max().WriteToMessage(message->mutable_t_max());
}
parameters_.WriteToMessage(message->mutable_fixed_step_parameters());
fitting_tolerance_.WriteToMessage(message->mutable_fitting_tolerance());
LOG(INFO) << NAMED(message->SpaceUsed());
LOG(INFO) << NAMED(message->ByteSize());
}
void DiscreteTrajectory<Frame>::WriteToMessage(
not_null<serialization::Trajectory*> const message,
std::vector<DiscreteTrajectory<Frame>*> const& forks)
const {
LOG(INFO) << __FUNCTION__;
CHECK(this->is_root());
std::vector<DiscreteTrajectory<Frame>*> mutable_forks = forks;
WriteSubTreeToMessage(message, mutable_forks);
CHECK(std::all_of(mutable_forks.begin(),
mutable_forks.end(),
[](DiscreteTrajectory<Frame>* const fork) {
return fork == nullptr;
}));
LOG(INFO) << NAMED(this);
LOG(INFO) << NAMED(message->SpaceUsed());
LOG(INFO) << NAMED(message->ByteSize());
}
void ContinuousTrajectory<Frame>::WriteToMessage(
not_null<serialization::ContinuousTrajectory*> const message,
Checkpoint const& checkpoint) const {
LOG(INFO) << __FUNCTION__;
step_.WriteToMessage(message->mutable_step());
tolerance_.WriteToMessage(message->mutable_tolerance());
checkpoint.adjusted_tolerance_.WriteToMessage(
message->mutable_adjusted_tolerance());
message->set_is_unstable(checkpoint.is_unstable_);
message->set_degree(checkpoint.degree_);
message->set_degree_age(checkpoint.degree_age_);
for (auto const& s : series_) {
if (s.t_max() <= checkpoint.t_max_) {
s.WriteToMessage(message->add_series());
}
if (s.t_max() == checkpoint.t_max_) {
break;
}
CHECK_LT(s.t_max(), checkpoint.t_max_);
}
if (first_time_) {
first_time_->WriteToMessage(message->mutable_first_time());
}
for (auto const& pair : checkpoint.last_points_) {
Instant const& instant = pair.first;
DegreesOfFreedom<Frame> const& degrees_of_freedom = pair.second;
not_null<
serialization::ContinuousTrajectory::InstantaneousDegreesOfFreedom*>
const instantaneous_degrees_of_freedom = message->add_last_point();
instant.WriteToMessage(instantaneous_degrees_of_freedom->mutable_instant());
degrees_of_freedom.WriteToMessage(
instantaneous_degrees_of_freedom->mutable_degrees_of_freedom());
}
LOG(INFO) << NAMED(this);
LOG(INFO) << NAMED(message->SpaceUsed());
LOG(INFO) << NAMED(message->ByteSize());
}
