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: 9e8d0ac8de02
Choose a base ref
...
head repository: mockingbirdnest/Principia
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: 4b121cefe444
Choose a head ref
  • 4 commits
  • 6 files changed
  • 2 contributors

Commits on Dec 30, 2019

  1. Copy the full SHA
    f44ea47 View commit details
  2. Copy the full SHA
    0dc1d6d View commit details

Commits on Dec 31, 2019

  1. Fix the test.

    pleroy committed Dec 31, 2019
    Copy the full SHA
    1507fd1 View commit details
  2. Merge pull request #2423 from pleroy/ApparentRigidMotion2

    Change the PileUp data structures to hold rigid motions
    pleroy authored Dec 31, 2019
    Copy the full SHA
    4b121ce View commit details
Showing with 141 additions and 80 deletions.
  1. +67 −47 ksp_plugin/pile_up.cpp
  2. +2 −2 ksp_plugin/pile_up.hpp
  3. +37 −31 ksp_plugin_test/pile_up_test.cpp
  4. +9 −0 physics/rigid_motion.hpp
  5. +22 −0 physics/rigid_motion_body.hpp
  6. +4 −0 serialization/ksp_plugin.proto
114 changes: 67 additions & 47 deletions ksp_plugin/pile_up.cpp
Original file line number Diff line number Diff line change
@@ -66,9 +66,9 @@ PileUp::PileUp(
AngularVelocity<Barycentric>{},
barycentre.velocity()};
for (not_null<Part*> const part : parts_) {
actual_part_degrees_of_freedom_.emplace(
actual_part_rigid_motion_.emplace(
part,
barycentric_to_pile_up(part->degrees_of_freedom()));
barycentric_to_pile_up * part->rigid_motion());
}
psychohistory_ = history_->NewForkAtLast();
}
@@ -87,13 +87,10 @@ std::list<not_null<Part*>> const& PileUp::parts() const {
void PileUp::SetPartApparentRigidMotion(
not_null<Part*> const part,
RigidMotion<RigidPart, ApparentBubble> const& rigid_motion) {
// TODO(phl): Propagate the rigid motion to the internal data structures.
auto const degrees_of_freedom = rigid_motion({RigidPart::origin,
RigidPart::unmoving});
bool const inserted = apparent_part_degrees_of_freedom_.emplace(
part, degrees_of_freedom).second;
auto const [_, inserted] =
apparent_part_rigid_motion_.emplace(part, rigid_motion);
CHECK(inserted) << "Duplicate part " << part->ShortDebugString() << " at "
<< degrees_of_freedom;
<< rigid_motion;
}

Status PileUp::DeformAndAdvanceTime(Instant const& t) {
@@ -117,18 +114,17 @@ void PileUp::WriteToMessage(not_null<serialization::PileUp*> message) const {
}
history_->WriteToMessage(message->mutable_history(),
/*forks=*/{psychohistory_});
for (auto const& pair : actual_part_degrees_of_freedom_) {
for (auto const& pair : actual_part_rigid_motion_) {
auto const part = pair.first;
auto const& degrees_of_freedom = pair.second;
degrees_of_freedom.WriteToMessage(&(
(*message->mutable_actual_part_degrees_of_freedom())[part->part_id()]));
auto const& rigid_motion = pair.second;
rigid_motion.WriteToMessage(&(
(*message->mutable_actual_part_rigid_motion())[part->part_id()]));
}
for (auto const& pair : apparent_part_degrees_of_freedom_) {
for (auto const& pair : apparent_part_rigid_motion_) {
auto const part = pair.first;
auto const& degrees_of_freedom = pair.second;
degrees_of_freedom.WriteToMessage(&(
(*message
->mutable_apparent_part_degrees_of_freedom())[part->part_id()]));
auto const& rigid_motion = pair.second;
rigid_motion.WriteToMessage(&(
(*message->mutable_apparent_part_rigid_motion())[part->part_id()]));
}
adaptive_step_parameters_.WriteToMessage(
message->mutable_adaptive_step_parameters());
@@ -149,6 +145,8 @@ not_null<std::unique_ptr<PileUp>> PileUp::ReadFromMessage(
bool const is_pre_cartan = !message.has_adaptive_step_parameters() ||
!message.has_fixed_step_parameters();
bool const is_pre_cesàro = message.history().children().empty();
bool const is_pre_frege = message.actual_part_degrees_of_freedom_size() > 0 &&
message.apparent_part_degrees_of_freedom_size() > 0;
std::unique_ptr<PileUp> pile_up;
if (is_pre_cesàro) {
if (is_pre_cartan) {
@@ -206,19 +204,40 @@ not_null<std::unique_ptr<PileUp>> PileUp::ReadFromMessage(
std::move(deletion_callback)));
}

for (auto const& pair : message.actual_part_degrees_of_freedom()) {
std::uint32_t const part_id = pair.first;
serialization::Pair const& degrees_of_freedom = pair.second;
pile_up->actual_part_degrees_of_freedom_.emplace(
if (is_pre_frege) {
for (auto const& pair : message.actual_part_degrees_of_freedom()) {
std::uint32_t const part_id = pair.first;
serialization::Pair const& degrees_of_freedom = pair.second;
pile_up->actual_part_rigid_motion_.emplace(
part_id_to_part(part_id),
RigidMotion<RigidPart, RigidPileUp>::MakeNonRotatingMotion(
DegreesOfFreedom<RigidPileUp>::ReadFromMessage(
degrees_of_freedom)));
}
for (auto const& pair : message.apparent_part_degrees_of_freedom()) {
std::uint32_t const part_id = pair.first;
serialization::Pair const& degrees_of_freedom = pair.second;
pile_up->apparent_part_rigid_motion_.emplace(
part_id_to_part(part_id),
RigidMotion<RigidPart, ApparentBubble>::MakeNonRotatingMotion(
DegreesOfFreedom<ApparentBubble>::ReadFromMessage(
degrees_of_freedom)));
}
} else {
for (auto const& pair : message.actual_part_rigid_motion()) {
std::uint32_t const part_id = pair.first;
serialization::RigidMotion const& rigid_motion = pair.second;
pile_up->actual_part_rigid_motion_.emplace(
part_id_to_part(part_id),
DegreesOfFreedom<RigidPileUp>::ReadFromMessage(degrees_of_freedom));
}
for (auto const& pair : message.apparent_part_degrees_of_freedom()) {
std::uint32_t const part_id = pair.first;
serialization::Pair const& degrees_of_freedom = pair.second;
pile_up->apparent_part_degrees_of_freedom_.emplace(
RigidMotion<RigidPart, RigidPileUp>::ReadFromMessage(rigid_motion));
}
for (auto const& pair : message.apparent_part_rigid_motion()) {
std::uint32_t const part_id = pair.first;
serialization::RigidMotion const& rigid_motion = pair.second;
pile_up->apparent_part_rigid_motion_.emplace(
part_id_to_part(part_id),
DegreesOfFreedom<ApparentBubble>::ReadFromMessage(degrees_of_freedom));
RigidMotion<RigidPart, ApparentBubble>::ReadFromMessage(rigid_motion));
}
}
pile_up->RecomputeFromParts();
return check_not_null(std::move(pile_up));
@@ -243,24 +262,26 @@ PileUp::PileUp(
deletion_callback_(std::move(deletion_callback)) {}

void PileUp::DeformPileUpIfNeeded() {
if (apparent_part_degrees_of_freedom_.empty()) {
if (apparent_part_rigid_motion_.empty()) {
return;
}
// A consistency check that |SetPartApparentDegreesOfFreedom| was called for
// all the parts.
// TODO(egg): I'd like to log some useful information on check failure, but I
// need a clean way of getting the debug strings of all parts (rather than
// giant self-evaluating lambdas).
CHECK_EQ(parts_.size(), apparent_part_degrees_of_freedom_.size());
CHECK_EQ(parts_.size(), apparent_part_rigid_motion_.size());
for (not_null<Part*> const part : parts_) {
CHECK(Contains(apparent_part_degrees_of_freedom_, part));
CHECK(Contains(apparent_part_rigid_motion_, part));
}

// Compute the apparent centre of mass of the parts.
BarycentreCalculator<DegreesOfFreedom<ApparentBubble>, Mass> calculator;
for (auto const& pair : apparent_part_degrees_of_freedom_) {
for (auto const& pair : apparent_part_rigid_motion_) {
auto const part = pair.first;
auto const& apparent_part_degrees_of_freedom = pair.second;
auto const& apparent_part_rigid_motion = pair.second;
DegreesOfFreedom<ApparentBubble> const apparent_part_degrees_of_freedom =
apparent_part_rigid_motion({RigidPart::origin, RigidPart::unmoving});
calculator.Add(apparent_part_degrees_of_freedom,
part->inertia_tensor().mass());
}
@@ -280,15 +301,15 @@ void PileUp::DeformPileUpIfNeeded() {
apparent_centre_of_mass.velocity());

// Now update the positions of the parts in the pile-up frame.
actual_part_degrees_of_freedom_.clear();
for (auto const& pair : apparent_part_degrees_of_freedom_) {
actual_part_rigid_motion_.clear();
for (auto const& pair : apparent_part_rigid_motion_) {
auto const part = pair.first;
auto const& apparent_part_degrees_of_freedom = pair.second;
actual_part_degrees_of_freedom_.emplace(
auto const& apparent_part_rigid_motion = pair.second;
actual_part_rigid_motion_.emplace(
part,
apparent_bubble_to_pile_up_motion(apparent_part_degrees_of_freedom));
apparent_bubble_to_pile_up_motion * apparent_part_rigid_motion);
}
apparent_part_degrees_of_freedom_.clear();
apparent_part_rigid_motion_.clear();
}

Status PileUp::AdvanceTime(Instant const& t) {
@@ -381,12 +402,9 @@ void PileUp::NudgeParts() const {
actual_centre_of_mass.velocity()};
auto const pile_up_to_barycentric = barycentric_to_pile_up.Inverse();
for (not_null<Part*> const part : parts_) {
DegreesOfFreedom<Barycentric> const actual_part_degrees_of_freedom =
pile_up_to_barycentric(
FindOrDie(actual_part_degrees_of_freedom_, part));
part->set_rigid_motion(
RigidMotion<RigidPart, Barycentric>::MakeNonRotatingMotion(
actual_part_degrees_of_freedom));
RigidMotion<RigidPart, Barycentric> const actual_part_rigid_motion =
pile_up_to_barycentric * FindOrDie(actual_part_rigid_motion_, part);
part->set_rigid_motion(actual_part_rigid_motion);
}
}

@@ -402,10 +420,12 @@ void PileUp::AppendToPart(DiscreteTrajectory<Barycentric>::Iterator it) const {
pile_up_dof.velocity());
auto const pile_up_to_barycentric = barycentric_to_pile_up.Inverse();
for (not_null<Part*> const part : parts_) {
DegreesOfFreedom<RigidPileUp> const actual_part_degrees_of_freedom =
FindOrDie(actual_part_rigid_motion_, part)({RigidPart::origin,
RigidPart::unmoving});
(static_cast<Part*>(part)->*append_to_part_trajectory)(
it->time,
pile_up_to_barycentric(
FindOrDie(actual_part_degrees_of_freedom_, part)));
pile_up_to_barycentric(actual_part_degrees_of_freedom));
}
}

4 changes: 2 additions & 2 deletions ksp_plugin/pile_up.hpp
Original file line number Diff line number Diff line change
@@ -185,8 +185,8 @@ class PileUp {
Ephemeris<Barycentric>::NewtonianMotionEquation>::Instance>
fixed_instance_;

PartTo<DegreesOfFreedom<RigidPileUp>> actual_part_degrees_of_freedom_;
PartTo<DegreesOfFreedom<ApparentBubble>> apparent_part_degrees_of_freedom_;
PartTo<RigidMotion<RigidPart, RigidPileUp>> actual_part_rigid_motion_;
PartTo<RigidMotion<RigidPart, ApparentBubble>> apparent_part_rigid_motion_;

// Called in the destructor.
std::function<void()> deletion_callback_;
Loading