++

Author: PhilipDeegan

src/amr/data/particles/particles_data.hpp

@@ -161,9 +161,8 @@ namespace amr
                 particles.sortMapping();
 
                 Packer{particles}.pack_ranges_into(
-                    [&](auto&&... args) {
-                        auto&& [arr, _] = std::forward_as_tuple(args...);
-                        core::double_apply(arr(), [&](auto const& key, auto const& arg, auto...) {
+                    [&](auto const& arr, auto const...) {
+                        core::double_apply(arr(), [&](auto const& key, auto const& arg) {
                             restart_db->putVector(name + "_" + key, arg);
                         });
                     },
@@ -202,7 +201,7 @@ namespace amr
                     = restart_db->getArraySize(name + "_" + Packer::arbitrarySingleValueKey());
                 core::ContiguousParticles<dim> soa{n_particles};
 
-                core::double_apply(soa(), [&](auto const& key, auto& arg, auto...) {
+                core::double_apply(soa(), [&](auto const& key, auto& arg) {
                     restart_db->getVector(name + "_" + key, arg);
                 });
 

src/core/data/particles/particle_array.hpp

@@ -342,25 +342,32 @@ namespace core
 
 
         template<typename T>
-        using tuple_element = std::tuple<std::string, container_t<T>&, std::size_t>;
+        using tuple_element_t = std::tuple<std::string, container_t<T>&>;
 
-        auto static _as_named_tuple(auto&& self)
+        auto operator()()
         {
-            return std::make_tuple(tuple_element<double>("weight", self.weight, 1),
-                                   tuple_element<double>("charge", self.charge, 1),
-                                   tuple_element<int>("iCell", self.iCell, dim),
-                                   tuple_element<double>("delta", self.delta, dim),
-                                   tuple_element<double>("v", self.v, 3));
+            return std::make_tuple(
+                tuple_element_t<double>("weight", weight),
+                tuple_element_t<double>("charge", charge), tuple_element_t<int>("iCell", iCell),
+                tuple_element_t<double>("delta", delta), tuple_element_t<double>("v", v));
         }
 
-        auto operator()() { return _as_named_tuple(*this); }
-        auto operator()() const { return _as_named_tuple(*this); }
+        template<typename T>
+        using tuple_element_ct = std::tuple<std::string, container_t<T> const&>;
+
+        auto operator()() const
+        {
+            return std::make_tuple(
+                tuple_element_ct<double>("weight", weight),
+                tuple_element_ct<double>("charge", charge), tuple_element_ct<int>("iCell", iCell),
+                tuple_element_ct<double>("delta", delta), tuple_element_ct<double>("v", v));
+        }
 
 
         void clear()
         {
             if constexpr (OwnedState)
-                core::double_apply((*this)(), [](auto& key, auto& vec, auto _) { vec.clear(); });
+                core::double_apply((*this)(), [](auto& key, auto& vec) { vec.clear(); });
         }
 
         void push_back(auto const& particle)

src/core/data/particles/particle_packer.hpp

@@ -23,7 +23,7 @@ class ParticlePacker
     {
     }
 
-    NO_DISCARD static auto get(Particle<dim> const& particle)
+    NO_DISCARD static constexpr auto get(Particle<dim> const& particle)
     {
         return std::forward_as_tuple(particle.weight, particle.charge, particle.iCell,
                                      particle.delta, particle.v);

src/hdf5/writer/particle_writer.hpp

@@ -18,17 +18,23 @@ class ParticleWriter
     template<typename H5File, typename Particles>
     static void write(H5File& h5file, Particles const& particles, std::string const& path)
     {
-        auto constexpr dim = Particles::dimension;
-        using Packer       = core::ParticlePacker<dim>;
+        constexpr auto dim              = Particles::dimension;
+        using Packer                    = core::ParticlePacker<dim>;
+        constexpr auto particle_members = Packer::empty();
+        static auto& keys               = Packer::keys();
 
-        Packer{particles}.pack_ranges_into([&](auto&&... args) {
-            auto&& [arr, from] = std::forward_as_tuple(args...);
 
-            core::double_apply(arr(), [&](auto const& key, auto const& arg, auto size) {
+        Packer{particles}.pack_ranges_into([&](auto const& arr, auto const from) {
+            auto const soa_members = arr();
+
+            core::for_N<Packer::n_keys>([&](auto ki) {
+                auto const [key, member] = std::get<ki>(soa_members);
+                auto const actual        = std::get<ki>(particle_members);
+
                 h5file.file()
-                    .getDataSet(path + key)
-                    .select({from, 0ul}, {arr.size(), size})
-                    .write_raw(arg.data());
+                    .getDataSet(path + keys[ki])
+                    .select({from, 0ul}, size_for<dim>(actual, arr.size()))
+                    .write_raw(member.data());
             });
         });
     }

tests/core/data/particles/test_interop.cpp

@@ -56,7 +56,6 @@ TYPED_TEST(ParticleListTest, SoAandAoSInterop)
     EXPECT_EQ(contiguous.size(), particleArray.size());
 
     ContiguousParticles<dim> AoSFromSoA{particleArray.size()};
-    AoSFromSoA.clear();
     EXPECT_EQ(AoSFromSoA.size(), 0);
     ParticlePacker<dim>{particleArray}.pack(AoSFromSoA);
     EXPECT_EQ(AoSFromSoA.size(), size);