Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: mockingbirdnest/Principia
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: 9590119ed293
Choose a base ref
...
head repository: mockingbirdnest/Principia
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: 91dd45b22efd
Choose a head ref
  • 6 commits
  • 8 files changed
  • 1 contributor

Commits on Oct 10, 2021

  1. Copy the full SHA
    123e71e View commit details
  2. Copy the full SHA
    0ecb6b1 View commit details
  3. Readying for review.

    pleroy committed Oct 10, 2021
    Copy the full SHA
    1128a00 View commit details
  4. After egg's review.

    pleroy committed Oct 10, 2021
    Copy the full SHA
    562c26a View commit details
  5. Compilation errors.

    pleroy committed Oct 10, 2021
    Copy the full SHA
    4ce2814 View commit details
  6. Merge pull request #3147 from pleroy/Factories

    Factories for new-style discrete trajectories
    pleroy authored Oct 10, 2021
    Copy the full SHA
    91dd45b View commit details
4 changes: 2 additions & 2 deletions physics/discrete_trajectory_iterator.hpp
Original file line number Diff line number Diff line change
@@ -73,8 +73,8 @@ class DiscreteTrajectoryIterator {
std::optional<Instant> previous_time_;

template<typename F>
friend class DiscreteTrajectorySegment;
friend class DiscreteTrajectoryIteratorTest;
friend class physics::DiscreteTrajectorySegment;
friend class physics::DiscreteTrajectoryIteratorTest;
};

} // namespace internal_discrete_trajectory_iterator
17 changes: 14 additions & 3 deletions physics/discrete_trajectory_segment.hpp
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
#pragma once
#pragma once

#include <cstdint>
#include <iterator>
@@ -13,6 +13,13 @@
#include "physics/discrete_trajectory_types.hpp"

namespace principia {

namespace testing_utilities {
FORWARD_DECLARE_FROM(discrete_trajectory_factories,
TEMPLATE(typename Frame) class,
DiscreteTrajectoryFactoriesFriend);
} // namespace testing_utilities

namespace physics {

class DiscreteTrajectoryIteratorTest;
@@ -88,8 +95,12 @@ class DiscreteTrajectorySegment {
template<typename F>
friend class internal_discrete_trajectory_iterator::
DiscreteTrajectoryIterator;
friend class DiscreteTrajectoryIteratorTest;
friend class DiscreteTrajectorySegmentTest;

// For testing.
friend class physics::DiscreteTrajectoryIteratorTest;
friend class physics::DiscreteTrajectorySegmentTest;
template<typename F>
friend class testing_utilities::DiscreteTrajectoryFactoriesFriend;
};

} // namespace internal_discrete_trajectory_segment
19 changes: 15 additions & 4 deletions physics/discrete_trajectory_segment_iterator.hpp
Original file line number Diff line number Diff line change
@@ -6,6 +6,13 @@
#include "physics/discrete_trajectory_types.hpp"

namespace principia {

namespace testing_utilities {
FORWARD_DECLARE_FROM(discrete_trajectory_factories,
TEMPLATE(typename Frame) class,
DiscreteTrajectoryFactoriesFriend);
} // namespace testing_utilities

namespace physics {

FORWARD_DECLARE_FROM(discrete_trajectory_iterator,
@@ -58,10 +65,14 @@ class DiscreteTrajectorySegmentIterator {
typename Segments::const_iterator iterator_;

template<typename F>
friend class DiscreteTrajectoryIterator;
friend class DiscreteTrajectoryIteratorTest;
friend class DiscreteTrajectorySegmentIteratorTest;
friend class DiscreteTrajectorySegmentTest;
friend class physics::DiscreteTrajectoryIterator;

// For testing.
friend class physics::DiscreteTrajectoryIteratorTest;
friend class physics::DiscreteTrajectorySegmentIteratorTest;
friend class physics::DiscreteTrajectorySegmentTest;
template<typename F>
friend class testing_utilities::DiscreteTrajectoryFactoriesFriend;
};

} // namespace internal_discrete_trajectory_segment_iterator
96 changes: 96 additions & 0 deletions testing_utilities/discrete_trajectory_factories.hpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,96 @@
#pragma once

#include <memory>

#include "absl/status/status.h"
#include "base/not_null.hpp"
#include "geometry/named_quantities.hpp"
#include "physics/degrees_of_freedom.hpp"
#include "physics/discrete_trajectory_segment.hpp"
#include "physics/discrete_trajectory_types.hpp"
#include "quantities/named_quantities.hpp"
#include "quantities/quantities.hpp"

namespace principia {
namespace testing_utilities {
namespace internal_discrete_trajectory_factories {

using base::not_null;
using geometry::Instant;
using geometry::Velocity;
using physics::DegreesOfFreedom;
using physics::DiscreteTrajectorySegment;
using physics::internal_discrete_trajectory_types::Segments;
using quantities::AngularFrequency;
using quantities::Length;
using quantities::Time;

// A helper class to avoid having to declare friendship for all the individual
// functions in this file.
template<typename Frame>
class DiscreteTrajectoryFactoriesFriend {
public:
static absl::Status Append(Instant const& t,
DegreesOfFreedom<Frame> const& degrees_of_freedom,
DiscreteTrajectorySegment<Frame>& segment);

static DiscreteTrajectorySegment<Frame>
MakeDiscreteTrajectorySegment(
Segments<Frame> const& segments,
typename Segments<Frame>::const_iterator iterator);
};

// All the functions below return a list of a single segment.
// TODO(phl): Revise this API as needed once we have all the pieces for the new-
// style discrete trajectories.
// TODO(phl): Must return unique_ptr because copying Segments is a bad idea due
// to the pointers within iterators.

// A linear trajectory with constant velocity, going through
// |degrees_of_freedom.position()| at t = 0. The first point is at time |t1|,
// the last point at a time < |t2|.
template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewLinearTrajectorySegment(DegreesOfFreedom<Frame> const& degrees_of_freedom,
Time const& Δt,
Instant const& t1,
Instant const& t2);
// Same as above, going through the origin at t = 0.
template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewLinearTrajectorySegment(Velocity<Frame> const& v,
Time const& Δt,
Instant const& t1,
Instant const& t2);

// A circular trajectory in the plane XY, centred at the origin. The first
// point is at time |t1|, the last point at a time < |t2|.
template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewCircularTrajectorySegment(AngularFrequency const& ω,
Length const& r,
Time const& Δt,
Instant const& t1,
Instant const& t2);
template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewCircularTrajectorySegment(Time const& period,
Length const& r,
Time const& Δt,
Instant const& t1,
Instant const& t2);

template<typename Frame>
void AppendTrajectorySegments(Segments<Frame> const& from,
Segments<Frame>& to);

} // namespace internal_discrete_trajectory_factories

using internal_discrete_trajectory_factories::AppendTrajectorySegments;
using internal_discrete_trajectory_factories::NewCircularTrajectorySegment;
using internal_discrete_trajectory_factories::NewLinearTrajectorySegment;

} // namespace testing_utilities
} // namespace principia

#include "testing_utilities/discrete_trajectory_factories_body.hpp"
129 changes: 129 additions & 0 deletions testing_utilities/discrete_trajectory_factories_body.hpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,129 @@
#pragma once

#include "testing_utilities/discrete_trajectory_factories.hpp"

#include "physics/degrees_of_freedom.hpp"
#include "physics/discrete_trajectory_segment.hpp"
#include "physics/discrete_trajectory_segment_iterator.hpp"
#include "quantities/elementary_functions.hpp"
#include "quantities/si.hpp"

namespace principia {
namespace testing_utilities {
namespace internal_discrete_trajectory_factories {

using base::check_not_null;
using base::make_not_null_unique;
using geometry::Displacement;
using geometry::Velocity;
using physics::DegreesOfFreedom;
using physics::DiscreteTrajectorySegment;
using physics::DiscreteTrajectorySegmentIterator;
using quantities::Cos;
using quantities::Sin;
using quantities::Speed;
using quantities::si::Radian;

template<typename Frame>
absl::Status DiscreteTrajectoryFactoriesFriend<Frame>::Append(
Instant const& t,
DegreesOfFreedom<Frame> const& degrees_of_freedom,
DiscreteTrajectorySegment<Frame>& segment) {
return segment.Append(t, degrees_of_freedom);
}

template<typename Frame>
DiscreteTrajectorySegment<Frame>
DiscreteTrajectoryFactoriesFriend<Frame>::MakeDiscreteTrajectorySegment(
Segments<Frame> const& segments,
typename Segments<Frame>::const_iterator const iterator) {
return DiscreteTrajectorySegment<Frame>(
DiscreteTrajectorySegmentIterator<Frame>(check_not_null(&segments),
iterator));
}

template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewLinearTrajectorySegment(DegreesOfFreedom<Frame> const& degrees_of_freedom,
Time const& Δt,
Instant const& t1,
Instant const& t2) {
static Instant const t0;
auto segments = std::make_unique<Segments<Frame>>(1);
auto const it = segments->begin();
*it = std::make_unique<DiscreteTrajectorySegment<Frame>>(
DiscreteTrajectoryFactoriesFriend<Frame>::MakeDiscreteTrajectorySegment(
*segments, it));
auto& segment = **segments->cbegin();
for (auto t = t1; t < t2; t += Δt) {
auto const velocity = degrees_of_freedom.velocity();
auto const position = degrees_of_freedom.position() + velocity * (t - t0);
DiscreteTrajectoryFactoriesFriend<Frame>::Append(
t, DegreesOfFreedom<Frame>(position, velocity), segment);
}
return segments;
}

template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewLinearTrajectorySegment(Velocity<Frame> const& v,
Time const& Δt,
Instant const& t1,
Instant const& t2) {
return NewLinearTrajectory(
DegreesOfFreedom<Frame>(Frame::origin, v), Δt, t1, t2);
}

template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewCircularTrajectorySegment(AngularFrequency const& ω,
Length const& r,
Time const& Δt,
Instant const& t1,
Instant const& t2) {
static Instant const t0;
auto segments = std::make_unique<Segments<Frame>>(1);
auto const it = segments->begin();
*it = std::make_unique<DiscreteTrajectorySegment<Frame>>(
DiscreteTrajectoryFactoriesFriend<Frame>::MakeDiscreteTrajectorySegment(
*segments, it));
auto& segment = **segments->cbegin();
Speed const v = ω * r / Radian;
for (auto t = t1; t < t2; t += Δt) {
DegreesOfFreedom<Frame> const dof = {
Frame::origin + Displacement<Frame>{{r * Cos(ω * (t - t0)),
r * Sin(ω * (t - t0)),
Length{}}},
Velocity<Frame>{{-v * Sin(ω * (t - t0)),
v * Cos(ω * (t - t0)),
Speed{}}}};
DiscreteTrajectoryFactoriesFriend<Frame>::Append(t, dof, segment);
}
return segments;
}

template<typename Frame>
not_null<std::unique_ptr<Segments<Frame>>>
NewCircularTrajectorySegment(Time const& period,
Length const& r,
Time const& Δt,
Instant const& t1,
Instant const& t2) {
return NewCircularTrajectory<Frame>(/*ω=*/2 * π * Radian / period,
r,
Δt,
t1,
t2);
}

template<typename Frame>
void AppendTrajectorySegments(Segments<Frame> const& from,
Segments<Frame>& to) {
for (auto const& [t, dof] : *from.front()) {
DiscreteTrajectoryFactoriesFriend<Frame>::Append(t, dof, to.rbegin());
}
}

} // namespace internal_discrete_trajectory_factories
} // namespace testing_utilities
} // namespace principia
Loading