summaryrefslogtreecommitdiff
path: root/modules/core/tests/contact_dynamics.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'modules/core/tests/contact_dynamics.cpp')
-rw-r--r--modules/core/tests/contact_dynamics.cpp272
1 files changed, 272 insertions, 0 deletions
diff --git a/modules/core/tests/contact_dynamics.cpp b/modules/core/tests/contact_dynamics.cpp
new file mode 100644
index 0000000..b6545b9
--- /dev/null
+++ b/modules/core/tests/contact_dynamics.cpp
@@ -0,0 +1,272 @@
+#include <forstio/test/suite.hpp>
+
+#include <cmath>
+#include <iostream>
+
+#include "../c++/particle/particle.hpp"
+#include "../c++/particle/integrate.hpp"
+#include "../c++/particle/contact.hpp"
+
+namespace {
+namespace sch {
+using namespace kel::lbm::sch;
+using T = Float64;
+}
+
+constexpr uint64_t D = 2u;
+
+template<uint64_t PC>
+auto make_group(double radius, double density){
+ kel::lbm::data<sch::Scalar<sch::T>> r,d;
+ r.at({}).set(radius);
+ d.at({}).set(density);
+ return kel::lbm::create_spheroid_particle_group<sch::T,D,PC>(r,d,{8u});
+}
+
+template<typename G>
+void set_state(G& g, uint64_t i, double x, double y, double vx, double vy){
+ auto& rb = g.template get<"particles">().at({i}).template get<"rigid_body">();
+ rb.template get<"position">().at({{0u}}).set(x);
+ rb.template get<"position">().at({{1u}}).set(y);
+ // Position-Verlet carries velocity implicitly in the position pair.
+ rb.template get<"position_old">().at({{0u}}).set(x - vx);
+ rb.template get<"position_old">().at({{1u}}).set(y - vy);
+}
+
+template<typename G>
+double vel_x(G& g, uint64_t i){
+ auto& rb = g.template get<"particles">().at({i}).template get<"rigid_body">();
+ return rb.template get<"position">().at({{0u}}).get()
+ - rb.template get<"position_old">().at({{0u}}).get();
+}
+
+/**
+ * One full step of the pipeline for every particle: clear, accumulate
+ * contacts, integrate.
+ */
+template<typename G>
+void step_all(G& g, uint64_t n, const kel::lbm::dem_params<sch::T>& dem){
+ using namespace kel;
+ auto& parts = g.template get<"particles">();
+ for(uint64_t i = 0u; i < n; ++i){
+ (lbm::reset_particle_accumulators<sch::T,D>)(parts.at({i}));
+ }
+ for(uint64_t i = 0u; i < n; ++i){
+ (lbm::accumulate_particle_contacts<sch::T,D>)(parts, i, dem, {1u});
+ }
+ for(uint64_t i = 0u; i < n; ++i){
+ (lbm::integrate_particle<sch::T,D>)(parts.at({i}), {}, {1u});
+ }
+}
+
+SAW_TEST("Dynamics / head-on collision reverses both bodies"){
+ using namespace kel;
+
+ auto g = make_group<2u>(2.0, 1.0);
+ // Approaching, just touching.
+ set_state(g, 0u, 0.0, 0.0, 0.05, 0.0);
+ set_state(g, 1u, 4.0, 0.0, -0.05, 0.0);
+
+ // Stiff enough to turn them around inside the window, lightly damped.
+ lbm::dem_params<sch::T> dem{2.0, 0.1, 0.0, 0.0};
+
+ bool reversed = false;
+ for(uint64_t step = 0u; step < 400u; ++step){
+ step_all(g, 2u, dem);
+ if(vel_x(g,0u) < 0.0 && vel_x(g,1u) > 0.0){
+ reversed = true;
+ break;
+ }
+ }
+
+ SAW_EXPECT(reversed, "an approaching pair must end up separating");
+}
+
+SAW_TEST("Dynamics / collision does not create energy"){
+ using namespace kel;
+
+ /**
+ * The dashpot can only remove energy. If the sign of the damping term or
+ * the velocity convention were wrong, a bounce would come back faster
+ * than it went in -- which is the classic way a DEM blows up slowly
+ * enough that you do not notice for a thousand steps.
+ */
+ auto g = make_group<2u>(2.0, 1.0);
+ const double v0 = 0.05;
+ set_state(g, 0u, 0.0, 0.0, v0, 0.0);
+ set_state(g, 1u, 4.0, 0.0, -v0, 0.0);
+
+ lbm::dem_params<sch::T> dem{2.0, 0.2, 0.0, 0.0};
+
+ double peak = 0.0;
+ for(uint64_t step = 0u; step < 600u; ++step){
+ step_all(g, 2u, dem);
+
+ auto s0 = std::abs(vel_x(g,0u));
+ auto s1 = std::abs(vel_x(g,1u));
+ if(s0 > peak){ peak = s0; }
+ if(s1 > peak){ peak = s1; }
+ }
+
+ SAW_EXPECT(peak <= v0 * 1.02,
+ std::string{"no body may exceed its incoming speed, peak was "}
+ + std::to_string(peak) + " against " + std::to_string(v0));
+}
+
+SAW_TEST("Dynamics / resting contact settles at the force balance"){
+ using namespace kel;
+
+ /**
+ * A body held against a wall by a constant body acceleration must come to
+ * rest where the spring balances the load, at an overlap of m*g/k.
+ *
+ * Note this needs confinement to mean anything: two FREE bodies pushed
+ * apart just separate and coast, so there is no equilibrium to find.
+ */
+ auto g = make_group<1u>(2.0, 1.0);
+ auto& parts = g.template get<"particles">();
+ auto& rb = parts.at({0u}).template get<"rigid_body">();
+
+ const double mass = rb.template get<"mass">().at({}).get();
+ const double k_n = 1.0;
+ const double gravity = 0.0005;
+
+ // Start just touching the low x wall, at rest.
+ set_state(g, 0u, 2.0, 16.0, 0.0, 0.0);
+
+ lbm::dem_params<sch::T> dem{k_n, 0.8, 0.0, 0.0};
+ kel::lbm::data<sch::FixedArray<sch::UInt64,D>> extent{{64u,32u}};
+
+ // Gravity pointing at the wall, as a body acceleration.
+ kel::lbm::data<sch::Vector<sch::T,D>> body_acc;
+ body_acc.at({{0u}}).set(-gravity);
+ body_acc.at({{1u}}).set(0.0);
+
+ auto x_of = [&](){
+ return rb.template get<"position">().at({{0u}}).get();
+ };
+
+ for(uint64_t step = 0u; step < 4000u; ++step){
+ (lbm::reset_particle_accumulators<sch::T,D>)(parts.at({0u}));
+ (lbm::accumulate_box_wall_contacts<sch::T,D>)(parts.at({0u}), extent, dem, {1u});
+ (lbm::integrate_particle<sch::T,D>)(parts.at({0u}), body_acc, {1u});
+ }
+
+ auto settled = x_of();
+ auto expect_overlap = mass * gravity / k_n;
+ auto got_overlap = 2.0 - settled;
+
+ SAW_EXPECT(std::isfinite(settled), "must stay finite");
+ SAW_EXPECT(std::abs(got_overlap - expect_overlap) < 0.1 * expect_overlap,
+ std::string{"expected overlap m*g/k = "} + std::to_string(expect_overlap)
+ + " got " + std::to_string(got_overlap));
+
+ // And it must actually be at rest, not still travelling.
+ auto speed = std::abs(x_of() - rb.template get<"position_old">().at({{0u}}).get());
+ SAW_EXPECT(speed < 1e-4,
+ std::string{"should have come to rest, residual speed "} + std::to_string(speed));
+}
+
+SAW_TEST("Dynamics / three body momentum is conserved"){
+ using namespace kel;
+
+ /**
+ * Two bodies cancelling is weak evidence -- a sign error can cancel
+ * pairwise and still be wrong once a particle has two neighbours at once.
+ */
+ auto g = make_group<3u>(2.0, 1.0);
+ set_state(g, 0u, 0.0, 0.0, 0.03, 0.01);
+ set_state(g, 1u, 3.5, 0.0, -0.01, 0.02);
+ set_state(g, 2u, 7.0, 0.3, 0.00, -0.02);
+
+ lbm::dem_params<sch::T> dem{5.0, 0.3, 2.0, 0.4};
+
+ auto& parts = g.template get<"particles">();
+ for(uint64_t i = 0u; i < 3u; ++i){
+ (lbm::reset_particle_accumulators<sch::T,D>)(parts.at({i}));
+ }
+ for(uint64_t i = 0u; i < 3u; ++i){
+ (lbm::accumulate_particle_contacts<sch::T,D>)(parts, i, dem, {1u});
+ }
+
+ // The middle body touches both neighbours, so this is the case that
+ // pairwise cancellation alone would not catch.
+ for(uint64_t k = 0u; k < D; ++k){
+ double sum = 0.0;
+ for(uint64_t i = 0u; i < 3u; ++i){
+ sum += parts.at({i}).template get<"rigid_body">()
+ .template get<"force">().at({{k}}).get();
+ }
+ SAW_EXPECT(std::abs(sum) < 1e-12,
+ std::string{"net force in component "} + std::to_string(k)
+ + " should vanish: " + std::to_string(sum));
+ }
+
+ // And the middle body must actually be feeling both sides.
+ auto f1 = parts.at({1u}).template get<"rigid_body">().template get<"force">().at({{0u}}).get();
+ SAW_EXPECT(std::abs(f1) > 0.0, "the middle body must be loaded from both sides");
+}
+
+SAW_TEST("Dynamics / wall stops an incoming body"){
+ using namespace kel;
+
+ auto g = make_group<1u>(2.0, 1.0);
+ // Heading into the low x wall.
+ set_state(g, 0u, 2.5, 16.0, -0.05, 0.0);
+
+ lbm::dem_params<sch::T> dem{2.0, 0.2, 0.0, 0.0};
+ kel::lbm::data<sch::FixedArray<sch::UInt64,D>> extent{{64u,32u}};
+
+ auto& parts = g.template get<"particles">();
+ double deepest = 2.5;
+
+ for(uint64_t step = 0u; step < 400u; ++step){
+ (lbm::reset_particle_accumulators<sch::T,D>)(parts.at({0u}));
+ (lbm::accumulate_box_wall_contacts<sch::T,D>)(parts.at({0u}), extent, dem, {1u});
+ (lbm::integrate_particle<sch::T,D>)(parts.at({0u}), {}, {1u});
+
+ auto x = parts.at({0u}).template get<"rigid_body">()
+ .template get<"position">().at({{0u}}).get();
+ if(x < deepest){ deepest = x; }
+ }
+
+ auto final_x = parts.at({0u}).template get<"rigid_body">()
+ .template get<"position">().at({{0u}}).get();
+
+ SAW_EXPECT(deepest > 0.0,
+ std::string{"the body must not pass through the wall, reached "}
+ + std::to_string(deepest));
+ SAW_EXPECT(final_x > deepest,
+ "and it must be pushed back out again");
+}
+
+SAW_TEST("Dynamics / sub steps do not change the trajectory"){
+ using namespace kel;
+
+ /**
+ * sub_steps subdivides one unit of time, so the displacement under a
+ * constant acceleration should come out the same regardless of how many
+ * pieces it is cut into. A mis-scaled dt would show up here immediately.
+ */
+ auto run = [&](uint64_t steps){
+ auto g = make_group<1u>(2.0, 1.0);
+ auto& p = g.template get<"particles">().at({0u});
+ auto& rb = p.template get<"rigid_body">();
+ rb.template get<"force">().at({{0u}}).set(rb.template get<"mass">().at({}).get());
+ (lbm::integrate_particle<sch::T,D>)(p, {}, {steps});
+ return rb.template get<"position">().at({{0u}}).get();
+ };
+
+ auto one = run(1u);
+ auto four = run(4u);
+ auto sixteen = run(16u);
+
+ SAW_EXPECT(one > 0.0, "must move at all");
+ // Verlet from rest: total displacement converges as the step shrinks.
+ SAW_EXPECT(std::abs(four - one) / one < 0.5,
+ std::string{"1 vs 4 sub steps diverged: "} + std::to_string(one)
+ + " vs " + std::to_string(four));
+ SAW_EXPECT(std::abs(sixteen - four) < std::abs(four - one),
+ "refining the sub step should be converging, not drifting");
+}
+}