From 0c0087ef9482634273ec1a23d3a915754f94926d Mon Sep 17 00:00:00 2001 From: "Claudius \"keldu\" Holeksa" Date: Wed, 11 Nov 2026 01:16:44 +0100 Subject: Snapshot. Migration to Lbm Unit --- modules/core/c++/abstract/math.hpp | 63 ++++++++ modules/core/c++/abstract/unit.hpp | 247 ++++++++++++++++++++++++++----- modules/core/c++/abstract/unit_print.hpp | 75 ++++++++-- modules/core/c++/boundary.hpp | 46 +++++- modules/core/c++/collision.hpp | 4 +- modules/core/c++/component/psm.hpp | 2 +- modules/core/c++/converter.hpp | 2 +- modules/core/c++/descriptor/d3q27.hpp | 70 +++++---- modules/core/c++/fplbm.hpp | 41 ++--- modules/core/c++/hlbm.hpp | 55 +++++-- modules/core/c++/particle/aabb.hpp | 2 +- modules/core/c++/particle/contact.hpp | 20 ++- modules/core/c++/particle/couple.hpp | 2 +- modules/core/c++/particle/integrate.hpp | 166 ++++++++++++++++++++- modules/core/c++/particle/particle.hpp | 26 +++- modules/core/c++/particle/porosity.hpp | 2 +- modules/core/c++/particle/schema.hpp | 22 ++- modules/core/c++/psm.hpp | 18 ++- 18 files changed, 714 insertions(+), 149 deletions(-) (limited to 'modules/core/c++') diff --git a/modules/core/c++/abstract/math.hpp b/modules/core/c++/abstract/math.hpp index d692be1..2d32a43 100644 --- a/modules/core/c++/abstract/math.hpp +++ b/modules/core/c++/abstract/math.hpp @@ -4,6 +4,7 @@ #include "data.hpp" #include "data_math.hpp" +#include "unit.hpp" namespace kel { namespace lbm { @@ -85,6 +86,68 @@ normalize(const data, Encoding> &input) { return out; } +/** + * Square root of a unit carrying scalar: the exponents halve, so the root of + * an area is a length. + * + * Only defined when every exponent is even -- a half power of a base unit is + * not expressible here, and silently truncating would be worse than refusing. + */ +template +data, sch::UnitElement...>, Encoding> +sqrt(const data, sch::UnitElement...>, + Encoding> &inp) { + static_assert(((E % 2 == 0) && ...), + "sqrt of a unit needs even exponents"); + return data, sch::UnitElement...>, + Encoding>{sqrt(inp.handle())}; +} + +/** + * Unit aware vector algebra. + * + * A unit belongs to the vector as a whole (see unit.hpp), so each of these + * recovers the raw vector, reuses the plain implementation above, and then + * re-attaches the unit the result actually carries. The result unit is + * computed rather than copied: the dot product of two lengths is an area, and + * a normalised vector is a direction and therefore dimensionless. + */ +template +auto dot(const data, EleL...>, Encoding> &left, + const data, EleR...>, Encoding> &right) { + using ResultSchema = + typename kel::lbm::unit_multiplication, EleL...>, + sch::Unit, EleR...>>::Schema; + return data{ + dot(left.handle(), right.handle())}; +} + +/** + * Length of a unit carrying vector. sqrt of an area is a length, so the unit + * is unchanged. + */ +template +data, Ele...>, Encoding> +norm(const data, Ele...>, Encoding> &input) { + return data, Ele...>, Encoding>{ + sqrt(dot(input.handle(), input.handle()))}; +} + +/** + * A direction is dimensionless, and dimensionless is spelled Pure -- a bare + * Vector would only mean "carries no annotation", which is a different claim. + */ +template +data>, Encoding> +normalize(const data, Ele...>, Encoding> &input) { + return data>, Encoding>{ + normalize(input.handle())}; +} + /** * Reinterprets a plain fixed array as a vector, so the algebra below applies * to it. diff --git a/modules/core/c++/abstract/unit.hpp b/modules/core/c++/abstract/unit.hpp index 406cb2f..b3d7391 100644 --- a/modules/core/c++/abstract/unit.hpp +++ b/modules/core/c++/abstract/unit.hpp @@ -10,11 +10,21 @@ namespace lbm { namespace sch { /** - * One factor of a unit: a base quantity raised to `Expo`, at scale `Scal`. + * One factor of a unit: a base quantity raised to `Expo`, at decimal scale + * `Scal`. * - * Scaling distinguishes units of the same quantity that are not - * interchangeable, e.g. lattice metres from SI metres, so that mixing them is - * a compile time error rather than a silent numeric mistake. + * `Scal` is an SI prefix exponent -- nano -9, micro -6, milli -3, none 0, kilo + * 3, mega 6, giga 9. It is a pure tag: the stored number is the value as + * written, so 2 km holds 2.0 and nothing is ever multiplied by a power of ten. + * + * It is NOT what separates lattice from SI. That comes from the base tag type + * itself -- `lbm_type::meter` and `si_type::meter` are distinct types, so + * mixing them cannot compile regardless of scale (see lbm_unit.hpp). + * + * Two factors fold their exponents only when base AND scale match + * (unit_matching_reduce below). Differently scaled quantities therefore do not + * add: km + m is a compile error by type identity. Implicit rescaling is + * deliberately absent -- add it here if it is ever wanted. */ template struct UnitElement { using Schema = Un; @@ -43,21 +53,19 @@ namespace impl { template class unit_matching; +/** + * A plain type list of UnitElements, used only to carry a pack around while + * the factors are being reduced. It holds no members: the specialisation below + * exists purely so that a non empty pack does not hit this assert. + */ template class unit_redux_list { static_assert(sizeof...(T) == 0u, "Template type not supported"); - - using Type = unit_redux_list<>; }; template struct unit_redux_list, - sch::UnitElement...> { - using Type = typename unit_matching< - unit_redux_list, - sch::UnitElement...>, - unit_redux_list<>>::TypeList; -}; + sch::UnitElement...> {}; template class unit_matching_reduce { public: @@ -108,7 +116,6 @@ public: using Type = sch::UnitElement; using TypeList = unit_redux_list...>; static constexpr int64_t Num = E; - static constexpr int64_t Scale = S; }; template class unit_matching { @@ -141,6 +148,85 @@ public: using TypeList = typename unit_matching::TypeList; }; +/** + * Whether a schema is a Unit at all. Lets the arithmetic below tell a united + * operand from a bare one. + */ +template struct is_unit_schema : std::false_type {}; + +template +struct is_unit_schema> : std::true_type {}; + +/** + * Splits a Unit into its base schema and its component list, so the list can + * be re-hosted on a different base. + * + * Needed because multiplying a unit vector by a unit scalar changes the base + * (Vector * Scalar -> Vector) while the component lists still have to be + * combined against each other. unit_multiplication requires both operands to + * share a base, so both are rebased onto the result first. + */ +template struct unit_parts; + +template struct unit_parts> { + using Base = B; + template using Rebase = sch::Unit; +}; + +/** + * A total order on unit factors, so that the same physical unit is always the + * same C++ type. + * + * Without this the reduction keeps encounter order, and m * s^-1 produces a + * different type from s^-1 * m -- the same quantity reached two ways then + * fails to match, and the mismatch shows up as a baffling template error far + * from its cause. Sorting by the base tag name gives a canonical form; the + * scale breaks ties so that factors differing only in prefix still order + * deterministically. + */ +template struct unit_element_less; + +template +struct unit_element_less, sch::UnitElement> { + static constexpr bool value = + (TA::name != TB::name) ? (TA::name < TB::name) : (SA < SB); +}; + +template struct unit_prepend; + +template +struct unit_prepend> { + using Type = unit_redux_list; +}; + +template struct unit_insert; + +template struct unit_insert> { + using Type = unit_redux_list; +}; + +template +struct unit_insert> { + using Type = typename std::conditional< + unit_element_less::value, + unit_redux_list, + typename unit_prepend< + Head, + typename unit_insert>::Type>::Type>::type; +}; + +template struct unit_sort; + +template <> struct unit_sort> { + using Type = unit_redux_list<>; +}; + +template +struct unit_sort> { + using Type = typename unit_insert< + Head, typename unit_sort>::Type>::Type; +}; + template class unit_add_base { static_assert(always_false, "Template type not supported"); }; @@ -154,24 +240,47 @@ public: } // namespace impl template struct unit_element_reduction { - using TypeList = + // Sorted after reducing, so the result is canonical regardless of the + // order the factors arrived in. + using TypeList = typename impl::unit_sort< typename impl::unit_matching, - impl::unit_redux_list<>>::TypeList; + impl::unit_redux_list<>>::TypeList>::Type; using Schema = typename impl::unit_add_base::Schema; }; +/** + * Labels a bare value with a unit. + * + * The deliberate way to cross from untyped to typed now that the wrapping + * constructor is explicit. Being a named function, every such crossing is + * greppable instead of happening silently at a call site. + */ +template +constexpr data as_unit(const data &value) { + return data{value}; +} + template struct unit_multiplication { static_assert(always_false, "Template type not supported"); }; +/** + * The scale packs have to be deduced explicitly. Writing + * `sch::UnitElement` here would mean + * `sch::UnitElement` after the default argument is + * substituted, so the specialisation would only ever match zero scaled factors + * and anything prefixed would fall through to the always_false primary. + */ template + int64_t... UnitS, typename... UnitRhsT, int64_t... UnitRhsE, + int64_t... UnitRhsS> struct unit_multiplication< - sch::Unit...>, - sch::Unit...>> { + sch::Unit...>, + sch::Unit...>> { using Schema = typename unit_element_reduction< - BaseSchema, sch::UnitElement..., - sch::UnitElement...>::Schema; + BaseSchema, sch::UnitElement..., + sch::UnitElement...>::Schema; }; template struct unit_division { @@ -180,15 +289,21 @@ template struct unit_division { /** * Division is multiplication by the negated exponents. + * + * The scale is deliberately NOT negated. Scale says which base unit is meant + * -- km rather than m -- while the exponent says what power it is raised to. + * So (km)^-1 is scale 3, exponent -1; negating the scale as well would quietly + * turn it into (mm)^-1. The symmetry with the exponent is only apparent. */ template + int64_t... UnitS, typename... UnitRhsT, int64_t... UnitRhsE, + int64_t... UnitRhsS> struct unit_division< - sch::Unit...>, - sch::Unit...>> { + sch::Unit...>, + sch::Unit...>> { using Schema = typename unit_element_reduction< - BaseSchema, sch::UnitElement..., - sch::UnitElement...>::Schema; + BaseSchema, sch::UnitElement..., + sch::UnitElement...>::Schema; }; /** @@ -212,16 +327,32 @@ public: KEL_DEFAULT_COPY(data); KEL_DEFAULT_MOVE(data); - data(const BaseData &dat__) : dat_{dat__} {} +/** + * Explicit: an already built value of the base type does not get to pick + * up a unit just because a unit was expected there. That is how an + * untyped sub step scalar silently became a time. + */ + explicit data(const BaseData &dat__) : dat_{dat__} {} + + explicit data(BaseData &&dat__) : dat_{std::move(dat__)} {} - data(BaseData &&dat__) : dat_{std::move(dat__)} {} + /** + * A bare literal is still allowed to become a united quantity at a + * construction site, because that is where the author is stating the + * unit. Only primitives, so this never competes with the base copy above + * for tensor valued units. + */ + template + requires(sch::is_primitive::value && std::is_arithmetic_v) + data(V value__) + : dat_{static_cast::type>(value__)} {} data operator+(const data &rhs) const { - return {dat_ + rhs.handle()}; + return data{dat_ + rhs.handle()}; } data operator-(const data &rhs) const { - return {dat_ - rhs.handle()}; + return data{dat_ - rhs.handle()}; } data &operator+=(const data &rhs) { @@ -250,22 +381,68 @@ public: return dat_ > rhs.handle(); } +/** + * The operands need not share a base schema: a length vector times a + * dimensionless scalar is a length vector. The base of the result is + * whatever the underlying arithmetic produces, and both component lists + * are rebased onto it before being combined. + */ template - data::Schema, enc::Native> - operator*(const data &rhs) const { - return {dat_ * rhs.handle()}; + requires impl::is_unit_schema::value + auto operator*(const data &rhs) const { + auto raw = dat_ * rhs.handle(); + using ResultBase = typename std::remove_cvref_t::Schema; + using ResultSchema = typename unit_multiplication< + typename impl::unit_parts::template Rebase, + typename impl::unit_parts::template Rebase>::Schema; + return data{raw}; } template - data::Schema, enc::Native> - operator/(const data &rhs) const { - return {dat_ / rhs.handle()}; + requires impl::is_unit_schema::value + auto operator/(const data &rhs) const { + auto raw = dat_ / rhs.handle(); + using ResultBase = typename std::remove_cvref_t::Schema; + using ResultSchema = typename unit_division< + typename impl::unit_parts::template Rebase, + typename impl::unit_parts::template Rebase>::Schema; + return data{raw}; } /** * The underlying value, with the unit stripped. Mostly for the * multiplication and division operators above. */ +/** + * Element access forwards to the underlying tensor and returns the raw + * element. + * + * The unit belongs to the quantity as a whole, not to one component -- a + * position is metres in every component -- so there is nothing distinct to + * attach per element. The wrapper is also not stored per element, so a + * reference to a unit typed component could not be formed even if it were + * wanted. Mixing is still caught, just at the vector level. + */ + /** + * The rank is taken through a defaulted template parameter so that it is + * a substitution failure, not a hard error, when the base is not a tensor. + * The parameter type itself stays concrete, because a braced index like + * at({{0u}}) cannot be deduced against a template parameter. + */ + template + auto &at(const index_data &index) { + return dat_.at(index); + } + + template + const auto &at(const index_data &index) const { + return dat_.at(index); + } + + auto &flat_at(uint64_t i) { return dat_.flat_at(i); } + + const auto &flat_at(uint64_t i) const { return dat_.flat_at(i); } + const BaseData &handle() const { return dat_; } BaseData &handle() { return dat_; } diff --git a/modules/core/c++/abstract/unit_print.hpp b/modules/core/c++/abstract/unit_print.hpp index 049e54f..2cb2ba6 100644 --- a/modules/core/c++/abstract/unit_print.hpp +++ b/modules/core/c++/abstract/unit_print.hpp @@ -1,13 +1,66 @@ #pragma once #include +#include #include "unit.hpp" +namespace kel { +namespace lbm { +namespace impl { +/** + * SI prefix symbol for a decimal scale exponent. + * + * Returns an empty view for the unprefixed case and for anything outside the + * table, which the caller renders as an explicit 10^n instead. Printing a + * scaled unit identically to an unscaled one would be worse than not printing + * it at all, so there is no silent fallback. + */ +inline constexpr std::string_view unit_prefix_symbol(int64_t scale) { + switch (scale) { + case -9: + return "n"; + case -6: + return "u"; + case -3: + return "m"; + case 0: + return ""; + case 3: + return "k"; + case 6: + return "M"; + case 9: + return "G"; + default: + return ""; + } +} + +inline constexpr bool unit_prefix_known(int64_t scale) { + return scale == -9 || scale == -6 || scale == -3 || scale == 0 || + scale == 3 || scale == 6 || scale == 9; +} +} // namespace impl +} // namespace lbm +} // namespace kel + namespace std { -template +/** + * The scale has to be deduced, not defaulted: writing UnitElement here + * would only ever match zero scaled factors, and a prefixed one would fail to + * bind at all. + */ +template inline ostream &operator<<(ostream &o, - const ::kel::lbm::sch::UnitElement &) { + const ::kel::lbm::sch::UnitElement &) { + if constexpr (US != 0) { + if constexpr (::kel::lbm::impl::unit_prefix_known(US)) { + o << ::kel::lbm::impl::unit_prefix_symbol(US); + } else { + o << "10^(" << US << ')' << '*'; + } + } o << UT::short_name; if constexpr (UE != 1) { o << '^' << '(' << UE << ')'; @@ -23,16 +76,19 @@ template struct unit_print { static_assert(always_false, "Template type not supported"); }; -template -struct unit_print, sch::UnitElement...> { +template +struct unit_print, + sch::UnitElement...> { static std::ostream &print(std::ostream &o) { - sch::UnitElement element; + sch::UnitElement element; std::ostream &o_ret = o << element; if constexpr (sizeof...(UTL) > 0) { std::ostream &o_ret_next = o_ret << ' ' << '*' << ' '; - return unit_print...>::print(o_ret_next); + return unit_print...>::print( + o_ret_next); } return o_ret << ']'; @@ -44,18 +100,19 @@ struct unit_print, sch::UnitElement...> { namespace std { template + int64_t... UnitE, int64_t... UnitS> inline ostream & operator<<(ostream &o, const ::kel::lbm::data< ::kel::lbm::sch::Unit< - StorageT, ::kel::lbm::sch::UnitElement...>, + StorageT, + ::kel::lbm::sch::UnitElement...>, Encode> &unit) { o << unit.handle().get(); if constexpr (sizeof...(UnitT) > 0) { auto &o_ret = o << ' ' << '['; return ::kel::lbm::impl::unit_print< - ::kel::lbm::sch::UnitElement...>::print(o_ret); + ::kel::lbm::sch::UnitElement...>::print(o_ret); } return o; } diff --git a/modules/core/c++/boundary.hpp b/modules/core/c++/boundary.hpp index d9ac941..7e5e65b 100644 --- a/modules/core/c++/boundary.hpp +++ b/modules/core/c++/boundary.hpp @@ -230,6 +230,22 @@ template class component, cmpt::ZouHePressureX, Encode> final { public: using Descriptor = sch::Descriptor<3u,27u>; +private: + /** + * The flag has to mean the same thing here as it does in the D2Q9 + * specialisation above, or the same call site picks a different wall + * depending on the descriptor. + * + * There, Dir == true reconstructs the populations with cx = +1, which are + * the unknowns at the x = 0 inlet. The body below is written for the + * opposite wall (unknowns with cx = -1, i.e. x = max), so the sense is + * flipped once here instead of at each branch. + * + * This used to be inverted, and since every example passes true for the + * inlet -- correct for D2Q9 -- the 3D cases drove the wrong face and + * diverged. + */ + static constexpr bool AtXMax = not East; private: kel::lbm::data rho_setting_; public: @@ -290,7 +306,7 @@ public: kel::lbm::data S; - if constexpr (East) { + if constexpr (AtXMax) { S = // cx = 0 @@ -347,10 +363,24 @@ public: kel::lbm::data rho_ux; - if constexpr (East) { - rho_ux = rho_setting_ - S; - } else { + /* + * With S = S0 + 2*S_known: + * + * x = max (unknown cx = -1): + * S_unknown = rho - S0 - S_known + * rho*ux = S_known - S_unknown = S - rho + * + * x = 0 (unknown cx = +1): + * rho*ux = S_unknown - S_known = rho - S + * + * Both of these were inverted, which drove the inlet and outlet the wrong + * way round and pumped mass into the domain every step. The D2Q9 + * specialisation above already has the correct signs. + */ + if constexpr (AtXMax) { rho_ux = S - rho_setting_; + } else { + rho_ux = rho_setting_ - S; } @@ -378,7 +408,7 @@ public: kel::lbm::data rho_uy; kel::lbm::data rho_uz; - if constexpr (East) { + if constexpr (AtXMax) { rho_uy = // cx = 0 @@ -506,7 +536,7 @@ public: * ============================================================ */ - if constexpr (East) { + if constexpr (AtXMax) { /* * -------------------------------------------------------- @@ -516,7 +546,7 @@ public: f.at({1u}) = f.at({2u}) - - kel::lbm::data{1.0 / 6.0} * rho_ux; + - kel::lbm::data{4.0 / 9.0} * rho_ux; /* @@ -624,7 +654,7 @@ public: f.at({2u}) = f.at({1u}) - + kel::lbm::data{1.0 / 6.0} * rho_ux; + + kel::lbm::data{4.0 / 9.0} * rho_ux; /* diff --git a/modules/core/c++/collision.hpp b/modules/core/c++/collision.hpp index d3e70cb..bf83994 100644 --- a/modules/core/c++/collision.hpp +++ b/modules/core/c++/collision.hpp @@ -81,7 +81,7 @@ public: auto& dfs_old_f = (is_even) ? field.template get<"dfs_old">() : field.template get<"dfs">(); auto& rho_f = macros.template get<"density">(); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); kel::lbm::data>& rho = rho_f.at(index); kel::lbm::data>& vel = vel_f.at(index); @@ -141,7 +141,7 @@ public: auto& dfs = dfs_old_f.at(index); auto& rho_f = macros.template get<"density">(); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); kel::lbm::data>& rho = rho_f.at(index); diff --git a/modules/core/c++/component/psm.hpp b/modules/core/c++/component/psm.hpp index e3ffa67..de71228 100644 --- a/modules/core/c++/component/psm.hpp +++ b/modules/core/c++/component/psm.hpp @@ -39,7 +39,7 @@ public: auto& porous_f = macros.template get<"porosity">(); auto& rho_f = macros.template get<"density">(); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); kel::lbm::data>& rho = rho_f.at(index); kel::lbm::data>& vel = vel_f.at(index); diff --git a/modules/core/c++/converter.hpp b/modules/core/c++/converter.hpp index 93c7617..a3c348d 100644 --- a/modules/core/c++/converter.hpp +++ b/modules/core/c++/converter.hpp @@ -19,7 +19,7 @@ private: kel::lbm::data, sch::LbmSecond >::Schema > second_conv_; public: converter() = delete; - converter( + explicit converter( kel::lbm::data, sch::LbmMeter >::Schema > meter_conv__, kel::lbm::data, sch::LbmSecond >::Schema > second_conv__ ): diff --git a/modules/core/c++/descriptor/d3q27.hpp b/modules/core/c++/descriptor/d3q27.hpp index 9358852..4190f15 100644 --- a/modules/core/c++/descriptor/d3q27.hpp +++ b/modules/core/c++/descriptor/d3q27.hpp @@ -47,37 +47,49 @@ public: { 1, 1, 1} // 26 }}; + /** + * D3Q27 weights, keyed on |e_i|^2: + * + * rest (|e|^2 = 0, 1 of them) 8/27 + * face (|e|^2 = 1, 6 of them) 2/27 + * edge (|e|^2 = 2, 12 of them) 1/54 + * corner (|e|^2 = 3, 8 of them) 1/216 + * + * These sum to 1. The six face weights used to read 1/36, which summed to + * 13/18 -- equilibrium then returned less mass than it was given and any + * 3D run diverged within a handful of steps. + */ static constexpr std::array::type,Q> weights = { - 8./27., + 8./27., // 0 rest // 1D - 1./36., - 1./36., - // 2D - 1./36., - 1./54., - 1./54., - 1./36., - 1./54., - 1./54., - // 3D - 1./36., - 1./54., - 1./54., - 1./54., - 1./216., - 1./216., - 1./54., - 1./216., - 1./216., - 1./36., - 1./54., - 1./54., - 1./54., - 1./216., - 1./216., - 1./54., - 1./216., - 1./216. + 2./27., // 1 face + 2./27., // 2 face + // Expand into 2D + 2./27., // 3 face + 1./54., // 4 edge + 1./54., // 5 edge + 2./27., // 6 face + 1./54., // 7 edge + 1./54., // 8 edge + // Expand into 3D + 2./27., // 9 face + 1./54., // 10 edge + 1./54., // 11 edge + 1./54., // 12 edge + 1./216., // 13 corner + 1./216., // 14 corner + 1./54., // 15 edge + 1./216., // 16 corner + 1./216., // 17 corner + 2./27., // 18 face + 1./54., // 19 edge + 1./54., // 20 edge + 1./54., // 21 edge + 1./216., // 22 corner + 1./216., // 23 corner + 1./54., // 24 edge + 1./216., // 25 corner + 1./216. // 26 corner }; static constexpr std::array opposite_index = { diff --git a/modules/core/c++/fplbm.hpp b/modules/core/c++/fplbm.hpp index f961bc9..bc99da5 100644 --- a/modules/core/c++/fplbm.hpp +++ b/modules/core/c++/fplbm.hpp @@ -48,7 +48,7 @@ public: auto& rho_f = macros.template get<"density">(); auto& rho = rho_f.at(index); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); auto& vel = vel_f.at(index); compute_rho_momentum(dfs,rho,vel); @@ -96,7 +96,7 @@ public: auto& force_f = macros.template get<"force">(); auto& force = force_f.at(index); - auto& mom_f = macros.template get<"momentum">(); + auto& mom_f = macros.template get<"velocity">(); auto& mom = mom_f.at(index); // We already computed this in reset @@ -144,13 +144,14 @@ class component final { public: using Component = cmpt::FpLbmOneParticleGather; private: - kel::lbm::data> global_force_; + // An acceleration, as the comment above says -- now typed as one. + kel::lbm::data>> body_acceleration_; public: component(): - global_force_{} + body_acceleration_{} {} - component(kel::lbm::data> global_force__): - global_force_{global_force__} + component(kel::lbm::data>> body_acceleration__): + body_acceleration_{body_acceleration__} {} template @@ -162,7 +163,7 @@ public: // auto& dfs = dfs_old_f.at(index); auto& rho_f = macros.template get<"density">(); - auto& mom_f = macros.template get<"momentum">(); + auto& mom_f = macros.template get<"velocity">(); auto& por_f = macros.template get<"porosity">(); auto& force_f = macros.template get<"force">(); @@ -177,9 +178,9 @@ public: auto& pi = parts.at(index); auto& pirb = pi.template get<"rigid_body">(); - auto& pirb_pos = pirb.template get<"position">(); - auto& pirb_pos_old = pirb.template get<"position_old">(); - auto& p_rad = pi.template get<"collision">().template get<"radius">(); + auto& pirb_pos = pirb.template get<"position">().handle(); + auto& pirb_pos_old = pirb.template get<"position_old">().handle(); + auto& p_rad = pi.template get<"collision">().template get<"radius">().handle(); @@ -205,7 +206,7 @@ public: auto vel_s = (pirb_pos-pirb_pos_old) * sss; kel::lbm::data> force_p{{}}; - //= global_force_; + //= body_acceleration_; iterator::apply([&](const auto& index_f) -> void { auto& force = force_f.at(index_f); @@ -220,7 +221,7 @@ public: // vel_s is technically time the density of the particle? - // force = global_force_ * por + ( vel_s - mom) * two * flip_por; + // force = body_acceleration_ * por + ( vel_s - mom) * two * flip_por; force = ( vel_s - mom) * two * flip_por; // force = (vel_s - mom) * flip_por / (flip_por / two + one); @@ -238,28 +239,30 @@ public: /** * The original fused one-particle step, kept so existing call sites keep - * working. global_force_ is an acceleration, so it rides along as the - * integrator's body acceleration. + * working. The body acceleration rides straight through to the integrator; + * it used to be called global_force_, which it never was -- the integrator + * takes an acceleration, not a force. */ template class component final { public: using Component = cmpt::FpLbmOneParticle; private: - kel::lbm::data> global_force_; + // An acceleration, as the comment above says -- now typed as one. + kel::lbm::data>> body_acceleration_; public: component(): - global_force_{} + body_acceleration_{} {} - component(kel::lbm::data> global_force__): - global_force_{global_force__} + component(kel::lbm::data>> body_acceleration__): + body_acceleration_{body_acceleration__} {} template void apply(const kel::lbm::data& field, const kel::lbm::data& macros, const kel::lbm::data& pg, kel::lbm::data> index, kel::lbm::data time_step, kel::lbm::data sub_steps) const { component reset; component gather; - component integrate{global_force_}; + component integrate{body_acceleration_}; reset.apply(pg,index,time_step); gather.apply(field,macros,pg,index,time_step,sub_steps); diff --git a/modules/core/c++/hlbm.hpp b/modules/core/c++/hlbm.hpp index acb2121..3bfdd6c 100644 --- a/modules/core/c++/hlbm.hpp +++ b/modules/core/c++/hlbm.hpp @@ -78,7 +78,7 @@ public: auto& porosity_f = macros.template get<"porosity">(); auto& rho_f = macros.template get<"density">(); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); kel::lbm::data>& rho = rho_f.at(index); kel::lbm::data>& vel = vel_f.at(index); @@ -128,7 +128,7 @@ public: auto& dfs_old_f = (is_even) ? field.template get<"dfs_old">() : field.template get<"dfs">(); auto& part_spheroid_group = part_group; - auto& mvel_f = macros.template get<"momentum">(); + auto& mvel_f = macros.template get<"velocity">(); auto& mrho_f = macros.template get<"density">(); auto& mpor_f = macros.template get<"porosity">(); { @@ -136,9 +136,15 @@ public: auto& pi = parts.at(index); auto& pirb = pi.template get<"rigid_body">(); - auto& p_rad = pi.template get<"collision">().template get<"radius">(); - kel::lbm::data>& pirb_pos = pirb.template get<"position">(); - auto& pirb_pos_old = pirb.template get<"position_old">(); + auto& p_rad = pi.template get<"collision">().template get<"radius">().handle(); + /** + * Unwrapped once here. The unit is checked where the position is + * stored and assigned; inside the sweep it meets lattice + * coordinates and lattice directions, which carry no unit yet, so + * the kernel works on the raw vector. + */ + auto& pirb_pos = pirb.template get<"position">().handle(); + auto& pirb_pos_old = pirb.template get<"position_old">().handle(); // Matches cmpt::ParticleIntegrate: zero sub steps means one step. uint64_t steps = sub_steps.get(); @@ -163,6 +169,16 @@ public: for(uint64_t i{0u}; i < Desc::D; ++i){ force_p.at({{i}}) = 0.0; } + + /** + * Hydrodynamic torque about the body centre. + * + * Accumulated from the same per-cell momentum as force_p and with + * the same sign applied at the end, so the two cannot disagree + * about which way the reaction points. + */ + kel::lbm::data::Schema> torque_p{}; + auto vel_p_old = (pirb_pos-pirb_pos_old) / ts; iterator::apply([&](const auto& index_f) -> void{ @@ -203,18 +219,37 @@ public: momentum = momentum + ei_dfs; } - // TODO technically needs to adjust for rotation as well - auto& rho = mrho_f.at(index_f); (void) rho; macros.template get<"force">().at(index_f) = momentum; force_p = force_p + momentum; + + /** + * r x f, with r the cell offset from the body centre already + * computed above. cross() returns a Scalar in 2D and a + * Vector3 in 3D, which is exactly the rotation type in each + * case, so one spelling covers both. + */ + torque_p = torque_p + kel::lbm::math::cross(rel_dist,momentum); },start,stop); // Accumulate, do not assign: contact adds to this before integration. auto& pirb_force = pirb.template get<"force">(); pirb_force = pirb_force - force_p; + + /** + * Same sign as the force above -- the per-cell momentum is what + * the fluid gained, so the body gets the negative of it. + * + * Gated: accumulating a torque no integrator will consume is a + * silent no-op, and in 3D only the fixed-axis integrator consumes + * it (see particle_fixed_axis_supported). + */ + if constexpr ( particle_angular_supported or particle_fixed_axis_supported ){ + auto& pirb_torque = pirb.template get<"torque">(); + pirb_torque = pirb_torque - torque_p; + } } } }; @@ -236,7 +271,7 @@ public: kel::lbm::data> one; one.at({}) = 1.0; - auto& mvel_f = macros.template get<"momentum">(); + auto& mvel_f = macros.template get<"velocity">(); auto& mpor_f = macros.template get<"porosity">(); auto& particle_N_f = field.template get<"particle_N">(); auto& particle_D_f = field.template get<"particle_D">(); @@ -244,8 +279,8 @@ public: auto parts = part_group.template get<"particles">(); auto& pi = parts.at(index); auto& pirb = pi.template get<"rigid_body">(); - auto& pirb_pos = pirb.template get<"position">(); - auto& pirb_pos_old = pirb.template get<"position_old">(); + auto& pirb_pos = pirb.template get<"position">().handle(); + auto& pirb_pos_old = pirb.template get<"position_old">().handle(); uint64_t steps = sub_steps.get(); if(steps == 0u){ diff --git a/modules/core/c++/particle/aabb.hpp b/modules/core/c++/particle/aabb.hpp index e207ad8..125232d 100644 --- a/modules/core/c++/particle/aabb.hpp +++ b/modules/core/c++/particle/aabb.hpp @@ -56,7 +56,7 @@ public: auto& b = aabb.template get<"b">(); // Radius is per particle now, so a group can hold mixed sizes. - const kel::lbm::data>& rad_d = pi.template get<"collision">().template get<"radius">(); + const kel::lbm::data>& rad_d = pi.template get<"collision">().template get<"radius">().handle(); kel::lbm::data> lower; kel::lbm::data> upper; diff --git a/modules/core/c++/particle/contact.hpp b/modules/core/c++/particle/contact.hpp index 857e116..cda4a01 100644 --- a/modules/core/c++/particle/contact.hpp +++ b/modules/core/c++/particle/contact.hpp @@ -269,7 +269,7 @@ contact_response soft_shell_response( * Velocity is implicit in position-Verlet, recovered from the position pair. */ template -kel::lbm::data> surface_velocity( +kel::lbm::data>> surface_velocity( const PRef& p, const kel::lbm::data>& r, typename kel::lbm::native_data_type::type steps @@ -304,7 +304,10 @@ kel::lbm::data> surface_velocity( } } - return v; + // (position difference) * steps is a lattice velocity, and saying so is + // the whole point of the label. The force law downstream is still untyped, + // because there is no mass base unit yet. + return kel::lbm::as_unit>>(v); } } @@ -348,16 +351,16 @@ contact_response particle_contact_response( auto v_s = impl::surface_velocity(self,r_s,steps); auto v_o = impl::surface_velocity(other,r_o,steps); - kel::lbm::data> v_rel; - for(uint64_t i{0u}; i < D; ++i){ - v_rel.at({{i}}).set(v_s.at({{i}}).get() - v_o.at({{i}}).get()); - } + // Velocity minus velocity is a velocity, checked rather than assumed. + auto v_rel = v_s - v_o; auto m_s = self.template get<"rigid_body">().template get<"mass">().at({}).get(); auto m_o = other.template get<"rigid_body">().template get<"mass">().at({}).get(); auto m_eff = (m_s * m_o) / (m_s + m_o); - return impl::soft_shell_response(m,r_s,v_rel,m_eff,dem); + // Unwrapped here: the spring-dashpot produces a force, and force has no + // unit until there is a mass base unit. + return impl::soft_shell_response(m,r_s,v_rel.handle(),m_eff,dem); } /** @@ -390,7 +393,8 @@ contact_response wall_contact_response( auto m_s = self.template get<"rigid_body">().template get<"mass">().at({}).get(); - return impl::soft_shell_response(m,r_s,v_rel,m_s,dem); + // Same boundary as the pair case: the force law is untyped. + return impl::soft_shell_response(m,r_s,v_rel.handle(),m_s,dem); } /** diff --git a/modules/core/c++/particle/couple.hpp b/modules/core/c++/particle/couple.hpp index 19a276c..d882081 100644 --- a/modules/core/c++/particle/couple.hpp +++ b/modules/core/c++/particle/couple.hpp @@ -43,7 +43,7 @@ kel::lbm::data> cell_porosity( for_each_bin_candidate(cl,cell,[&](uint64_t p){ auto& pi = parts.at({p}); auto& pos = pi.template get<"rigid_body">().template get<"position">(); - auto rad = pi.template get<"collision">().template get<"radius">(); + auto rad = pi.template get<"collision">().template get<"radius">().handle(); kel::lbm::data> rel; for(uint64_t i{0u}; i < D; ++i){ diff --git a/modules/core/c++/particle/integrate.hpp b/modules/core/c++/particle/integrate.hpp index a84cd37..1e85338 100644 --- a/modules/core/c++/particle/integrate.hpp +++ b/modules/core/c++/particle/integrate.hpp @@ -45,21 +45,29 @@ constexpr bool particle_angular_supported = (D == 2u); template void integrate_particle( kel::lbm::data>& pi, - const kel::lbm::data>& body_acceleration, + const kel::lbm::data>>& body_acceleration, kel::lbm::data sub_steps ){ auto& pirb = pi.template get<"rigid_body">(); const uint64_t steps = particle_sub_steps(sub_steps); - kel::lbm::data> ts; + // A sub step is a lattice time, not a bare number. + kel::lbm::data>> ts; ts.at({}).set( typename kel::lbm::native_data_type::type(1) / static_cast::type>(steps) ); + /** + * The seam between the typed and untyped halves. Force and mass carry no + * units yet -- there is no mass base unit -- so their quotient is a bare + * vector and the acceleration unit is attached here, deliberately and in + * one place, rather than being acquired silently at an assignment. + */ pirb.template get<"acceleration">() = - pirb.template get<"force">() / pirb.template get<"mass">() + kel::lbm::data>>{ + pirb.template get<"force">() / pirb.template get<"mass">()} + body_acceleration; // See particle_angular_supported for why 3D is excluded rather than @@ -74,6 +82,113 @@ void integrate_particle( } } +/** + * Whether rotation about a single FIXED axis can be integrated exactly. + * + * True in 3D as well as 2D, unlike particle_angular_supported. Constraining + * the body to one axis does not paper over the three problems listed there -- + * it removes all of them: + * + * - Rotation composition only fails to commute when the axis moves. If the + * angular acceleration is always parallel to a fixed axis and the rotation + * starts parallel to it, the rotation vector stays parallel to it for all + * time, so verlet_step_lambda's component-wise update is exact rather than + * a small-angle approximation. + * - omega x (I omega) vanishes when omega lies along a principal axis. Every + * axis of a sphere is principal, and a rotor symmetric about its own axis + * has that axis principal. The term is genuinely zero, not neglected. + * - A scalar inertia is exactly the moment about that one axis. + * + * This is the wind turbine case: a body pinned in place, free to spin about + * one axis and nothing else. + */ +template +constexpr bool particle_fixed_axis_supported = (D == 2u or D == 3u); + +namespace impl { +/** + * The spin axis has the same schema as the rotation it drives: a signed scalar + * in 2D (there is only the out-of-plane direction), a unit vector in 3D. + */ +template +using spin_axis_schema = typename sch::impl::rotation_type_helper::Schema; + +template +kel::lbm::data> normalise_spin_axis( + const kel::lbm::data>& axis +){ + if constexpr ( D == 2u ){ + kel::lbm::data> out; + const auto a = axis.at({}).get(); + out.at({}).set((a < 0) ? -1 : 1); + return out; + }else{ + // math::normalize returns a zero vector unchanged rather than NaN, so + // a caller that forgets the axis gets a body that never spins instead + // of one that poisons the whole simulation. + return kel::lbm::math::normalize(axis); + } +} +} + +/** + * Projects the accumulated torque onto a fixed axis and advances the body + * about it, holding the position fixed. + * + * The position is pinned by zeroing the acceleration, not by writing the + * position back each step. Position-Verlet is x_new = 2x - x_old + a dt^2, so + * with x_old == x at construction and a == 0 the body stays exactly where it + * started, every step, bitwise, with no drift to correct for. + */ +template +void integrate_particle_fixed_axis( + kel::lbm::data>& pi, + const kel::lbm::data>& axis, + kel::lbm::data sub_steps +){ + static_assert(particle_fixed_axis_supported, "Fixed axis spin needs D == 2 or D == 3"); + + auto& pirb = pi.template get<"rigid_body">(); + + const uint64_t steps = particle_sub_steps(sub_steps); + + // A sub step is a lattice time, not a bare number. + kel::lbm::data>> ts; + ts.at({}).set( + typename kel::lbm::native_data_type::type(1) + / static_cast::type>(steps) + ); + + // Pinned: the accumulated force is deliberately ignored. + auto& acc = pirb.template get<"acceleration">(); + for(uint64_t i{0u}; i < D; ++i){ + acc.at({{i}}).set(0); + } + + auto& torque = pirb.template get<"torque">(); + auto& inertia = pirb.template get<"inertia">(); + auto& ang_acc = pirb.template get<"angular_acceleration">(); + + if constexpr ( D == 2u ){ + ang_acc.at({}).set( + axis.at({}).get() * torque.at({}).get() / inertia.at({}).get() + ); + }else{ + // tau_axis = axis . torque, then alpha = axis * (tau_axis / I). Any + // torque component off the axis is reacted by the mounting and does + // not accelerate the rotor. + const auto tau_axis = kel::lbm::math::dot(axis,torque).at({}).get(); + const auto alpha = tau_axis / inertia.at({}).get(); + for(uint64_t i{0u}; i < 3u; ++i){ + ang_acc.at({{i}}).set(axis.at({{i}}).get() * alpha); + } + } + + for(uint64_t i{0u}; i < steps; ++i){ + verlet_step_lambda(pi,ts); + } +} + /** * Clears the force/torque accumulators. Must run before any contributor. */ @@ -113,6 +228,16 @@ struct ParticleForceReset {}; * acceleration directly, so a second contributor silently overwrote the first. */ struct ParticleIntegrate {}; + +/** + * Integrates a body pinned in place and free to spin about one fixed axis. + * + * The rotor case: the fluid torque projected onto the axis spins it, the + * position never moves, and angular velocity is an output. Unlike + * ParticleIntegrate this works in 3D -- see particle_fixed_axis_supported for + * why the constraint makes that exact rather than approximate. + */ +struct ParticleAxisIntegrate {}; } template @@ -145,14 +270,14 @@ private: * Body acceleration applied to every particle, e.g. gravity. Kept as an * acceleration rather than a force so it does not need the mass. */ - kel::lbm::data> body_acceleration_; + kel::lbm::data>> body_acceleration_; public: component(): body_acceleration_{} {} - component(const kel::lbm::data>& body_acceleration__): + component(const kel::lbm::data>>& body_acceleration__): body_acceleration_{body_acceleration__} {} @@ -170,5 +295,36 @@ public: } }; +template +class component final { +public: + using Component = cmpt::ParticleAxisIntegrate; + +private: + /** + * Normalised once here rather than per step, so the kernel never divides + * by a length and a caller cannot change the axis mid-run. + */ + kel::lbm::data> axis_; + +public: + component(const kel::lbm::data>& axis__): + axis_{impl::normalise_spin_axis(axis__)} + {} + + template + void apply( + const kel::lbm::data& pg, + kel::lbm::data> index, + kel::lbm::data time_step, + kel::lbm::data sub_steps + ) const { + (void) time_step; + + auto& parts = pg.template get<"particles">(); + integrate_particle_fixed_axis(parts.at(index), axis_, sub_steps); + } +}; + } } diff --git a/modules/core/c++/particle/particle.hpp b/modules/core/c++/particle/particle.hpp index 00e401a..4d96440 100644 --- a/modules/core/c++/particle/particle.hpp +++ b/modules/core/c++/particle/particle.hpp @@ -18,7 +18,7 @@ namespace lbm { */ template kel::lbm::data>> create_spheroid_particle_group( - kel::lbm::data> radius_p, + kel::lbm::data>> radius_p, kel::lbm::data> density_p, const kel::lbm::data& mask_resolution ){ @@ -169,7 +169,7 @@ kel::lbm::data>> create_sph */ template -constexpr auto verlet_step_lambda = [](kel::lbm::data>& particle, kel::lbm::data> time_step_delta){ +constexpr auto verlet_step_lambda = [](kel::lbm::data>& particle, kel::lbm::data>> time_step_delta){ auto& body = particle.template get<"rigid_body">(); auto& pos = body.template get<"position">(); @@ -184,10 +184,13 @@ constexpr auto verlet_step_lambda = [](kel::lbm::data>& parti auto tsd_squared = time_step_delta * time_step_delta; - kel::lbm::data> pos_new; + kel::lbm::data>> pos_new; // Actual step - kel::lbm::data> two; + // Dimensionless, and spelled as such: Pure is the claim, Scalar is only + // the shape. + kel::lbm::data>> two; two.at({}).set(2.0); + // m + (m/s^2)*s^2 = m. pos_new = pos * two - pos_old + pos_acc * tsd_squared; // Swap - Could be std::swap? No, this is device code @@ -196,7 +199,12 @@ constexpr auto verlet_step_lambda = [](kel::lbm::data>& parti // Angular kel::lbm::data::Schema> rot_new; - rot_new = rot * two - rot_old + rot_acc * tsd_squared; + /** + * The angular half runs on raw values. Torque and inertia have no units + * yet (there is no mass base unit), so angular acceleration cannot be + * typed either, and the timestep has to be unwrapped to meet it. + */ + rot_new = rot * two.handle() - rot_old + rot_acc * tsd_squared.handle(); rot_old = rot; rot = rot_new; @@ -240,7 +248,8 @@ template> constexpr auto broadphase_collision_distance_squared = []( const PRef& left, const PRef& right -) -> std::pair>>{ +) -> std::pair>, sch::LbmMeter>>::Schema>>{ auto rad_l = left.template get<"collision">().template get<"radius">(); auto rad_r = right.template get<"collision">().template get<"radius">(); @@ -252,9 +261,10 @@ constexpr auto broadphase_collision_distance_squared = []( auto norm_2 = kel::lbm::math::dot(pos_dist,pos_dist); - kel::lbm::data> two; + // Dimensionless factor, so it has to say Pure. + kel::lbm::data>> two; two.at({}) = 2.0; - // (r_l + r_r)^2 + // (r_l + r_r)^2 -- an area, matching the squared centre distance above. auto rad_ab_2 = rad_l * rad_l + rad_r * rad_r + rad_r * rad_l * two; return std::make_pair((norm_2.at({}).get() < rad_ab_2.at({}).get()), norm_2); diff --git a/modules/core/c++/particle/porosity.hpp b/modules/core/c++/particle/porosity.hpp index cd4e804..f393eb1 100644 --- a/modules/core/c++/particle/porosity.hpp +++ b/modules/core/c++/particle/porosity.hpp @@ -106,7 +106,7 @@ public: kel::lbm::data> dist_len = kel::lbm::math::dot(dist,dist); dist_len.at({}).set(std::sqrt(dist_len.at({}).get())); auto& coll = pi.template get<"collision">(); - const kel::lbm::data>& rad_d = coll.template get<"radius">(); + const kel::lbm::data>& rad_d = coll.template get<"radius">().handle(); const auto& eps = part_group.template get<"epsilon">().at({}); // Move this somewhere diff --git a/modules/core/c++/particle/schema.hpp b/modules/core/c++/particle/schema.hpp index 39e1a36..b0a6f5d 100644 --- a/modules/core/c++/particle/schema.hpp +++ b/modules/core/c++/particle/schema.hpp @@ -2,6 +2,8 @@ #include "common.hpp" +#include "../lbm_unit.hpp" + namespace kel { namespace lbm { @@ -10,7 +12,8 @@ template struct Spheroid { using ValueSchema = T; using Schema = sch::Struct< - sch::Member,"radius"> + // A radius is a lattice length, like the position it is compared against. + sch::Member>,"radius"> >; }; } @@ -47,12 +50,23 @@ struct inertia_type_helper { template using ParticleRigidBody = Struct< - Member, "position">, - Member, "position_old">, + /** + * Lattice length. The unit sits on the vector rather than on its + * components: a position is metres in every direction, and the component + * type is what the kernels index. + */ + Member>, "position">, + Member>, "position_old">, Member::Schema, "rotation">, Member::Schema, "rotation_old">, - Member, "acceleration">, + /** + * Lattice acceleration. Typed because the Verlet update adds + * acceleration * dt^2 to a position and so must come out in metres. + * It is also where the typed and untyped halves meet: force and mass have + * no units yet, so integrate_particle attaches this one explicitly. + */ + Member>, "acceleration">, Member::Schema, "angular_acceleration">, /** diff --git a/modules/core/c++/psm.hpp b/modules/core/c++/psm.hpp index b540f38..7f43e2d 100644 --- a/modules/core/c++/psm.hpp +++ b/modules/core/c++/psm.hpp @@ -65,7 +65,7 @@ public: auto& porous_f = macros.template get<"porosity">(); auto& rho_f = macros.template get<"density">(); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); kel::lbm::data>& rho = rho_f.at(index); kel::lbm::data>& vel = vel_f.at(index); @@ -125,7 +125,7 @@ void apply( auto& por_f = macros.template get<"porosity">(); auto& rho_f = macros.template get<"density">(); - auto& vel_f = macros.template get<"momentum">(); + auto& vel_f = macros.template get<"velocity">(); auto& force_f = macros.template get<"force">(); kel::lbm::data> one; @@ -145,16 +145,20 @@ void apply( auto& pi = parts.at(index); auto& p_rad = - pi.template get<"collision">().template get<"radius">(); + pi.template get<"collision">().template get<"radius">().handle(); auto& pirb = pi.template get<"rigid_body">(); - kel::lbm::data>& pirb_pos = - pirb.template get<"position">(); + /** + * Unwrapped once here. The unit is checked where the position is + * stored and assigned; inside the sweep it meets lattice coordinates + * and lattice directions, which carry no unit yet, so the kernel + * works on the raw vector. + */ + auto& pirb_pos = pirb.template get<"position">().handle(); - auto& pirb_pos_old = - pirb.template get<"position_old">(); + auto& pirb_pos_old = pirb.template get<"position_old">().handle(); /* -- cgit v1.3.1