Skip to content

Commit 189e189

Browse files
pleroypleroy
authored
Merge pull request #3137 from pleroy/Headers
Headers for the new-style DiscreteTrajectory
2 parents fd669b1 + 3a27c66 commit 189e189

8 files changed

+370
-0
lines changed

‎physics/discrete_trajectory2.hpp

+114
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,114 @@
1+
#pragma once
2+
3+
#include <list>
4+
#include <memory>
5+
#include <vector>
6+
7+
#include "absl/container/btree_map.h"
8+
#include "base/not_null.hpp"
9+
#include "geometry/named_quantities.hpp"
10+
#include "physics/degrees_of_freedom.hpp"
11+
#include "physics/discrete_trajectory_iterator.hpp"
12+
#include "physics/discrete_trajectory_segment_iterator.hpp"
13+
#include "physics/discrete_trajectory_segment_range.hpp"
14+
#include "physics/discrete_trajectory_types.hpp"
15+
#include "physics/trajectory.hpp"
16+
#include "serialization/physics.pb.h"
17+
18+
namespace principia {
19+
namespace physics {
20+
21+
template<typename Frame>
22+
class DiscreteTrajectorySegment;
23+
24+
namespace internal_discrete_trajectory {
25+
26+
using base::not_null;
27+
using geometry::Instant;
28+
using geometry::Position;
29+
using geometry::Velocity;
30+
using physics::DegreesOfFreedom;
31+
32+
template<typename Frame>
33+
class DiscreteTrajectory2 : public Trajectory<Frame> {
34+
public:
35+
using iterator = DiscreteTrajectoryIterator<Frame>;
36+
using reverse_iterator = std::reverse_iterator<iterator>;
37+
using SegmentIterator = DiscreteTrajectorySegmentIterator<Frame>;
38+
using ReverseSegmentIterator = std::reverse_iterator<SegmentIterator>;
39+
using SegmentRange = DiscreteTrajectorySegmentRange<SegmentIterator>;
40+
using ReverseSegmentRange =
41+
DiscreteTrajectorySegmentRange<ReverseSegmentIterator>;
42+
43+
DiscreteTrajectory2() = default;
44+
45+
// Moveable.
46+
DiscreteTrajectory2(DiscreteTrajectory2&&) = default;
47+
DiscreteTrajectory2& operator=(DiscreteTrajectory2&&) = default;
48+
DiscreteTrajectory2(const DiscreteTrajectory2&) = delete;
49+
DiscreteTrajectory2& operator=(const DiscreteTrajectory2&) = delete;
50+
51+
iterator begin() const;
52+
iterator end() const;
53+
54+
reverse_iterator rbegin() const;
55+
reverse_iterator rend() const;
56+
57+
iterator find(Instant const& t) const;
58+
59+
iterator lower_bound(Instant const& t) const;
60+
iterator upper_bound(Instant const& t) const;
61+
62+
SegmentRange segments() const;
63+
// TODO(phl): In C++20 this should be a reverse_view on segments.
64+
ReverseSegmentRange rsegments() const;
65+
66+
SegmentIterator NewSegment();
67+
68+
DiscreteTrajectory DetachSegments(iterator begin);
69+
SegmentIterator AttachSegments(DiscreteTrajectory&& trajectory);
70+
void DeleteSegments(iterator begin);
71+
72+
void ForgetAfter(Instant const& t);
73+
void ForgetAfter(iterator begin);
74+
75+
void ForgetBefore(Instant const& t);
76+
void ForgetBefore(iterator end);
77+
78+
void Append(Instant const& t,
79+
DegreesOfFreedom<Frame> const& degrees_of_freedom);
80+
81+
Position<Frame> EvaluatePosition(Instant const& time) const override;
82+
Velocity<Frame> EvaluateVelocity(Instant const& time) const override;
83+
DegreesOfFreedom<Frame> EvaluateDegreesOfFreedom(
84+
Instant const& time) const override;
85+
86+
void WriteToMessage(
87+
not_null<serialization::DiscreteTrajectory*> message,
88+
std::vector<SegmentIterator> const& tracked,
89+
std::vector<iterator> const& exact) const;
90+
void WriteToMessage(
91+
not_null<serialization::DiscreteTrajectory*> message,
92+
iterator begin, iterator end,
93+
std::vector<SegmentIterator> const& tracked,
94+
std::vector<iterator> const& exact) const;
95+
96+
template<typename F = Frame,
97+
typename = std::enable_if_t<base::is_serializable_v<F>>>
98+
static not_null<std::unique_ptr<DiscreteTrajectory>> ReadFromMessage(
99+
serialization::DiscreteTrajectory const& message,
100+
std::vector<DiscreteTrajectory<Frame>**> const& tracked);
101+
102+
private:
103+
using Segments = internal_discrete_trajectory_types::Segments<Frame>;
104+
105+
Segments segments_;
106+
};
107+
108+
} // namespace internal_discrete_trajectory
109+
110+
template<typename Frame>
111+
using DiscreteTrajectory2 = internal_discrete_trajectory::DiscreteTrajectory2;
112+
113+
} // namespace physics
114+
} // namespace principia

‎physics/discrete_trajectory_iterator.hpp

+47
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
#pragma once
2+
3+
#include "absl/container/btree_map.h"
4+
#include "geometry/named_quantities.hpp"
5+
#include "physics/degrees_of_freedom.hpp"
6+
#include "physics/discrete_trajectory_segment_iterator.hpp"
7+
#include "physics/discrete_trajectory_types.hpp"
8+
9+
namespace principia {
10+
namespace physics {
11+
12+
template<typename Frame>
13+
class DiscreteTrajectory;
14+
15+
namespace internal_discrete_trajectory_iterator {
16+
17+
using geometry::Instant;
18+
using physics::DegreesOfFreedom;
19+
20+
template<typename Frame>
21+
class DiscreteTrajectoryIterator {
22+
public:
23+
DiscreteTrajectoryIterator() = default;
24+
25+
DiscreteTrajectoryIterator& operator++();
26+
DiscreteTrajectoryIterator& operator--();
27+
DiscreteTrajectoryIterator operator++(int);
28+
DiscreteTrajectoryIterator operator--(int);
29+
30+
typename DiscreteTrajectory<Frame>::value_type const& operator*() const;
31+
typename DiscreteTrajectory<Frame>::value_type const* operator->() const;
32+
33+
private:
34+
using Timeline = internal_discrete_trajectory_types::Timeline<Frame>;
35+
36+
DiscreteTrajectorySegmentIterator segment_;
37+
Timeline::const_iterator point_;
38+
};
39+
40+
} // namespace internal_discrete_trajectory_iterator
41+
42+
template<typename Frame>
43+
using DiscreteTrajectoryIterator =
44+
internal_discrete_trajectory_iterator::DiscreteTrajectoryIterator;
45+
46+
} // namespace physics
47+
} // namespace principia

‎physics/discrete_trajectory_segment.hpp

+66
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
#pragma once
2+
3+
#include "absl/container/btree_map.h"
4+
#include "absl/container/btree_set.h"
5+
#include "geometry/named_quantities.hpp"
6+
#include "physics/degrees_of_freedom.hpp"
7+
#include "physics/discrete_trajectory_iterator.hpp"
8+
#include "physics/discrete_trajectory_segment_iterator.hpp"
9+
#include "physics/discrete_trajectory_types.hpp"
10+
11+
namespace principia {
12+
namespace physics {
13+
namespace internal_discrete_trajectory_segment {
14+
15+
using geometry::Instant;
16+
using physics::DegreesOfFreedom;
17+
18+
template<typename Frame>
19+
class DiscreteTrajectorySegment {
20+
public:
21+
DiscreteTrajectorySegment() = default;
22+
23+
// Moveable.
24+
DiscreteTrajectorySegment(DiscreteTrajectorySegment&&) = default;
25+
DiscreteTrajectorySegment& operator=(DiscreteTrajectorySegment&&) = default;
26+
DiscreteTrajectorySegment(const DiscreteTrajectorySegment&) = delete;
27+
DiscreteTrajectorySegment& operator=(const DiscreteTrajectorySegment&) =
28+
delete;
29+
30+
DiscreteTrajectoryIterator<Frame> begin() const;
31+
DiscreteTrajectoryIterator<Frame> end() const;
32+
33+
DiscreteTrajectoryIterator<Frame> rbegin() const;
34+
DiscreteTrajectoryIterator<Frame> rend() const;
35+
36+
DiscreteTrajectoryIterator<Frame> find(Instant const& t) const;
37+
38+
DiscreteTrajectoryIterator<Frame> lower_bound(Instant const& t) const;
39+
DiscreteTrajectoryIterator<Frame> upper_bound(Instant const& t) const;
40+
41+
private:
42+
using Timeline = internal_discrete_trajectory_types::Timeline<Frame>;
43+
44+
void Append(Instant const& t,
45+
DegreesOfFreedom<Frame> const& degrees_of_freedom);
46+
47+
void ForgetAfter(Instant const& t);
48+
void ForgetAfter(Timeline::const_iterator begin);
49+
50+
void ForgetBefore(Instant const& t);
51+
void ForgetBefore(Timeline::const_iterator end);
52+
53+
DiscreteTrajectorySegmentIterator<Frame> that_;
54+
55+
Timeline timeline_;
56+
absl::btree_set<Instant> dense_points_;
57+
};
58+
59+
} // namespace internal_discrete_trajectory_segment
60+
61+
template<typename Frame>
62+
using DiscreteTrajectorySegment =
63+
internal_discrete_trajectory_segment::DiscreteTrajectorySegment;
64+
65+
} // namespace physics
66+
} // namespace principia

‎physics/discrete_trajectory_segment_iterator.hpp

+49
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
#pragma once
2+
3+
#include <list>
4+
#include <memory>
5+
6+
#include "absl/container/btree_map.h"
7+
#include "geometry/named_quantities.hpp"
8+
#include "physics/degrees_of_freedom.hpp"
9+
#include "physics/discrete_trajectory_types.hpp"
10+
11+
namespace principia {
12+
namespace physics {
13+
14+
template<typename Frame>
15+
class DiscreteTrajectorySegment;
16+
17+
namespace internal_discrete_trajectory_segment_iterator {
18+
19+
using geometry::Instant;
20+
using physics::DegreesOfFreedom;
21+
22+
template<typename Frame>
23+
class DiscreteTrajectorySegmentIterator {
24+
public:
25+
DiscreteTrajectorySegmentIterator() = default;
26+
27+
DiscreteTrajectorySegmentIterator& operator++();
28+
DiscreteTrajectorySegmentIterator& operator--();
29+
DiscreteTrajectorySegmentIterator operator++(int);
30+
DiscreteTrajectorySegmentIterator operator--(int);
31+
32+
DiscreteTrajectorySegment<Frame> const& operator*() const;
33+
DiscreteTrajectorySegment<Frame> const* operator->() const;
34+
35+
private:
36+
using Segments = internal_discrete_trajectory_types::Segments<Frame>;
37+
38+
Segments::const_iterator segment_;
39+
};
40+
41+
} // namespace internal_discrete_trajectory_segment_iterator
42+
43+
template<typename Frame>
44+
using DiscreteTrajectorySegmentIterator =
45+
internal_discrete_trajectory_segment_iterator::
46+
DiscreteTrajectorySegmentIterator;
47+
48+
} // namespace physics
49+
} // namespace principia

‎physics/discrete_trajectory_segment_range.hpp

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
#pragma once
2+
3+
#include <list>
4+
#include <memory>
5+
6+
#include "absl/container/btree_map.h"
7+
#include "geometry/named_quantities.hpp"
8+
#include "physics/degrees_of_freedom.hpp"
9+
10+
namespace principia {
11+
namespace physics {
12+
namespace internal_discrete_trajectory_segment_range {
13+
14+
using geometry::Instant;
15+
using physics::DegreesOfFreedom;
16+
17+
template<typename Iterator>
18+
class DiscreteTrajectorySegmentRange {
19+
public:
20+
DiscreteTrajectorySegmentRange() = default;
21+
22+
Iterator begin() const;
23+
Iterator end() const;
24+
25+
private:
26+
Iterator begin_;
27+
Iterator end_;
28+
};
29+
30+
} // namespace internal_discrete_trajectory_segment_range
31+
32+
template<typename Iterator>
33+
using DiscreteTrajectorySegmentRange =
34+
internal_discrete_trajectory_segment_range::DiscreteTrajectorySegmentRange;
35+
36+
} // namespace physics
37+
} // namespace principia

‎physics/discrete_trajectory_types.hpp

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
#pragma once
2+
3+
#include <list>
4+
#include <memory>
5+
6+
#include "absl/container/btree_map.h"
7+
#include "geometry/named_quantities.hpp"
8+
#include "physics/degrees_of_freedom.hpp"
9+
10+
// An internal header to avoid replicating data structures in multiple places.
11+
// Doesn't export anything outside of its internal namespace.
12+
namespace principia {
13+
namespace physics {
14+
15+
template<typename Frame>
16+
class DiscreteTrajectorySegment;
17+
18+
namespace internal_discrete_trajectory_types {
19+
20+
using geometry::Instant;
21+
using physics::DegreesOfFreedom;
22+
23+
// The use of an unique_ptr here makes it possible to only depend on a forward
24+
// declaration of DiscreteTrajectorySegment.
25+
template<typename Frame>
26+
using Segments = std::list<std::unique_ptr<DiscreteTrajectorySegment<Frame>>>;
27+
28+
template<typename Frame>
29+
using Timeline = absl::btree_map<Instant, DegreesOfFreedom<Frame>>;
30+
31+
} // namespace internal_discrete_trajectory_types
32+
} // namespace physics
33+
} // namespace principia

‎physics/physics.vcxproj

+6
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,12 @@
3131
<ClInclude Include="body_surface_frame_field_body.hpp" />
3232
<ClInclude Include="checkpointer.hpp" />
3333
<ClInclude Include="checkpointer_body.hpp" />
34+
<ClInclude Include="discrete_trajectory2.hpp" />
35+
<ClInclude Include="discrete_trajectory_iterator.hpp" />
36+
<ClInclude Include="discrete_trajectory_segment.hpp" />
37+
<ClInclude Include="discrete_trajectory_segment_iterator.hpp" />
38+
<ClInclude Include="discrete_trajectory_segment_range.hpp" />
39+
<ClInclude Include="discrete_trajectory_types.hpp" />
3440
<ClInclude Include="mechanical_system.hpp" />
3541
<ClInclude Include="mechanical_system_body.hpp" />
3642
<ClInclude Include="continuous_trajectory_body.hpp" />

‎physics/physics.vcxproj.filters

+18
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,24 @@
191191
<ClInclude Include="mechanical_system_body.hpp">
192192
<Filter>Source Files</Filter>
193193
</ClInclude>
194+
<ClInclude Include="discrete_trajectory_segment.hpp">
195+
<Filter>Header Files</Filter>
196+
</ClInclude>
197+
<ClInclude Include="discrete_trajectory_iterator.hpp">
198+
<Filter>Header Files</Filter>
199+
</ClInclude>
200+
<ClInclude Include="discrete_trajectory_segment_iterator.hpp">
201+
<Filter>Header Files</Filter>
202+
</ClInclude>
203+
<ClInclude Include="discrete_trajectory2.hpp">
204+
<Filter>Header Files</Filter>
205+
</ClInclude>
206+
<ClInclude Include="discrete_trajectory_types.hpp">
207+
<Filter>Header Files</Filter>
208+
</ClInclude>
209+
<ClInclude Include="discrete_trajectory_segment_range.hpp">
210+
<Filter>Header Files</Filter>
211+
</ClInclude>
194212
</ItemGroup>
195213
<ItemGroup>
196214
<ClCompile Include="degrees_of_freedom_test.cpp">

0 commit comments

Comments
 (0)