Merge pull request #3160 from pleroy/Compatibility2

Compatibility deserialization of DiscreteTrajectory2

Author: pleroy

base/pull_serializer_test.cpp

@@ -49,8 +49,7 @@ class PullSerializerTest : public ::testing::Test {
         make_not_null_unique<DiscreteTrajectory>();
     // Build a biggish protobuf for serialization.
     for (int i = 0; i < 100; ++i) {
-      DiscreteTrajectory::InstantaneousDegreesOfFreedom* idof =
-          result->add_timeline();
+      auto* const idof = result->add_timeline();
       Point* instant = idof->mutable_instant();
       Quantity* scalar = instant->mutable_scalar();
       scalar->set_dimensions(3);

base/push_deserializer_test.cpp

@@ -66,8 +66,7 @@ class PushDeserializerTest : public ::testing::Test {
         make_not_null_unique<DiscreteTrajectory>();
     // Build a biggish protobuf for serialization.
     for (int i = 0; i < 100; ++i) {
-      DiscreteTrajectory::InstantaneousDegreesOfFreedom* idof =
-          result->add_timeline();
+      auto* const idof = result->add_timeline();
       Point* instant = idof->mutable_instant();
       Quantity* scalar = instant->mutable_scalar();
       scalar->set_dimensions(3);

ksp_plugin_test/ksp_plugin_test.vcxproj

@@ -50,6 +50,7 @@
     <ClCompile Include="..\numerics\elliptic_functions.cpp" />
     <ClCompile Include="..\numerics\elliptic_integrals.cpp" />
     <ClCompile Include="..\physics\protector.cpp" />
+    <ClCompile Include="..\testing_utilities\string_log_sink.cpp" />
     <ClCompile Include="benchmark.cpp" />
     <ClCompile Include="celestial_test.cpp" />
     <ClCompile Include="equator_relevance_threshold_test.cpp" />

ksp_plugin_test/ksp_plugin_test.vcxproj.filters

@@ -197,6 +197,9 @@
     <ClCompile Include="plugin_compatibility_test.cpp">
       <Filter>Test Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\testing_utilities\string_log_sink.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="mock_plugin.hpp">

ksp_plugin_test/plugin_compatibility_test.cpp

@@ -22,6 +22,7 @@
 #include "serialization/ksp_plugin.pb.h"
 #include "testing_utilities/is_near.hpp"
 #include "testing_utilities/serialization.hpp"
+#include "testing_utilities/string_log_sink.hpp"
 
 namespace principia {
 namespace interface {
@@ -47,6 +48,7 @@ using testing_utilities::IsNear;
 using testing_utilities::ReadFromBinaryFile;
 using testing_utilities::ReadLinesFromBase64File;
 using testing_utilities::ReadLinesFromHexadecimalFile;
+using testing_utilities::StringLogSink;
 using testing_utilities::WriteToBinaryFile;
 using ::testing::AllOf;
 using ::testing::ElementsAre;
@@ -61,43 +63,6 @@ using ::testing::internal::GetCapturedStderr;
 const char preferred_compressor[] = "gipfeli";
 const char preferred_encoder[] = "base64";
 
-class StringLogSink : google::LogSink {
- public:
-  explicit StringLogSink(google::LogSeverity const minimal_severity)
-      : minimal_severity_(minimal_severity) {
-    google::AddLogSink(this);
-  }
-
-  ~StringLogSink() {
-    google::RemoveLogSink(this);
-  }
-
-  void send(google::LogSeverity const severity,
-            char const* const full_filename,
-            char const* const base_filename,
-            int const line,
-            tm const* const tm_time,
-            const char* const message,
-            size_t const message_len) override {
-    if (severity < minimal_severity_) {
-      return;
-    }
-    absl::MutexLock lock(&mutex_);
-    absl::StrAppend(
-        &string_,
-        ToString(severity, base_filename, line, tm_time, message, message_len));
-  }
-
-  std::string& string() {
-    return string_;
-  }
-
- private:
-  google::LogSeverity const minimal_severity_;
-  absl::Mutex mutex_;
-  std::string string_ GUARDED_BY(mutex_);
-};
-
 class PluginCompatibilityTest : public testing::Test {
  protected:
   PluginCompatibilityTest()
@@ -375,6 +340,28 @@ TEST_F(PluginCompatibilityTest, DISABLED_Lpg) {
   EXPECT_EQ(435'927, history->Size());
   EXPECT_EQ(435'929, psychohistory.Size());
 
+  // Evaluate a point in each of the two segments.
+  EXPECT_THAT(history->EvaluateDegreesOfFreedom("1957-10-04T19:28:34"_TT),
+              Eq(DegreesOfFreedom<Barycentric>(
+                  Barycentric::origin + Displacement<Barycentric>(
+                                            {+1.47513683827317657e+11 * Metre,
+                                             +2.88696086355042419e+10 * Metre,
+                                             +1.24740082262952404e+10 * Metre}),
+                  Velocity<Barycentric>(
+                      {-6.28845231836519179e+03 * (Metre / Second),
+                       +2.34046542233168329e+04 * (Metre / Second),
+                       +4.64410011408655919e+03 * (Metre / Second)}))));
+  EXPECT_THAT(psychohistory.EvaluateDegreesOfFreedom("1958-10-07T09:38:30"_TT),
+              Eq(DegreesOfFreedom<Barycentric>(
+                  Barycentric::origin + Displacement<Barycentric>(
+                                            {+1.45814173315801941e+11 * Metre,
+                                             +3.45409490426372147e+10 * Metre,
+                                             +1.49445864962450924e+10 * Metre}),
+                  Velocity<Barycentric>(
+                      {-8.70708379504568074e+03 * (Metre / Second),
+                       +2.61488327506437054e+04 * (Metre / Second),
+                       +1.90319283138508908e+04 * (Metre / Second)}))));
+
   // Serialize the history and psychohistory to a temporary file.
   {
     serialization::DiscreteTrajectory message;

physics/discrete_trajectory2.hpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "absl/container/btree_map.h"
+#include "absl/status/status.h"
 #include "base/macros.hpp"
 #include "base/not_null.hpp"
 #include "base/tags.hpp"
@@ -108,6 +109,8 @@ class DiscreteTrajectory2 : public Trajectory<Frame> {
       std::vector<SegmentIterator*> const& tracked);
 
  private:
+  using DownsamplingParameters =
+      internal_discrete_trajectory_types::DownsamplingParameters;
   using Segments = internal_discrete_trajectory_types::Segments<Frame>;
 
   // This constructor leaves the list of segments empty (but allocated) as well
@@ -117,6 +120,10 @@ class DiscreteTrajectory2 : public Trajectory<Frame> {
   typename Segments::iterator FindSegment(Instant const& t);
   typename Segments::const_iterator FindSegment(Instant const& t) const;
 
+  // Checks if this objects is in a consistent state, and returns an error
+  // status with a relevant message if it isn't.
+  absl::Status ValidateConsistency() const;
+
   // Updates the segments self-pointers and the time-to-segment mapping after
   // segments have been spliced from |from| to |to|.  The iterators indicate the
   // segments to fix-up.
@@ -126,6 +133,31 @@ class DiscreteTrajectory2 : public Trajectory<Frame> {
       typename Segments::iterator to_segments_begin,
       std::reverse_iterator<typename Segments::iterator> to_segments_rend);
 
+  // Reads a pre-Ζήνων downsampling message and return the downsampling
+  // parameters and the start of the dense timeline.  The latter will have to be
+  // converted to a number of points based on the deserialized timeline.
+  static void ReadFromPreΖήνωνMessage(
+      serialization::DiscreteTrajectory::Downsampling const& message,
+      DownsamplingParameters& downsampling_parameters,
+      Instant& start_of_dense_timeline);
+
+  // Reads a set of pre-Ζήνων children.  Checks that there is only one child,
+  // and that it is at the end of the preceding segment.  Append a segment to
+  // the trajectory and returns an iterator to that segment.
+  static SegmentIterator ReadFromPreΖήνωνMessage(
+      serialization::DiscreteTrajectory::Brood const& message,
+      std::vector<SegmentIterator*> const& tracked,
+      value_type const& fork_point,
+      DiscreteTrajectory2& trajectory);
+
+  // Reads a pre-Ζήνων trajectory, updating the tracked segments as needed.  If
+  // this is not the root of the trajectory, fork_point is set.
+  static void ReadFromPreΖήνωνMessage(
+      serialization::DiscreteTrajectory const& message,
+      std::vector<SegmentIterator*> const& tracked,
+      std::optional<value_type> const& fork_point,
+      DiscreteTrajectory2& trajectory);
+
   // We need a level of indirection here to make sure that the pointer to
   // Segments in the DiscreteTrajectorySegmentIterator remain valid when the
   // DiscreteTrajectory moves.  This field is never null and never empty.