From fb251caffa2be8aaceed7190636e078ae75f889f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 15:43:03 +0100
Subject: [PATCH 01/22] Base structure for scientific defaults

---
 CMakeLists.txt                                |  1 +
 include/openPMD/Iteration.hpp                 |  5 ++-
 include/openPMD/Mesh.hpp                      | 11 ++++++-
 include/openPMD/ParticleSpecies.hpp           |  5 ++-
 include/openPMD/backend/Container.hpp         | 28 ++++++++++++++++
 .../openPMD/backend/MeshRecordComponent.hpp   |  5 ++-
 .../openPMD/backend/ScientificDefaults.hpp    | 18 +++++++++++
 src/Iteration.cpp                             | 15 +++++++++
 src/backend/ScientificDefaults.cpp            | 32 +++++++++++++++++++
 9 files changed, 116 insertions(+), 4 deletions(-)
 create mode 100644 include/openPMD/backend/ScientificDefaults.hpp
 create mode 100644 src/backend/ScientificDefaults.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index dba77d38be..f741d524e7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -426,6 +426,7 @@ set(CORE_SOURCE
         src/backend/PatchRecord.cpp
         src/backend/PatchRecordComponent.cpp
         src/backend/Writable.cpp
+        src/backend/ScientificDefaults.cpp
         src/auxiliary/OneDimensionalBlockSlicer.cpp
         src/helper/list_series.cpp
         src/snapshots/ContainerImpls.cpp
diff --git a/include/openPMD/Iteration.hpp b/include/openPMD/Iteration.hpp
index c66199c46f..fac3a0a269 100644
--- a/include/openPMD/Iteration.hpp
+++ b/include/openPMD/Iteration.hpp
@@ -27,6 +27,7 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <cstdint>
 #include <deque>
@@ -142,7 +143,9 @@ namespace internal
  * @see
  * https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#required-attributes-for-the-basepath
  */
-class Iteration : public Attributable
+class Iteration
+    : public Attributable
+    , internal::ScientificDefaults<Iteration>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
diff --git a/include/openPMD/Mesh.hpp b/include/openPMD/Mesh.hpp
index d0bf81ddef..deaebfcb5f 100644
--- a/include/openPMD/Mesh.hpp
+++ b/include/openPMD/Mesh.hpp
@@ -23,7 +23,9 @@
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <ostream>
 #include <string>
@@ -37,7 +39,9 @@ namespace openPMD
  * @see
  * https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#mesh-based-records
  */
-class Mesh : public BaseRecord<MeshRecordComponent>
+class Mesh
+    : public BaseRecord<MeshRecordComponent>
+    , internal::ScientificDefaults<Mesh>
 {
     friend class Container<Mesh>;
     friend class Iteration;
@@ -330,6 +334,11 @@ class Mesh : public BaseRecord<MeshRecordComponent>
     void read();
 }; // Mesh
 
+static_assert(internal::IsContainer_v<Mesh>);
+static_assert(std::is_same_v<
+              Container<MeshRecordComponent>,
+              internal::AsContainer_t<Mesh>>);
+
 template <typename T>
 inline std::vector<T> Mesh::gridSpacing() const
 {
diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp
index 4f309c0f2a..8a0eb2fc80 100644
--- a/include/openPMD/ParticleSpecies.hpp
+++ b/include/openPMD/ParticleSpecies.hpp
@@ -24,13 +24,16 @@
 #include "openPMD/Record.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
 
 namespace openPMD
 {
 
-class ParticleSpecies : public Container<Record>
+class ParticleSpecies
+    : public Container<Record>
+    , internal::ScientificDefaults<ParticleSpecies>
 {
     friend class Container<ParticleSpecies>;
     friend class Container<Record>;
diff --git a/include/openPMD/backend/Container.hpp b/include/openPMD/backend/Container.hpp
index 963fd34802..25fc9a4349 100644
--- a/include/openPMD/backend/Container.hpp
+++ b/include/openPMD/backend/Container.hpp
@@ -343,5 +343,33 @@ namespace internal
 
         ~EraseStaleEntries();
     };
+
+    template <template <typename...> class Base, typename... Args>
+    auto infer_template_args(Base<Args...> &) -> Base<Args...>;
+
+    template <typename T, typename SFINAE = void>
+    struct IsContainer
+    {
+        static constexpr bool value = false;
+    };
+
+    template <typename T>
+    struct IsContainer<
+        T,
+        std::void_t<decltype(infer_template_args<Container>(
+            std::declval<T &>()))>>
+    {
+        static constexpr bool value = true;
+        using type =
+            decltype(infer_template_args<Container>(std::declval<T &>()));
+    };
+
+    template <typename T>
+    constexpr bool IsContainer_v = IsContainer<T>::value;
+    template <typename T>
+    using AsContainer_t = typename IsContainer<T>::type;
+
+    static_assert(!IsContainer_v<int>);
+    static_assert(IsContainer_v<Container<Attributable>>);
 } // namespace internal
 } // namespace openPMD
diff --git a/include/openPMD/backend/MeshRecordComponent.hpp b/include/openPMD/backend/MeshRecordComponent.hpp
index 708c4a496f..04524cf574 100644
--- a/include/openPMD/backend/MeshRecordComponent.hpp
+++ b/include/openPMD/backend/MeshRecordComponent.hpp
@@ -21,6 +21,7 @@
 #pragma once
 
 #include "openPMD/RecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <vector>
 
@@ -32,7 +33,9 @@ namespace internal
     class BaseRecordData;
 }
 
-class MeshRecordComponent : public RecordComponent
+class MeshRecordComponent
+    : public RecordComponent
+    , internal::ScientificDefaults<MeshRecordComponent>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
new file mode 100644
index 0000000000..52b0749e33
--- /dev/null
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "openPMD/IO/Access.hpp"
+#include <type_traits>
+
+namespace openPMD::internal
+{
+template <typename Child> // CRT
+class ScientificDefaults
+{
+protected:
+    void finalize(Access);
+};
+
+template <typename Child>
+constexpr bool HasScientificDefaults_v =
+    std::is_base_of_v<ScientificDefaults<Child>, Child>;
+} // namespace openPMD::internal
diff --git a/src/Iteration.cpp b/src/Iteration.cpp
index ab35c1e3ae..92de30fea7 100644
--- a/src/Iteration.cpp
+++ b/src/Iteration.cpp
@@ -32,6 +32,7 @@
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
 #include "openPMD/backend/Writable.hpp"
 
@@ -112,6 +113,20 @@ Iteration &Iteration::close(bool _flush)
         // yet keeps it re-openable)
         break;
     }
+    {
+        Access at = IOHandler()->m_frontendAccess;
+        finalize(at);
+        for (auto &[_, mesh] : meshes)
+        {
+            (void)_;
+            mesh.internal::ScientificDefaults<Mesh>::finalize(at);
+        }
+        for (auto &[_, ps] : particles)
+        {
+            (void)_;
+            ps.finalize(at);
+        }
+    }
     if (_flush)
     {
         if (flag == StepStatus::DuringStep)
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
new file mode 100644
index 0000000000..eac2386a68
--- /dev/null
+++ b/src/backend/ScientificDefaults.cpp
@@ -0,0 +1,32 @@
+#include "openPMD/backend/ScientificDefaults.hpp"
+#include "openPMD/Iteration.hpp"
+#include "openPMD/Mesh.hpp"
+#include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/MeshRecordComponent.hpp"
+
+namespace openPMD::internal
+{
+template <typename Child>
+void ScientificDefaults<Child>::finalize(Access at)
+{
+    if constexpr (IsContainer_v<Child>)
+    {
+        using Container_t = AsContainer_t<Child>;
+        using value_t = typename Container_t::value_type;
+        if constexpr (HasScientificDefaults_v<value_t>)
+        {
+            for (auto &[_, right] : *this)
+            {
+                (void)_;
+                right.ScientificDefaults<value_t>::finalize(at);
+            }
+        }
+    }
+}
+
+template class ScientificDefaults<Iteration>;
+template class ScientificDefaults<Mesh>;
+template class ScientificDefaults<MeshRecordComponent>;
+template class ScientificDefaults<ParticleSpecies>;
+} // namespace openPMD::internal

From 205461e650a6906145afe7695569b0f31a812120 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 17:14:45 +0100
Subject: [PATCH 02/22] Start adding defaults

---
 include/openPMD/Iteration.hpp                 |   1 +
 include/openPMD/Mesh.hpp                      |   2 +
 include/openPMD/ParticleSpecies.hpp           |   1 +
 .../openPMD/backend/MeshRecordComponent.hpp   |   1 +
 .../openPMD/backend/ScientificDefaults.hpp    |  40 +++++
 src/Mesh.cpp                                  |  51 +++----
 src/backend/ScientificDefaults.cpp            | 138 ++++++++++++++++++
 7 files changed, 202 insertions(+), 32 deletions(-)

diff --git a/include/openPMD/Iteration.hpp b/include/openPMD/Iteration.hpp
index fac3a0a269..4aed643472 100644
--- a/include/openPMD/Iteration.hpp
+++ b/include/openPMD/Iteration.hpp
@@ -156,6 +156,7 @@ class Iteration
     friend class Writable;
     friend class StatefulIterator;
     friend class StatefulSnapshotsContainer;
+    friend class internal::ScientificDefaults<Iteration>;
 
 public:
     Iteration(Iteration const &) = default;
diff --git a/include/openPMD/Mesh.hpp b/include/openPMD/Mesh.hpp
index deaebfcb5f..279db4fdbb 100644
--- a/include/openPMD/Mesh.hpp
+++ b/include/openPMD/Mesh.hpp
@@ -45,6 +45,7 @@ class Mesh
 {
     friend class Container<Mesh>;
     friend class Iteration;
+    friend class internal::ScientificDefaults<Mesh>;
 
 public:
     Mesh(Mesh const &) = default;
@@ -332,6 +333,7 @@ class Mesh
     void
     flush_impl(std::string const &, internal::FlushParams const &) override;
     void read();
+    auto retrieveDimensionality() const -> uint64_t;
 }; // Mesh
 
 static_assert(internal::IsContainer_v<Mesh>);
diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp
index 8a0eb2fc80..8c8b187afb 100644
--- a/include/openPMD/ParticleSpecies.hpp
+++ b/include/openPMD/ParticleSpecies.hpp
@@ -40,6 +40,7 @@ class ParticleSpecies
     friend class Iteration;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults<ParticleSpecies>;
 
 public:
     ParticlePatches particlePatches;
diff --git a/include/openPMD/backend/MeshRecordComponent.hpp b/include/openPMD/backend/MeshRecordComponent.hpp
index 04524cf574..30449885bd 100644
--- a/include/openPMD/backend/MeshRecordComponent.hpp
+++ b/include/openPMD/backend/MeshRecordComponent.hpp
@@ -43,6 +43,7 @@ class MeshRecordComponent
     friend class BaseRecord;
     template <typename, typename>
     friend class internal::BaseRecordData;
+    friend class internal::ScientificDefaults<MeshRecordComponent>;
 
     friend class Mesh;
 
diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
index 52b0749e33..9a0a1de763 100644
--- a/include/openPMD/backend/ScientificDefaults.hpp
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -3,13 +3,53 @@
 #include "openPMD/IO/Access.hpp"
 #include <type_traits>
 
+namespace openPMD::detail
+{
+template <typename F, typename SFINAE = void>
+struct IsCallable
+{
+    static constexpr bool value = false;
+    using type = F;
+};
+
+template <typename F>
+struct IsCallable<F, std::void_t<decltype(std::declval<F>()())>>
+{
+    static constexpr bool value = true;
+    using type = decltype(std::declval<F>()());
+};
+
+template <typename F>
+constexpr bool IsCallable_v = IsCallable<F>::value;
+template <typename F>
+using CallResult_t = typename IsCallable<F>::type;
+} // namespace openPMD::detail
+
 namespace openPMD::internal
 {
 template <typename Child> // CRT
 class ScientificDefaults
 {
+private:
+    auto asChild() -> Child &;
+    auto asChild() const -> Child const &;
+
+    template <typename F>
+    using setter_t = Child &(Child::*)();
+
+    template <typename Setter = void, typename F>
+    void addDefaultFor(
+        char const *key,
+        Child &(Child::*)(std::conditional_t<
+                          std::is_void_v<Setter>,
+                          std::remove_reference_t<detail::CallResult_t<F>>,
+                          Setter>),
+        F &&get_value);
+    // template<typename F>
+    // void addDefaultFor(char const *key, F&& get_value);
 protected:
     void finalize(Access);
+    void addDefaults();
 };
 
 template <typename Child>
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index e93b2b5219..9f6c46a9a6 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -35,17 +35,7 @@
 
 namespace openPMD
 {
-Mesh::Mesh()
-{
-    setTimeOffset(0.f);
-
-    setGeometry(Geometry::cartesian);
-    setDataOrder(DataOrder::C);
-
-    setAxisLabels({"x"}); // empty strings are not allowed in HDF5
-    setGridSpacing(std::vector<double>{1});
-    setGridGlobalOffset({0});
-}
+Mesh::Mesh() = default;
 
 Mesh::Geometry Mesh::geometry() const
 {
@@ -204,27 +194,24 @@ Mesh &Mesh::setGridUnitSI(std::vector<double> const &gusi)
     return setGridUnitSIPerDimension(gusi);
 }
 
-namespace
+auto Mesh::retrieveDimensionality() const -> uint64_t
 {
-    uint64_t retrieveMeshDimensionality(Mesh const &m)
+    if (containsAttribute("axisLabels"))
     {
-        if (m.containsAttribute("axisLabels"))
-        {
-            return m.axisLabels().size();
-        }
+        return axisLabels().size();
+    }
 
-        // maybe we have record components and can ask them
-        if (auto it = m.begin(); it != m.end())
-        {
-            return it->second.getDimensionality();
-        }
-        /*
-         * Since some backends cannot distinguish between vector and
-         * scalar values, the most likely answer here is 1.
-         */
-        return 1;
+    // maybe we have record components and can ask them
+    if (auto it = begin(); it != end())
+    {
+        return it->second.getDimensionality();
     }
-} // namespace
+    /*
+     * Since some backends cannot distinguish between vector and
+     * scalar values, the most likely answer here is 1.
+     */
+    return 1;
+}
 
 std::vector<double> Mesh::gridUnitSIPerDimension() const
 {
@@ -235,7 +222,7 @@ std::vector<double> Mesh::gridUnitSIPerDimension() const
             // If the openPMD version is lower than 2.0, the gridUnitSI is a
             // scalar interpreted for all axes. Copy it d times.
             return std::vector<double>(
-                retrieveMeshDimensionality(*this),
+                retrieveDimensionality(),
                 getAttribute("gridUnitSI").get<double>());
         }
         return getAttribute("gridUnitSI").get<std::vector<double>>();
@@ -244,7 +231,7 @@ std::vector<double> Mesh::gridUnitSIPerDimension() const
     {
         // gridUnitSI is an optional attribute
         // if it is missing, the mesh is interpreted as unscaled
-        return std::vector<double>(retrieveMeshDimensionality(*this), 1.);
+        return std::vector<double>(retrieveDimensionality(), 1.);
     }
 }
 
@@ -341,7 +328,7 @@ unit_representations::AsArrays Mesh::gridUnitDimension() const
         // if it is missing, the mesh is interpreted as spatial
         auto spatialMesh =
             unit_representations::asArray({{UnitDimension::L, 1}});
-        auto dim = retrieveMeshDimensionality(*this);
+        auto dim = retrieveDimensionality();
         unit_representations::AsArrays res(dim, spatialMesh);
         return res;
     }
@@ -426,7 +413,7 @@ void Mesh::flush_impl(
             else
             {
                 setGridUnitSIPerDimension(
-                    std::vector<double>(retrieveMeshDimensionality(*this), 1));
+                    std::vector<double>(retrieveDimensionality(), 1));
             }
         }
         flushAttributes(flushParams);
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index eac2386a68..da03e91cdc 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -4,12 +4,78 @@
 #include "openPMD/ParticleSpecies.hpp"
 #include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
+#include <iostream>
+#include <utility>
 
 namespace openPMD::internal
 {
+template <typename Child>
+auto ScientificDefaults<Child>::asChild() -> Child &
+{
+    return *static_cast<Child *>(this);
+}
+
+template <typename Child>
+auto ScientificDefaults<Child>::asChild() const -> Child const &
+{
+    return *static_cast<Child const *>(this);
+}
+
+template <typename Child>
+template <typename Setter, typename F>
+void ScientificDefaults<Child>::addDefaultFor(
+    char const *key,
+    Child &(Child::*setter)(std::conditional_t<
+                            std::is_void_v<Setter>,
+                            std::remove_reference_t<detail::CallResult_t<F>>,
+                            Setter>),
+    F &&get_value)
+{
+    if (asChild().containsAttribute(key))
+    {
+        return;
+    }
+    std::cout << "\tInitializing default for '" << key << "'" << std::endl;
+    auto value = [&]() {
+        if constexpr (detail::IsCallable_v<F>)
+        {
+            return get_value();
+        }
+        else
+        {
+            return get_value;
+        }
+    }();
+    (asChild().*setter)(std::move(value));
+}
+// template <typename Child>
+// template <typename F>
+// void ScientificDefaults<Child>::addDefaultFor(char const *key, F &&get_value)
+// {
+//     if (asChild().containsAttribute(key))
+//     {
+//         return;
+//     }
+//     auto value = [&]() {
+//         if constexpr (detail::IsCallable_v<F>)
+//         {
+//             return get_value();
+//         }
+//         else
+//         {
+//             return get_value;
+//         }
+//     }();
+//     asChild().setAttribute(key, std::move(value));
+// }
+
 template <typename Child>
 void ScientificDefaults<Child>::finalize(Access at)
 {
+    if (access::write(at))
+    {
+        addDefaults();
+    }
     if constexpr (IsContainer_v<Child>)
     {
         using Container_t = AsContainer_t<Child>;
@@ -25,6 +91,78 @@ void ScientificDefaults<Child>::finalize(Access at)
     }
 }
 
+template <typename Child>
+void ScientificDefaults<Child>::addDefaults()
+{
+    std::cout << "Adding defaults for '" << asChild().myPath().openPMDPath()
+              << "'" << std::endl;
+
+    if constexpr (std::is_same_v<Child, Mesh>)
+    {
+        auto dimensionality = asChild().retrieveDimensionality();
+
+        addDefaultFor("timeOffset", &Mesh::setTimeOffset, 0.f);
+        addDefaultFor(
+            "geometry", &Mesh::setGeometry, Mesh::Geometry::cartesian);
+        addDefaultFor("dataOrder", &Mesh::setDataOrder, Mesh::DataOrder::C);
+        addDefaultFor<std::vector<std::string> const &>(
+            "axisLabels",
+            &Mesh::setAxisLabels,
+            [&]() -> std::vector<std::string> {
+                switch (dimensionality)
+                {
+                case 1:
+                    return {"x"};
+                case 2:
+                    return {"x", "y"};
+                case 3:
+                    return {"x", "y", "z"};
+                default: {
+                    if (dimensionality < 100)
+                    {
+                        std::vector<std::string> res;
+                        res.reserve(dimensionality);
+                        for (uint64_t i = 0; i < dimensionality; ++i)
+                        {
+                            res.emplace_back("x" + std::to_string(i));
+                        }
+                        return res;
+                    }
+                    else
+                    {
+                        return {
+                            "Please verify dimensionality. Was inferred as '" +
+                            std::to_string(dimensionality) + "'."};
+                    }
+                }
+                }
+                return std::vector<std::string>{"x", "y", "z"};
+            });
+        addDefaultFor<std::vector<double> const &>(
+            "gridSpacing", &Mesh::setGridSpacing, [&]() {
+                if (dimensionality < 100)
+                {
+                    return std::vector<double>(1.0, dimensionality);
+                }
+                else
+                {
+                    return std::vector<double>();
+                }
+            });
+        addDefaultFor<std::vector<double> const &>(
+            "gridGlobalOffset", &Mesh::setGridGlobalOffset, [&]() {
+                if (dimensionality < 100)
+                {
+                    return std::vector<double>(0.0, dimensionality);
+                }
+                else
+                {
+                    return std::vector<double>();
+                }
+            });
+    }
+}
+
 template class ScientificDefaults<Iteration>;
 template class ScientificDefaults<Mesh>;
 template class ScientificDefaults<MeshRecordComponent>;

From 2d29a95fe975a265d088226586fe81f6b7e56146 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 18:00:51 +0100
Subject: [PATCH 03/22] debugging output

---
 src/backend/ScientificDefaults.cpp | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index da03e91cdc..c3d4868821 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -2,6 +2,8 @@
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Mesh.hpp"
 #include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include <iostream>
@@ -35,7 +37,6 @@ void ScientificDefaults<Child>::addDefaultFor(
     {
         return;
     }
-    std::cout << "\tInitializing default for '" << key << "'" << std::endl;
     auto value = [&]() {
         if constexpr (detail::IsCallable_v<F>)
         {
@@ -46,6 +47,17 @@ void ScientificDefaults<Child>::addDefaultFor(
             return get_value;
         }
     }();
+    std::cout << "\tInitializing default for '" << key << "' = ";
+    if constexpr (auxiliary::IsVector_v<
+                      std::remove_reference_t<decltype(value)>>)
+    {
+        auxiliary::write_vec_to_stream(std::cout, value);
+    }
+    else
+    {
+        std::cout << value;
+    }
+    std::cout << "'" << std::endl;
     (asChild().*setter)(std::move(value));
 }
 // template <typename Child>
@@ -100,6 +112,8 @@ void ScientificDefaults<Child>::addDefaults()
     if constexpr (std::is_same_v<Child, Mesh>)
     {
         auto dimensionality = asChild().retrieveDimensionality();
+        // std::cout << "Dimensionality is " << dimensionality << " for '"
+        //           << asChild().myPath().openPMDPath() << "'" << std::endl;
 
         addDefaultFor("timeOffset", &Mesh::setTimeOffset, 0.f);
         addDefaultFor(
@@ -146,18 +160,18 @@ void ScientificDefaults<Child>::addDefaults()
                 }
                 else
                 {
-                    return std::vector<double>();
+                    return std::vector<double>{1.0};
                 }
             });
         addDefaultFor<std::vector<double> const &>(
             "gridGlobalOffset", &Mesh::setGridGlobalOffset, [&]() {
-                if (dimensionality < 100)
-                {
-                    return std::vector<double>(0.0, dimensionality);
-                }
-                else
+                // if (dimensionality < 100)
+                // {
+                //     return std::vector<double>(0.0, dimensionality);
+                // }
+                // else
                 {
-                    return std::vector<double>();
+                    return std::vector<double>{0.0};
                 }
             });
     }

From 372830c539ec20a3c4d65ee3ae5964484d529d3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 20:03:06 +0100
Subject: [PATCH 04/22] Fixes

---
 src/Series.cpp                     |  8 ++++++++
 src/backend/ScientificDefaults.cpp | 14 +++++++-------
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/Series.cpp b/src/Series.cpp
index 6d13de73c3..49f2c646b2 100644
--- a/src/Series.cpp
+++ b/src/Series.cpp
@@ -3301,6 +3301,14 @@ namespace internal
             !(access::readOnly(IOHandler->m_frontendAccess) &&
               !(*this)->m_writable.written))
         {
+            for (auto &[_, iteration] : iterations)
+            {
+                (void)_;
+                if (!iteration.closed())
+                {
+                    iteration.close(/* flush = */ false);
+                }
+            }
             impl.flush();
             /*
              * In file-based iteration encoding, this must be triggered by
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index c3d4868821..e8e519e119 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -47,7 +47,7 @@ void ScientificDefaults<Child>::addDefaultFor(
             return get_value;
         }
     }();
-    std::cout << "\tInitializing default for '" << key << "' = ";
+    std::cout << "\tInitializing default for '" << key << "' = '";
     if constexpr (auxiliary::IsVector_v<
                       std::remove_reference_t<decltype(value)>>)
     {
@@ -156,7 +156,7 @@ void ScientificDefaults<Child>::addDefaults()
             "gridSpacing", &Mesh::setGridSpacing, [&]() {
                 if (dimensionality < 100)
                 {
-                    return std::vector<double>(1.0, dimensionality);
+                    return std::vector<double>(dimensionality, 1.0);
                 }
                 else
                 {
@@ -165,11 +165,11 @@ void ScientificDefaults<Child>::addDefaults()
             });
         addDefaultFor<std::vector<double> const &>(
             "gridGlobalOffset", &Mesh::setGridGlobalOffset, [&]() {
-                // if (dimensionality < 100)
-                // {
-                //     return std::vector<double>(0.0, dimensionality);
-                // }
-                // else
+                if (dimensionality < 100)
+                {
+                    return std::vector<double>(dimensionality, 0.0);
+                }
+                else
                 {
                     return std::vector<double>{0.0};
                 }

From ca09aa61f8e1677fa95db2651718228905a30a7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 21:23:57 +0100
Subject: [PATCH 05/22] BaseRecord --> unitDimension

---
 include/openPMD/auxiliary/TypeTraits.hpp      |  28 +++++
 include/openPMD/backend/BaseRecord.hpp        |   6 +
 include/openPMD/backend/Container.hpp         |  25 +---
 .../openPMD/backend/ScientificDefaults.hpp    |  19 +++-
 src/backend/BaseRecord.cpp                    |   9 +-
 src/backend/ScientificDefaults.cpp            | 107 +++++++++++++-----
 test/CoreTest.cpp                             |  10 +-
 7 files changed, 143 insertions(+), 61 deletions(-)

diff --git a/include/openPMD/auxiliary/TypeTraits.hpp b/include/openPMD/auxiliary/TypeTraits.hpp
index faf2b29472..05a0033cbe 100644
--- a/include/openPMD/auxiliary/TypeTraits.hpp
+++ b/include/openPMD/auxiliary/TypeTraits.hpp
@@ -203,6 +203,34 @@ namespace detail
     // little trick to avoid trailing commas in the macro expansions below
     template <typename Arg, typename... Args>
     using variant_tail_t = std::variant<Args...>;
+
+    template <template <typename...> class Base, typename... Args>
+    auto infer_template_args(Base<Args...> &) -> Base<Args...>;
+
+    template <
+        template <typename> class Base,
+        typename T,
+        typename SFINAE = void>
+    struct IsTemplateBaseOf
+    {
+        static constexpr bool value = false;
+    };
+
+    template <template <typename> class Base, typename T>
+    struct IsTemplateBaseOf<
+        Base,
+        T,
+        std::void_t<decltype(detail::infer_template_args<Base>(
+            std::declval<T &>()))>>
+    {
+        static constexpr bool value = true;
+        using type =
+            decltype(detail::infer_template_args<Base>(std::declval<T &>()));
+    };
 } // namespace detail
 
+template <template <typename> class Base, typename T>
+constexpr bool IsTemplateBaseOf_v = detail::IsTemplateBaseOf<Base, T>::value;
+template <template <typename> class Base, typename T>
+using AsTemplateBase_t = typename detail::IsTemplateBaseOf<Base, T>::type;
 } // namespace openPMD::auxiliary
diff --git a/include/openPMD/backend/BaseRecord.hpp b/include/openPMD/backend/BaseRecord.hpp
index f75536e3bd..db60a62bea 100644
--- a/include/openPMD/backend/BaseRecord.hpp
+++ b/include/openPMD/backend/BaseRecord.hpp
@@ -26,6 +26,7 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <array>
 #include <stdexcept>
@@ -165,6 +166,8 @@ namespace internal
     };
 } // namespace internal
 
+class Mesh;
+
 /**
  * @brief Base class for any type of record (e.g. mesh or particle record).
  *
@@ -179,6 +182,7 @@ template <typename T_elem>
 class BaseRecord
     : public Container<T_elem>
     , public T_elem // T_RecordComponent
+    , internal::ScientificDefaults<BaseRecord<T_elem>>
 {
 public:
     using T_RecordComponent = T_elem;
@@ -197,6 +201,8 @@ class BaseRecord
     friend class internal::ScalarIterator;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults<BaseRecord<T_elem>>;
+    friend class internal::ScientificDefaults<Mesh>;
 
     using Data_t =
         internal::BaseRecordData<T_elem, typename T_RecordComponent::Data_t>;
diff --git a/include/openPMD/backend/Container.hpp b/include/openPMD/backend/Container.hpp
index 25fc9a4349..418823ede4 100644
--- a/include/openPMD/backend/Container.hpp
+++ b/include/openPMD/backend/Container.hpp
@@ -22,6 +22,7 @@
 
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/Access.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Attributable.hpp"
 
 #include <initializer_list>
@@ -344,30 +345,10 @@ namespace internal
         ~EraseStaleEntries();
     };
 
-    template <template <typename...> class Base, typename... Args>
-    auto infer_template_args(Base<Args...> &) -> Base<Args...>;
-
-    template <typename T, typename SFINAE = void>
-    struct IsContainer
-    {
-        static constexpr bool value = false;
-    };
-
-    template <typename T>
-    struct IsContainer<
-        T,
-        std::void_t<decltype(infer_template_args<Container>(
-            std::declval<T &>()))>>
-    {
-        static constexpr bool value = true;
-        using type =
-            decltype(infer_template_args<Container>(std::declval<T &>()));
-    };
-
     template <typename T>
-    constexpr bool IsContainer_v = IsContainer<T>::value;
+    constexpr bool IsContainer_v = auxiliary::IsTemplateBaseOf_v<Container, T>;
     template <typename T>
-    using AsContainer_t = typename IsContainer<T>::type;
+    using AsContainer_t = auxiliary::AsTemplateBase_t<Container, T>;
 
     static_assert(!IsContainer_v<int>);
     static_assert(IsContainer_v<Container<Attributable>>);
diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
index 9a0a1de763..fba37397f6 100644
--- a/include/openPMD/backend/ScientificDefaults.hpp
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -37,14 +37,29 @@ class ScientificDefaults
     template <typename F>
     using setter_t = Child &(Child::*)();
 
+    template <typename Setter = void, typename V>
+    void addDefaultFor_worker(char const *key, V &&value, Setter &&setter);
+
+    template <typename V>
+    void addDefaultFor_worker(char const *key, V &&value);
+
+    template <typename F, typename... Args>
+    void addDefaultFor_resolveValue(char const *key, F &&get_value, Args &&...);
+
     template <typename Setter = void, typename F>
     void addDefaultFor(
         char const *key,
+        F &&get_value,
         Child &(Child::*)(std::conditional_t<
                           std::is_void_v<Setter>,
                           std::remove_reference_t<detail::CallResult_t<F>>,
-                          Setter>),
-        F &&get_value);
+                          Setter>));
+
+    template <typename F>
+    void addDefaultFor(char const *key, F &&get_value);
+
+    template <typename Parent>
+    void addParentDefaults();
     // template<typename F>
     // void addDefaultFor(char const *key, F&& get_value);
 protected:
diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp
index 37d6d7b126..07b27902d2 100644
--- a/src/backend/BaseRecord.cpp
+++ b/src/backend/BaseRecord.cpp
@@ -34,14 +34,7 @@ namespace openPMD
 namespace internal
 {
     template <typename T_elem, typename T_RecordComponentData>
-    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData()
-    {
-        Attributable impl;
-        impl.setData({this, [](auto const *) {}});
-        impl.setAttribute(
-            "unitDimension",
-            std::array<double, 7>{{0., 0., 0., 0., 0., 0., 0.}});
-    }
+    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData() = default;
 
 #define OPENPMD_INSTANTIATE(recordcomponenttype)                               \
     template class BaseRecordData<                                             \
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index e8e519e119..ab1e07b203 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -2,6 +2,7 @@
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Mesh.hpp"
 #include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/UnitDimension.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Container.hpp"
@@ -24,14 +25,24 @@ auto ScientificDefaults<Child>::asChild() const -> Child const &
 }
 
 template <typename Child>
-template <typename Setter, typename F>
-void ScientificDefaults<Child>::addDefaultFor(
-    char const *key,
-    Child &(Child::*setter)(std::conditional_t<
-                            std::is_void_v<Setter>,
-                            std::remove_reference_t<detail::CallResult_t<F>>,
-                            Setter>),
-    F &&get_value)
+template <typename Setter, typename V>
+void ScientificDefaults<Child>::addDefaultFor_worker(
+    char const *, V &&value, Setter &&setter)
+{
+    (asChild().*setter)(std::forward<V>(value));
+}
+
+template <typename Child>
+template <typename V>
+void ScientificDefaults<Child>::addDefaultFor_worker(char const *key, V &&value)
+{
+    asChild().setAttribute(key, std::forward<V>(value));
+}
+
+template <typename Child>
+template <typename F, typename... Args>
+void ScientificDefaults<Child>::addDefaultFor_resolveValue(
+    char const *key, F &&get_value, Args &&...args)
 {
     if (asChild().containsAttribute(key))
     {
@@ -47,18 +58,48 @@ void ScientificDefaults<Child>::addDefaultFor(
             return get_value;
         }
     }();
-    std::cout << "\tInitializing default for '" << key << "' = '";
-    if constexpr (auxiliary::IsVector_v<
-                      std::remove_reference_t<decltype(value)>>)
-    {
-        auxiliary::write_vec_to_stream(std::cout, value);
-    }
-    else
     {
-        std::cout << value;
+        std::cout << "\tInitializing default for '" << key << "' = '";
+        if constexpr (
+            auxiliary::IsVector_v<std::remove_reference_t<decltype(value)>> ||
+            auxiliary::IsArray_v<std::remove_reference_t<decltype(value)>>)
+        {
+            auxiliary::write_vec_to_stream(std::cout, value);
+        }
+        else
+        {
+            std::cout << value;
+        }
+        std::cout << "'" << std::endl;
     }
-    std::cout << "'" << std::endl;
-    (asChild().*setter)(std::move(value));
+    addDefaultFor_worker(key, std::move(value), std::forward<Args>(args)...);
+}
+
+template <typename Child>
+template <typename Setter, typename F>
+void ScientificDefaults<Child>::addDefaultFor(
+    char const *key,
+    F &&get_value,
+    Child &(Child::*setter)(std::conditional_t<
+                            std::is_void_v<Setter>,
+                            std::remove_reference_t<detail::CallResult_t<F>>,
+                            Setter>))
+{
+    addDefaultFor_resolveValue(key, std::forward<F>(get_value), setter);
+}
+
+template <typename Child>
+template <typename F>
+void ScientificDefaults<Child>::addDefaultFor(char const *key, F &&get_value)
+{
+    addDefaultFor_resolveValue(key, std::forward<F>(get_value));
+}
+
+template <typename Child>
+template <typename Parent>
+void ScientificDefaults<Child>::addParentDefaults()
+{
+    asChild().ScientificDefaults<Parent>::addDefaults();
 }
 // template <typename Child>
 // template <typename F>
@@ -115,13 +156,12 @@ void ScientificDefaults<Child>::addDefaults()
         // std::cout << "Dimensionality is " << dimensionality << " for '"
         //           << asChild().myPath().openPMDPath() << "'" << std::endl;
 
-        addDefaultFor("timeOffset", &Mesh::setTimeOffset, 0.f);
+        addDefaultFor("timeOffset", 0.f, &Mesh::setTimeOffset);
         addDefaultFor(
-            "geometry", &Mesh::setGeometry, Mesh::Geometry::cartesian);
-        addDefaultFor("dataOrder", &Mesh::setDataOrder, Mesh::DataOrder::C);
+            "geometry", Mesh::Geometry::cartesian, &Mesh::setGeometry);
+        addDefaultFor("dataOrder", Mesh::DataOrder::C, &Mesh::setDataOrder);
         addDefaultFor<std::vector<std::string> const &>(
             "axisLabels",
-            &Mesh::setAxisLabels,
             [&]() -> std::vector<std::string> {
                 switch (dimensionality)
                 {
@@ -151,9 +191,11 @@ void ScientificDefaults<Child>::addDefaults()
                 }
                 }
                 return std::vector<std::string>{"x", "y", "z"};
-            });
+            },
+            &Mesh::setAxisLabels);
         addDefaultFor<std::vector<double> const &>(
-            "gridSpacing", &Mesh::setGridSpacing, [&]() {
+            "gridSpacing",
+            [&]() {
                 if (dimensionality < 100)
                 {
                     return std::vector<double>(dimensionality, 1.0);
@@ -162,9 +204,11 @@ void ScientificDefaults<Child>::addDefaults()
                 {
                     return std::vector<double>{1.0};
                 }
-            });
+            },
+            &Mesh::setGridSpacing);
         addDefaultFor<std::vector<double> const &>(
-            "gridGlobalOffset", &Mesh::setGridGlobalOffset, [&]() {
+            "gridGlobalOffset",
+            [&]() {
                 if (dimensionality < 100)
                 {
                     return std::vector<double>(dimensionality, 0.0);
@@ -173,7 +217,15 @@ void ScientificDefaults<Child>::addDefaults()
                 {
                     return std::vector<double>{0.0};
                 }
-            });
+            },
+            &Mesh::setGridGlobalOffset);
+
+        addParentDefaults<BaseRecord<MeshRecordComponent>>();
+    }
+    else if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
+    {
+        addDefaultFor<unit_representations::AsArray const &>(
+            "unitDimension", unit_representations::AsArray{});
     }
 }
 
@@ -181,4 +233,5 @@ template class ScientificDefaults<Iteration>;
 template class ScientificDefaults<Mesh>;
 template class ScientificDefaults<MeshRecordComponent>;
 template class ScientificDefaults<ParticleSpecies>;
+template class ScientificDefaults<BaseRecord<MeshRecordComponent>>;
 } // namespace openPMD::internal
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index ad22ae1cf8..eae22ec0b3 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -755,11 +755,18 @@ TEST_CASE("mesh_constructor_test", "[core]")
     Mesh &m = o.iterations[42].meshes["E"];
 
     std::vector<double> pos{0};
-    /* unitSI and position are set to default values upon flushing */
+    /* unitSI and position are set to default values upon closing */
     REQUIRE(m["x"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["y"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["z"].resetDataset(globalDataset).numAttributes() == 0);
 
+    for (auto const &attr : m.attributes())
+    {
+        std::cout << "Attribute: " << attr << std::endl;
+    }
+    REQUIRE(m.numAttributes() == 0);
+    o.iterations[42].close();
+
     REQUIRE(m.geometry() == Mesh::Geometry::cartesian);
     REQUIRE(m.dataOrder() == Mesh::DataOrder::C);
     std::vector<std::string> al{"x"};
@@ -773,7 +780,6 @@ TEST_CASE("mesh_constructor_test", "[core]")
         7); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
                timeOffset, unitDimension */
 
-    o.flush();
     REQUIRE(m["x"].unitSI() == 1);
     REQUIRE(m["x"].numAttributes() == 2); /* unitSI, position */
     REQUIRE(m["x"].position<double>() == pos);

From e0a92ef3d23d9f99f9caf87c1f08dc1a5ff56236 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 22:10:10 +0100
Subject: [PATCH 06/22] nunja hehe

---
 include/openPMD/Record.hpp                    |  9 ++++-
 include/openPMD/backend/BaseRecord.hpp        |  4 +--
 .../openPMD/backend/MeshRecordComponent.hpp   |  3 +-
 src/backend/ScientificDefaults.cpp            | 35 ++++++++++++++++---
 test/CoreTest.cpp                             |  8 +++--
 5 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/include/openPMD/Record.hpp b/include/openPMD/Record.hpp
index 2bb070365f..618a246c83 100644
--- a/include/openPMD/Record.hpp
+++ b/include/openPMD/Record.hpp
@@ -23,17 +23,22 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
 #include <type_traits>
 
 namespace openPMD
 {
-class Record : public BaseRecord<RecordComponent>
+class Record
+    : public BaseRecord<RecordComponent>
+    , internal::ScientificDefaults<Record>
 {
     friend class Container<Record>;
     friend class Iteration;
     friend class ParticleSpecies;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     Record(Record const &) = default;
@@ -57,6 +62,8 @@ class Record : public BaseRecord<RecordComponent>
     [[nodiscard]] internal::HomogenizeExtents read();
 }; // Record
 
+static_assert(internal::HasScientificDefaults_v<Record>);
+
 template <typename T>
 inline T Record::timeOffset() const
 {
diff --git a/include/openPMD/backend/BaseRecord.hpp b/include/openPMD/backend/BaseRecord.hpp
index db60a62bea..daca050740 100644
--- a/include/openPMD/backend/BaseRecord.hpp
+++ b/include/openPMD/backend/BaseRecord.hpp
@@ -201,8 +201,8 @@ class BaseRecord
     friend class internal::ScalarIterator;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
-    friend class internal::ScientificDefaults<BaseRecord<T_elem>>;
-    friend class internal::ScientificDefaults<Mesh>;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     using Data_t =
         internal::BaseRecordData<T_elem, typename T_RecordComponent::Data_t>;
diff --git a/include/openPMD/backend/MeshRecordComponent.hpp b/include/openPMD/backend/MeshRecordComponent.hpp
index 30449885bd..5319985832 100644
--- a/include/openPMD/backend/MeshRecordComponent.hpp
+++ b/include/openPMD/backend/MeshRecordComponent.hpp
@@ -43,7 +43,8 @@ class MeshRecordComponent
     friend class BaseRecord;
     template <typename, typename>
     friend class internal::BaseRecordData;
-    friend class internal::ScientificDefaults<MeshRecordComponent>;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     friend class Mesh;
 
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index ab1e07b203..b130435268 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -2,12 +2,14 @@
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Mesh.hpp"
 #include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/Record.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include <iostream>
+#include <typeinfo>
 #include <utility>
 
 namespace openPMD::internal
@@ -132,15 +134,33 @@ void ScientificDefaults<Child>::finalize(Access at)
     if constexpr (IsContainer_v<Child>)
     {
         using Container_t = AsContainer_t<Child>;
-        using value_t = typename Container_t::value_type;
-        if constexpr (HasScientificDefaults_v<value_t>)
+        using mapped_type = typename Container_t::mapped_type;
+        if constexpr (HasScientificDefaults_v<mapped_type>)
         {
-            for (auto &[_, right] : *this)
+            // std::cout << "Iterate children" << std::endl;
+            for (auto &[_, right] : asChild())
             {
                 (void)_;
-                right.ScientificDefaults<value_t>::finalize(at);
+                right.ScientificDefaults<mapped_type>::finalize(at);
             }
         }
+        // else
+        // {
+        //     std::cout << "Child type has no defaults tho ("
+        //               << typeid(mapped_type).name() << ")" << std::endl;
+        // }
+    }
+    // else
+    // {
+    //     std::cout << "Not a container type tho" << std::endl;
+    // }
+
+    if constexpr (std::is_same_v<Child, ParticleSpecies>)
+    {
+        for (auto &[_, right] : asChild().particlePatches)
+        {
+            right.finalize(at);
+        }
     }
 }
 
@@ -222,6 +242,12 @@ void ScientificDefaults<Child>::addDefaults()
 
         addParentDefaults<BaseRecord<MeshRecordComponent>>();
     }
+    else if constexpr (std::is_same_v<Child, Record>)
+    {
+        addDefaultFor("timeOffset", 0.f, &Record::setTimeOffset);
+
+        addParentDefaults<BaseRecord<RecordComponent>>();
+    }
     else if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
     {
         addDefaultFor<unit_representations::AsArray const &>(
@@ -233,5 +259,6 @@ template class ScientificDefaults<Iteration>;
 template class ScientificDefaults<Mesh>;
 template class ScientificDefaults<MeshRecordComponent>;
 template class ScientificDefaults<ParticleSpecies>;
+template class ScientificDefaults<Record>;
 template class ScientificDefaults<BaseRecord<MeshRecordComponent>>;
 } // namespace openPMD::internal
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index eae22ec0b3..a59d5eea2f 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -663,13 +663,15 @@ TEST_CASE("particleSpecies_modification_test", "[core]")
     REQUIRE(0 == patches.numAttributes());
     auto &offset = patches["offset"];
     REQUIRE(0 == offset.size());
-    REQUIRE(1 == offset.numAttributes()); // unitDimension
-    std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
-    REQUIRE(zeros == offset.unitDimension());
 
     auto &off_x = offset["x"];
     off_x.resetDataset(dset);
+
+    o.iterations[42].close();
+    REQUIRE(1 == offset.numAttributes()); // unitDimension
     REQUIRE(1 == off_x.unitSI());
+    std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
+    REQUIRE(zeros == offset.unitDimension());
 }
 
 TEST_CASE("record_constructor_test", "[core]")

From a7b265b6305713632707098361d412790c8df9d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 12 Jan 2026 22:28:10 +0100
Subject: [PATCH 07/22] Fixes

---
 src/Mesh.cpp | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index 9f6c46a9a6..111394b907 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -256,7 +256,9 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{0};
         unit_representations::auxiliary::fromMapOfUnitDimension(
             tmpUnitDimension.data(), udim);
         setAttribute("unitDimension", tmpUnitDimension);
@@ -272,15 +274,20 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsArray const &udim)
 
 Mesh &Mesh::setGridUnitDimension(unit_representations::AsMaps const &udims)
 {
-    auto rawGridUnitDimension = [this]() {
-        try
+    auto rawGridUnitDimension = [&udims, this]() {
+        if (!this->contains("gridUnitDimension"))
         {
-            return this->getAttribute("gridUnitDimension")
-                .get<std::vector<double>>();
+            std::vector<double> res(udims.size() * 7);
+            for (size_t i = 0; i < udims.size(); ++i)
+            {
+                res[7 * i] = 1;
+            }
+            return res;
         }
-        catch (no_such_attribute_error const &)
+        else
         {
-            return std::vector<double>();
+            return this->getAttribute("gridUnitDimension")
+                .get<std::vector<double>>();
         }
     }();
     rawGridUnitDimension.resize(7 * udims.size());

From 9e1070c75bc39e205a3e475ad7959a57e63706df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 13 Jan 2026 12:45:43 +0100
Subject: [PATCH 08/22] Further fixes

---
 src/ParticleSpecies.cpp     | 10 ++--------
 src/Record.cpp              |  4 +++-
 src/backend/PatchRecord.cpp |  4 +++-
 3 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/ParticleSpecies.cpp b/src/ParticleSpecies.cpp
index b3e7ea1f7e..155a69c88e 100644
--- a/src/ParticleSpecies.cpp
+++ b/src/ParticleSpecies.cpp
@@ -175,15 +175,12 @@ void ParticleSpecies::flush(
             record.second.flush(record.first, flushParams);
         for (auto &patch : particlePatches)
             patch.second.flush(patch.first, flushParams);
-        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-        {
-            particlePatches.setDirty(false);
-        }
     }
     else
     {
         if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
         {
+            // Should we defer this ScientificDefaults?
             auto it = find("position");
             if (it != end())
                 it->second.setUnitDimension({{UnitDimension::L, 1}});
@@ -203,13 +200,10 @@ void ParticleSpecies::flush(
             for (auto &patch : particlePatches)
                 patch.second.flush(patch.first, flushParams);
         }
-        else
-        {
-            particlePatches.setDirty(false);
-        }
     }
     if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
     {
+        particlePatches.setDirty(false);
         setDirty(false);
     }
 }
diff --git a/src/Record.cpp b/src/Record.cpp
index 8056718edd..88a20b3c98 100644
--- a/src/Record.cpp
+++ b/src/Record.cpp
@@ -38,7 +38,9 @@ Record &Record::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{};
         for (auto const &entry : udim)
             tmpUnitDimension[static_cast<uint8_t>(entry.first)] = entry.second;
         setAttribute("unitDimension", tmpUnitDimension);
diff --git a/src/backend/PatchRecord.cpp b/src/backend/PatchRecord.cpp
index 3080523d24..64088e7f6a 100644
--- a/src/backend/PatchRecord.cpp
+++ b/src/backend/PatchRecord.cpp
@@ -30,7 +30,9 @@ PatchRecord::setUnitDimension(std::map<UnitDimension, double> const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{};
         for (auto const &entry : udim)
             tmpUnitDimension[static_cast<uint8_t>(entry.first)] = entry.second;
         setAttribute("unitDimension", tmpUnitDimension);

From bfcdb119110c10941ac8677069c8033764806a8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 13 Jan 2026 13:34:01 +0100
Subject: [PATCH 09/22] further fixes

---
 src/Record.cpp                     |  5 +----
 src/backend/ScientificDefaults.cpp |  6 ++++++
 test/CoreTest.cpp                  | 25 +++++++++++++++++--------
 3 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/src/Record.cpp b/src/Record.cpp
index 88a20b3c98..cf8493a327 100644
--- a/src/Record.cpp
+++ b/src/Record.cpp
@@ -29,10 +29,7 @@
 
 namespace openPMD
 {
-Record::Record()
-{
-    setTimeOffset(0.f);
-}
+Record::Record() = default;
 
 Record &Record::setUnitDimension(unit_representations::AsMap const &udim)
 {
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index b130435268..547978b4f0 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -8,6 +8,8 @@
 #include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/backend/PatchRecord.hpp"
+#include "openPMD/backend/PatchRecordComponent.hpp"
 #include <iostream>
 #include <typeinfo>
 #include <utility>
@@ -248,6 +250,10 @@ void ScientificDefaults<Child>::addDefaults()
 
         addParentDefaults<BaseRecord<RecordComponent>>();
     }
+    else if constexpr (std::is_same_v<Child, PatchRecord>)
+    {
+        addParentDefaults<BaseRecord<PatchRecordComponent>>();
+    }
     else if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
     {
         addDefaultFor<unit_representations::AsArray const &>(
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index a59d5eea2f..bfc98939a0 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -691,11 +691,16 @@ TEST_CASE("record_constructor_test", "[core]")
     REQUIRE(r["y"].resetDataset(dset).numAttributes() == 0); /* unitSI */
     // REQUIRE(r["z"].unitSI() == 1);
     REQUIRE(r["z"].resetDataset(dset).numAttributes() == 0); /* unitSI */
+    REQUIRE(r.numAttributes() == 0);
+    // TODO: unitSI
+    // REQUIRE(r["x"].numAttributes() == 0);
+    // REQUIRE(r["y"].numAttributes() == 0);
+    // REQUIRE(r["z"].numAttributes() == 0);
+    o.iterations[42].close();
     std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
     REQUIRE(r.unitDimension() == zeros);
     REQUIRE(r.timeOffset<float>() == static_cast<float>(0));
     REQUIRE(r.numAttributes() == 2); /* timeOffset, unitDimension */
-    o.flush();
     REQUIRE(r["x"].unitSI() == 1);
     REQUIRE(r["y"].unitSI() == 1);
     REQUIRE(r["z"].unitSI() == 1);
@@ -777,10 +782,11 @@ TEST_CASE("mesh_constructor_test", "[core]")
     REQUIRE(m.gridSpacing<double>() == gs);
     std::vector<double> ggo{0};
     REQUIRE(m.gridGlobalOffset() == ggo);
+    auxiliary::write_vec_to_stream(std::cout, m.attributes()) << std::endl;
     REQUIRE(
         m.numAttributes() ==
-        7); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
-               timeOffset, unitDimension */
+        8); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
+               timeOffset, unitDimension, gridUnitSI */
 
     REQUIRE(m["x"].unitSI() == 1);
     REQUIRE(m["x"].numAttributes() == 2); /* unitSI, position */
@@ -802,24 +808,27 @@ TEST_CASE("mesh_modification_test", "[core]")
     m["y"].resetDataset(globalDataset);
     m["z"].resetDataset(globalDataset);
 
+    o.iterations[42].close(); // trigger writing for defaults
+    o.iterations[42].open();
+
     m.setGeometry(Mesh::Geometry::spherical);
     REQUIRE(m.geometry() == Mesh::Geometry::spherical);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     m.setDataOrder(Mesh::DataOrder::F);
     REQUIRE(m.dataOrder() == Mesh::DataOrder::F);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<std::string> al{"z_", "y_", "x_"};
     m.setAxisLabels({"z_", "y_", "x_"});
     REQUIRE(m.axisLabels() == al);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<double> gs{1e-5, 2e-5, 3e-5};
     m.setGridSpacing(gs);
     REQUIRE(m.gridSpacing<double>() == gs);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<double> ggo{1e-10, 2e-10, 3e-10};
     m.setGridGlobalOffset({1e-10, 2e-10, 3e-10});
     REQUIRE(m.gridGlobalOffset() == ggo);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     m.setGridUnitSI(42.0);
     REQUIRE(m.gridUnitSI() == static_cast<double>(42));
     REQUIRE(m.numAttributes() == 8);

From fe005ec5fa99feec32a8cd661c1c5677d90bfee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 13 Jan 2026 13:47:45 +0100
Subject: [PATCH 10/22] tests temporarily passing :D

---
 src/Mesh.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index 111394b907..bf7952911a 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -275,13 +275,13 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsArray const &udim)
 Mesh &Mesh::setGridUnitDimension(unit_representations::AsMaps const &udims)
 {
     auto rawGridUnitDimension = [&udims, this]() {
-        if (!this->contains("gridUnitDimension"))
+        if (!this->containsAttribute("gridUnitDimension"))
         {
             std::vector<double> res(udims.size() * 7);
-            for (size_t i = 0; i < udims.size(); ++i)
-            {
-                res[7 * i] = 1;
-            }
+            // for (size_t i = 0; i < udims.size(); ++i)
+            // {
+            //     res[7 * i] = 1;
+            // }
             return res;
         }
         else

From 2970deb36a368b01624251f82865b8f315115f15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 13 Jan 2026 14:04:14 +0100
Subject: [PATCH 11/22] Cleanup

---
 include/openPMD/backend/BaseRecord.hpp        |  2 -
 .../openPMD/backend/ScientificDefaults.hpp    |  6 ++-
 src/backend/ScientificDefaults.cpp            | 42 +++----------------
 test/CoreTest.cpp                             |  4 --
 4 files changed, 10 insertions(+), 44 deletions(-)

diff --git a/include/openPMD/backend/BaseRecord.hpp b/include/openPMD/backend/BaseRecord.hpp
index daca050740..90862f97fd 100644
--- a/include/openPMD/backend/BaseRecord.hpp
+++ b/include/openPMD/backend/BaseRecord.hpp
@@ -166,8 +166,6 @@ namespace internal
     };
 } // namespace internal
 
-class Mesh;
-
 /**
  * @brief Base class for any type of record (e.g. mesh or particle record).
  *
diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
index fba37397f6..8a0eca2def 100644
--- a/include/openPMD/backend/ScientificDefaults.hpp
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -46,6 +46,9 @@ class ScientificDefaults
     template <typename F, typename... Args>
     void addDefaultFor_resolveValue(char const *key, F &&get_value, Args &&...);
 
+    // These two below overloads exist only for type inference purposes
+    // Apart from this, they just forward their arguments to
+    // addDefaultFor_resolveValue
     template <typename Setter = void, typename F>
     void addDefaultFor(
         char const *key,
@@ -60,8 +63,7 @@ class ScientificDefaults
 
     template <typename Parent>
     void addParentDefaults();
-    // template<typename F>
-    // void addDefaultFor(char const *key, F&& get_value);
+
 protected:
     void finalize(Access);
     void addDefaults();
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index 547978b4f0..4e76cd1557 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -1,4 +1,5 @@
 #include "openPMD/backend/ScientificDefaults.hpp"
+
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Mesh.hpp"
 #include "openPMD/ParticleSpecies.hpp"
@@ -10,8 +11,8 @@
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include "openPMD/backend/PatchRecord.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
+
 #include <iostream>
-#include <typeinfo>
 #include <utility>
 
 namespace openPMD::internal
@@ -105,26 +106,6 @@ void ScientificDefaults<Child>::addParentDefaults()
 {
     asChild().ScientificDefaults<Parent>::addDefaults();
 }
-// template <typename Child>
-// template <typename F>
-// void ScientificDefaults<Child>::addDefaultFor(char const *key, F &&get_value)
-// {
-//     if (asChild().containsAttribute(key))
-//     {
-//         return;
-//     }
-//     auto value = [&]() {
-//         if constexpr (detail::IsCallable_v<F>)
-//         {
-//             return get_value();
-//         }
-//         else
-//         {
-//             return get_value;
-//         }
-//     }();
-//     asChild().setAttribute(key, std::move(value));
-// }
 
 template <typename Child>
 void ScientificDefaults<Child>::finalize(Access at)
@@ -139,23 +120,13 @@ void ScientificDefaults<Child>::finalize(Access at)
         using mapped_type = typename Container_t::mapped_type;
         if constexpr (HasScientificDefaults_v<mapped_type>)
         {
-            // std::cout << "Iterate children" << std::endl;
             for (auto &[_, right] : asChild())
             {
                 (void)_;
                 right.ScientificDefaults<mapped_type>::finalize(at);
             }
         }
-        // else
-        // {
-        //     std::cout << "Child type has no defaults tho ("
-        //               << typeid(mapped_type).name() << ")" << std::endl;
-        // }
     }
-    // else
-    // {
-    //     std::cout << "Not a container type tho" << std::endl;
-    // }
 
     if constexpr (std::is_same_v<Child, ParticleSpecies>)
     {
@@ -175,8 +146,6 @@ void ScientificDefaults<Child>::addDefaults()
     if constexpr (std::is_same_v<Child, Mesh>)
     {
         auto dimensionality = asChild().retrieveDimensionality();
-        // std::cout << "Dimensionality is " << dimensionality << " for '"
-        //           << asChild().myPath().openPMDPath() << "'" << std::endl;
 
         addDefaultFor("timeOffset", 0.f, &Mesh::setTimeOffset);
         addDefaultFor(
@@ -193,9 +162,10 @@ void ScientificDefaults<Child>::addDefaults()
                     return {"x", "y"};
                 case 3:
                     return {"x", "y", "z"};
-                default: {
+                default:
                     if (dimensionality < 100)
                     {
+                        // x1, x2, x3, x4, ...
                         std::vector<std::string> res;
                         res.reserve(dimensionality);
                         for (uint64_t i = 0; i < dimensionality; ++i)
@@ -208,10 +178,10 @@ void ScientificDefaults<Child>::addDefaults()
                     {
                         return {
                             "Please verify dimensionality. Was inferred as '" +
-                            std::to_string(dimensionality) + "'."};
+                            std::to_string(dimensionality) +
+                            "'. Seems a bit much."};
                     }
                 }
-                }
                 return std::vector<std::string>{"x", "y", "z"};
             },
             &Mesh::setAxisLabels);
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index bfc98939a0..eaa7771329 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -767,10 +767,6 @@ TEST_CASE("mesh_constructor_test", "[core]")
     REQUIRE(m["y"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["z"].resetDataset(globalDataset).numAttributes() == 0);
 
-    for (auto const &attr : m.attributes())
-    {
-        std::cout << "Attribute: " << attr << std::endl;
-    }
     REQUIRE(m.numAttributes() == 0);
     o.iterations[42].close();
 

From e4e5b0aa62df94dffe977342d59af5ad376ea628 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 13 Jan 2026 18:50:43 +0100
Subject: [PATCH 12/22] UnitDimension for position/positionOffset

---
 include/openPMD/backend/Writable.hpp |  4 ++++
 src/ParticleSpecies.cpp              | 11 -----------
 src/backend/ScientificDefaults.cpp   | 18 ++++++++++++++++++
 3 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/include/openPMD/backend/Writable.hpp b/include/openPMD/backend/Writable.hpp
index 0396aa1f93..b36c299b4d 100644
--- a/include/openPMD/backend/Writable.hpp
+++ b/include/openPMD/backend/Writable.hpp
@@ -51,6 +51,8 @@ namespace internal
     class SharedAttributableData;
     class AttributableData;
     class SeriesData;
+    template <typename>
+    class ScientificDefaults;
 } // namespace internal
 namespace detail
 {
@@ -106,6 +108,8 @@ class Writable final
     friend void debug::printDirty(Series const &);
     friend struct Parameter<Operation::CREATE_DATASET>;
     friend struct Parameter<Operation::OPEN_DATASET>;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 private:
     Writable(internal::AttributableData *);
diff --git a/src/ParticleSpecies.cpp b/src/ParticleSpecies.cpp
index 155a69c88e..b77258c461 100644
--- a/src/ParticleSpecies.cpp
+++ b/src/ParticleSpecies.cpp
@@ -178,17 +178,6 @@ void ParticleSpecies::flush(
     }
     else
     {
-        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-        {
-            // Should we defer this ScientificDefaults?
-            auto it = find("position");
-            if (it != end())
-                it->second.setUnitDimension({{UnitDimension::L, 1}});
-            it = find("positionOffset");
-            if (it != end())
-                it->second.setUnitDimension({{UnitDimension::L, 1}});
-        }
-
         Container<Record>::flush(path, flushParams);
 
         for (auto &record : *this)
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index 4e76cd1557..e21535fc1c 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -11,6 +11,7 @@
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include "openPMD/backend/PatchRecord.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/Writable.hpp"
 
 #include <iostream>
 #include <utility>
@@ -71,6 +72,12 @@ void ScientificDefaults<Child>::addDefaultFor_resolveValue(
         {
             auxiliary::write_vec_to_stream(std::cout, value);
         }
+        else if constexpr (std::is_same_v<
+                               std::remove_reference_t<decltype(value)>,
+                               unit_representations::AsMap>)
+        {
+            std::cout << "Unit_Map";
+        }
         else
         {
             std::cout << value;
@@ -217,6 +224,17 @@ void ScientificDefaults<Child>::addDefaults()
     else if constexpr (std::is_same_v<Child, Record>)
     {
         addDefaultFor("timeOffset", 0.f, &Record::setTimeOffset);
+        auto const &keyInParent = asChild().writable().ownKeyWithinParent;
+
+        if (keyInParent == "position" || keyInParent == "positionOffset")
+        {
+            addDefaultFor<unit_representations::AsMap const &>(
+                "unitDimension",
+                []() {
+                    return unit_representations::AsMap{{UnitDimension::L, 1.0}};
+                },
+                &Record::setUnitDimension);
+        }
 
         addParentDefaults<BaseRecord<RecordComponent>>();
     }

From 54dc7789781c56be1c54d1ab77c691e6be148c40 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 13 Jan 2026 19:11:59 +0100
Subject: [PATCH 13/22] WIP: RecordComponent stuff

---
 include/openPMD/RecordComponent.hpp           |  7 +++-
 .../openPMD/backend/PatchRecordComponent.hpp  |  7 +++-
 src/RecordComponent.cpp                       |  4 ---
 src/backend/MeshRecordComponent.cpp           |  5 ---
 src/backend/ScientificDefaults.cpp            | 33 ++++++++++++++++++-
 5 files changed, 44 insertions(+), 12 deletions(-)

diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp
index d06b4213f4..3d62d476c3 100644
--- a/include/openPMD/RecordComponent.hpp
+++ b/include/openPMD/RecordComponent.hpp
@@ -27,6 +27,7 @@
 #include "openPMD/auxiliary/UniquePtr.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 // comment to prevent this include from being moved by clang-format
 #include "openPMD/DatatypeMacros.hpp"
@@ -110,7 +111,9 @@ namespace internal
 template <typename>
 class BaseRecord;
 
-class RecordComponent : public BaseRecordComponent
+class RecordComponent
+    : public BaseRecordComponent
+    , internal::ScientificDefaults<RecordComponent>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -128,6 +131,8 @@ class RecordComponent : public BaseRecordComponent
     friend class MeshRecordComponent;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     enum class Allocation
diff --git a/include/openPMD/backend/PatchRecordComponent.hpp b/include/openPMD/backend/PatchRecordComponent.hpp
index 63c8b34f92..b448f13e08 100644
--- a/include/openPMD/backend/PatchRecordComponent.hpp
+++ b/include/openPMD/backend/PatchRecordComponent.hpp
@@ -24,6 +24,7 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/auxiliary/ShareRawInternal.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <memory>
 #include <sstream>
@@ -42,7 +43,9 @@ namespace openPMD
 /**
  * @todo add support for constant patch record components
  */
-class PatchRecordComponent : public RecordComponent
+class PatchRecordComponent
+    : public RecordComponent
+    , internal::ScientificDefaults<PatchRecordComponent>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -53,6 +56,8 @@ class PatchRecordComponent : public RecordComponent
     friend class ParticlePatches;
     friend class PatchRecord;
     friend class ParticleSpecies;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     /**
diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp
index eb41dddd19..207affe31a 100644
--- a/src/RecordComponent.cpp
+++ b/src/RecordComponent.cpp
@@ -415,10 +415,6 @@ void RecordComponent::flush(
                     "RecordComponent::resetDataset()).");
             }
         }
-        if (!containsAttribute("unitSI"))
-        {
-            setUnitSI(1);
-        }
         auto constant_component_write_shape = [&]() {
             auto extent = getExtent();
             return !Dataset::undefinedExtent(extent) &&
diff --git a/src/backend/MeshRecordComponent.cpp b/src/backend/MeshRecordComponent.cpp
index 8298a8abbd..c07a0cb62f 100644
--- a/src/backend/MeshRecordComponent.cpp
+++ b/src/backend/MeshRecordComponent.cpp
@@ -76,11 +76,6 @@ void MeshRecordComponent::flush(
     {
         return;
     }
-    if (access::write(IOHandler()->m_frontendAccess) &&
-        !containsAttribute("position"))
-    {
-        setPosition(std::vector<double>{0});
-    }
     RecordComponent::flush(name, params);
 }
 
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index e21535fc1c..c3bd59bc62 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -139,7 +139,9 @@ void ScientificDefaults<Child>::finalize(Access at)
     {
         for (auto &[_, right] : asChild().particlePatches)
         {
-            right.finalize(at);
+            right
+                .ScientificDefaults<BaseRecord<PatchRecordComponent>>::finalize(
+                    at);
         }
     }
 }
@@ -247,11 +249,40 @@ void ScientificDefaults<Child>::addDefaults()
         addDefaultFor<unit_representations::AsArray const &>(
             "unitDimension", unit_representations::AsArray{});
     }
+    else if constexpr (std::is_same_v<Child, RecordComponent>)
+    {
+        addDefaultFor("unitSI", 1.0, &RecordComponent::setUnitSI);
+    }
+    else if constexpr (std::is_same_v<Child, MeshRecordComponent>)
+    {
+        // position
+        auto dimensionality = asChild().getDimensionality();
+        addDefaultFor(
+            "position",
+            [&]() {
+                if (dimensionality < 100)
+                {
+                    return std::vector<double>(dimensionality, 0.5);
+                }
+                else
+                {
+                    return std::vector<double>{0.0};
+                }
+            },
+            &MeshRecordComponent::setPosition);
+        addParentDefaults<RecordComponent>();
+    }
+    else if constexpr (std::is_same_v<Child, PatchRecordComponent>)
+    {
+        addParentDefaults<RecordComponent>();
+    }
 }
 
 template class ScientificDefaults<Iteration>;
 template class ScientificDefaults<Mesh>;
 template class ScientificDefaults<MeshRecordComponent>;
+template class ScientificDefaults<RecordComponent>;
+template class ScientificDefaults<PatchRecordComponent>;
 template class ScientificDefaults<ParticleSpecies>;
 template class ScientificDefaults<Record>;
 template class ScientificDefaults<BaseRecord<MeshRecordComponent>>;

From f9ba472406702029153e95134ab879c2982c0c92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Wed, 14 Jan 2026 11:30:23 +0100
Subject: [PATCH 14/22] Fix coretests

---
 test/CoreTest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index eaa7771329..f1c758d877 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -761,7 +761,7 @@ TEST_CASE("mesh_constructor_test", "[core]")
 
     Mesh &m = o.iterations[42].meshes["E"];
 
-    std::vector<double> pos{0};
+    std::vector<double> pos{0.5};
     /* unitSI and position are set to default values upon closing */
     REQUIRE(m["x"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["y"].resetDataset(globalDataset).numAttributes() == 0);

From 55e9dbf141224aecdba4935d6f6b6a9ac99285a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Wed, 14 Jan 2026 11:36:54 +0100
Subject: [PATCH 15/22] Clean up Iteration finalizing logic

---
 include/openPMD/Mesh.hpp            |  3 ++-
 include/openPMD/ParticleSpecies.hpp |  3 ++-
 src/Iteration.cpp                   | 12 ++----------
 src/backend/ScientificDefaults.cpp  | 17 ++++++++++++++++-
 4 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/include/openPMD/Mesh.hpp b/include/openPMD/Mesh.hpp
index 279db4fdbb..4ff5d3749d 100644
--- a/include/openPMD/Mesh.hpp
+++ b/include/openPMD/Mesh.hpp
@@ -45,7 +45,8 @@ class Mesh
 {
     friend class Container<Mesh>;
     friend class Iteration;
-    friend class internal::ScientificDefaults<Mesh>;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     Mesh(Mesh const &) = default;
diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp
index 8c8b187afb..075d5bb8cd 100644
--- a/include/openPMD/ParticleSpecies.hpp
+++ b/include/openPMD/ParticleSpecies.hpp
@@ -40,7 +40,8 @@ class ParticleSpecies
     friend class Iteration;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
-    friend class internal::ScientificDefaults<ParticleSpecies>;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     ParticlePatches particlePatches;
diff --git a/src/Iteration.cpp b/src/Iteration.cpp
index 92de30fea7..287a8ab292 100644
--- a/src/Iteration.cpp
+++ b/src/Iteration.cpp
@@ -113,20 +113,12 @@ Iteration &Iteration::close(bool _flush)
         // yet keeps it re-openable)
         break;
     }
+
     {
         Access at = IOHandler()->m_frontendAccess;
         finalize(at);
-        for (auto &[_, mesh] : meshes)
-        {
-            (void)_;
-            mesh.internal::ScientificDefaults<Mesh>::finalize(at);
-        }
-        for (auto &[_, ps] : particles)
-        {
-            (void)_;
-            ps.finalize(at);
-        }
     }
+
     if (_flush)
     {
         if (flag == StepStatus::DuringStep)
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index c3bd59bc62..52956694a6 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -134,11 +134,26 @@ void ScientificDefaults<Child>::finalize(Access at)
             }
         }
     }
+    // sic! no else
 
-    if constexpr (std::is_same_v<Child, ParticleSpecies>)
+    if constexpr (std::is_same_v<Child, Iteration>)
+    {
+        for (auto &[_, right] : asChild().meshes)
+        {
+            (void)_;
+            right.ScientificDefaults<Mesh>::finalize(at);
+        }
+        for (auto &[_, right] : asChild().particles)
+        {
+            (void)_;
+            right.ScientificDefaults<ParticleSpecies>::finalize(at);
+        }
+    }
+    else if constexpr (std::is_same_v<Child, ParticleSpecies>)
     {
         for (auto &[_, right] : asChild().particlePatches)
         {
+            (void)_;
             right
                 .ScientificDefaults<BaseRecord<PatchRecordComponent>>::finalize(
                     at);

From baaa1d53ac5ba616b07478f2dc438d0b7799953a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Wed, 14 Jan 2026 11:51:58 +0100
Subject: [PATCH 16/22] Add defaults for Iteration class

---
 src/Iteration.cpp                  |  3 ---
 src/backend/ScientificDefaults.cpp | 10 +++++++++-
 test/CoreTest.cpp                  |  3 +++
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/Iteration.cpp b/src/Iteration.cpp
index 287a8ab292..438a33f974 100644
--- a/src/Iteration.cpp
+++ b/src/Iteration.cpp
@@ -53,9 +53,6 @@ using internal::DeferredParseAccess;
 Iteration::Iteration() : Attributable(NoInit())
 {
     setData(std::make_shared<Data_t>());
-    setTime(static_cast<double>(0));
-    setDt(static_cast<double>(1));
-    setTimeUnitSI(1);
     meshes.writable().ownKeyWithinParent = "meshes";
     particles.writable().ownKeyWithinParent = "particles";
 }
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index 52956694a6..172276c148 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -64,6 +64,8 @@ void ScientificDefaults<Child>::addDefaultFor_resolveValue(
             return get_value;
         }
     }();
+    constexpr bool debug = true;
+    if constexpr (debug)
     {
         std::cout << "\tInitializing default for '" << key << "' = '";
         if constexpr (
@@ -167,7 +169,13 @@ void ScientificDefaults<Child>::addDefaults()
     std::cout << "Adding defaults for '" << asChild().myPath().openPMDPath()
               << "'" << std::endl;
 
-    if constexpr (std::is_same_v<Child, Mesh>)
+    if constexpr (std::is_same_v<Child, Iteration>)
+    {
+        addDefaultFor("time", 0., &Iteration::setTime);
+        addDefaultFor("dt", 1., &Iteration::setDt);
+        addDefaultFor("timeUnitSI", 1.0, &Iteration::setTimeUnitSI);
+    }
+    else if constexpr (std::is_same_v<Child, Mesh>)
     {
         auto dimensionality = asChild().retrieveDimensionality();
 
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index f1c758d877..e12b06b52f 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -618,6 +618,9 @@ TEST_CASE("iteration_default_test", "[core]")
 
     Iteration &i = o.iterations[42];
 
+    REQUIRE(i.numAttributes() == 0);
+
+    i.close();
     REQUIRE(i.time<double>() == static_cast<double>(0));
     REQUIRE(i.dt<double>() == static_cast<double>(1));
     REQUIRE(i.timeUnitSI() == static_cast<double>(1));

From fecdae298bf1717ef40d6c10777bbb33c4d56a95 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Thu, 15 Jan 2026 11:37:09 +0100
Subject: [PATCH 17/22] Fix variadic template template parameters

heh
---
 include/openPMD/auxiliary/TypeTraits.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/openPMD/auxiliary/TypeTraits.hpp b/include/openPMD/auxiliary/TypeTraits.hpp
index 05a0033cbe..150875d92e 100644
--- a/include/openPMD/auxiliary/TypeTraits.hpp
+++ b/include/openPMD/auxiliary/TypeTraits.hpp
@@ -208,7 +208,7 @@ namespace detail
     auto infer_template_args(Base<Args...> &) -> Base<Args...>;
 
     template <
-        template <typename> class Base,
+        template <typename...> class Base,
         typename T,
         typename SFINAE = void>
     struct IsTemplateBaseOf
@@ -216,7 +216,7 @@ namespace detail
         static constexpr bool value = false;
     };
 
-    template <template <typename> class Base, typename T>
+    template <template <typename...> class Base, typename T>
     struct IsTemplateBaseOf<
         Base,
         T,
@@ -229,8 +229,8 @@ namespace detail
     };
 } // namespace detail
 
-template <template <typename> class Base, typename T>
+template <template <typename...> class Base, typename T>
 constexpr bool IsTemplateBaseOf_v = detail::IsTemplateBaseOf<Base, T>::value;
-template <template <typename> class Base, typename T>
+template <template <typename...> class Base, typename T>
 using AsTemplateBase_t = typename detail::IsTemplateBaseOf<Base, T>::type;
 } // namespace openPMD::auxiliary

From af0d1a93edfd031193e2878f5815749b82f5e7e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Thu, 15 Jan 2026 12:07:26 +0100
Subject: [PATCH 18/22] Factor this out: Fix deletion

---
 src/IO/AbstractIOHandlerImpl.cpp | 10 ++++++++--
 src/backend/BaseRecord.cpp       |  8 +-------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/IO/AbstractIOHandlerImpl.cpp b/src/IO/AbstractIOHandlerImpl.cpp
index ec16ae4c1b..4f93ff1a5b 100644
--- a/src/IO/AbstractIOHandlerImpl.cpp
+++ b/src/IO/AbstractIOHandlerImpl.cpp
@@ -235,7 +235,12 @@ std::future<void> AbstractIOHandlerImpl::flush()
                 auto &parameter = deref_dynamic_cast<Parameter<O::DELETE_PATH>>(
                     i.parameter.get());
                 writeToStderr(
-                    "[", i.writable->parent, "->", i.writable, "] DELETE_PATH");
+                    "[",
+                    i.writable->parent,
+                    "->",
+                    i.writable,
+                    "] DELETE_PATH: ",
+                    parameter.path);
                 deletePath(i.writable, parameter);
                 break;
             }
@@ -248,7 +253,8 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     i.writable->parent,
                     "->",
                     i.writable,
-                    "] DELETE_DATASET");
+                    "] DELETE_DATASET: ",
+                    parameter.name);
                 deleteDataset(i.writable, parameter);
                 break;
             }
diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp
index 07b27902d2..23523818f1 100644
--- a/src/backend/BaseRecord.cpp
+++ b/src/backend/BaseRecord.cpp
@@ -472,7 +472,7 @@ auto BaseRecord<T_elem>::erase(key_type const &key) -> size_type
 {
     bool const keyScalar = (key == RecordComponent::SCALAR);
     size_type res;
-    if (!keyScalar || (keyScalar && this->at(key).constant()))
+    if (!keyScalar)
         res = Container<T_elem>::erase(key);
     else
     {
@@ -480,12 +480,6 @@ auto BaseRecord<T_elem>::erase(key_type const &key) -> size_type
         eraseScalar();
     }
 
-    if (keyScalar)
-    {
-        this->setWritten(false, Attributable::EnqueueAsynchronously::No);
-        this->writable().abstractFilePosition.reset();
-        this->get().m_datasetDefined = false;
-    }
     return res;
 }
 

From 2115edebe61a680eb78ceb8b4575372975fb1e23 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Fri, 16 Jan 2026 14:59:23 +0100
Subject: [PATCH 19/22] Remove flush-time check for populized components

Moved to finalize(), degraded to warning
---
 src/backend/BaseRecord.cpp         |  8 ++++----
 src/backend/ScientificDefaults.cpp | 28 +++++++++++++++++++++++-----
 test/CoreTest.cpp                  | 14 ++++++--------
 3 files changed, 33 insertions(+), 17 deletions(-)

diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp
index 23523818f1..858a437cf5 100644
--- a/src/backend/BaseRecord.cpp
+++ b/src/backend/BaseRecord.cpp
@@ -813,10 +813,10 @@ inline void BaseRecord<T_elem>::flush(
     }
 
     if (!this->written() && this->empty() && !this->datasetDefined())
-        throw std::runtime_error(
-            "A Record can not be written without any contained "
-            "RecordComponents: " +
-            name);
+        // Verify upon ScientificDefaults::finalize() that the Record has been
+        // populized. For now, we will assume that data will come later; ignore
+        // this Record at the moment.
+        return;
 
     /*
      * Defensive programming. Normally, this error should yield as soon as
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index 172276c148..c2202611e5 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -169,6 +169,24 @@ void ScientificDefaults<Child>::addDefaults()
     std::cout << "Adding defaults for '" << asChild().myPath().openPMDPath()
               << "'" << std::endl;
 
+    // First some verifications
+    if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
+    {
+        if (asChild().empty() && !asChild().datasetDefined())
+        {
+            std::cerr
+                << "Cannot flush Record without any contained components: '"
+                << asChild().myPath().openPMDPath() << "'. Will ignore.";
+            if (asChild().written())
+            {
+                std::cerr << "\n(Note: The Record seems to have been written "
+                             "previously?)";
+            }
+            std::cerr << std::endl;
+            return;
+        }
+    }
+
     if constexpr (std::is_same_v<Child, Iteration>)
     {
         addDefaultFor("time", 0., &Iteration::setTime);
@@ -267,11 +285,6 @@ void ScientificDefaults<Child>::addDefaults()
     {
         addParentDefaults<BaseRecord<PatchRecordComponent>>();
     }
-    else if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
-    {
-        addDefaultFor<unit_representations::AsArray const &>(
-            "unitDimension", unit_representations::AsArray{});
-    }
     else if constexpr (std::is_same_v<Child, RecordComponent>)
     {
         addDefaultFor("unitSI", 1.0, &RecordComponent::setUnitSI);
@@ -299,6 +312,11 @@ void ScientificDefaults<Child>::addDefaults()
     {
         addParentDefaults<RecordComponent>();
     }
+    else if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
+    {
+        addDefaultFor<unit_representations::AsArray const &>(
+            "unitDimension", unit_representations::AsArray{});
+    }
 }
 
 template class ScientificDefaults<Iteration>;
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index e12b06b52f..d23437ae8e 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -1299,16 +1299,14 @@ TEST_CASE("empty_record_test", "[core]")
 
     o.iterations[1].meshes["E"].setComment(
         "No assumption about contained RecordComponents will be made");
-    REQUIRE_THROWS_WITH(
-        o.flush(),
-        Catch::Equals(
-            "A Record can not be written without any contained "
-            "RecordComponents: E"));
-    o.iterations[1].meshes["E"][RecordComponent::SCALAR].resetDataset(
-        Dataset(Datatype::DOUBLE, {1}));
     auto B = o.iterations[1].meshes["B"];
     B.resetDataset(Dataset(Datatype::DOUBLE, {1}));
-    o.flush();
+    auto sneakily_keep_meshes_alive = o.iterations[1].meshes;
+    o.close();
+#if openPMD_USE_INVASIVE_TESTS
+    REQUIRE(!sneakily_keep_meshes_alive["E"].written());
+    REQUIRE(sneakily_keep_meshes_alive["B"].written());
+#endif
 }
 
 TEST_CASE("zero_extent_component", "[core]")

From 03b283b87850a444d2dc19b848084c3b6dd1f607 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Fri, 16 Jan 2026 19:24:15 +0100
Subject: [PATCH 20/22] Make the default specification more flexible

prep for reading
---
 .../openPMD/backend/ScientificDefaults.hpp    | 95 +++++++++++++++++++
 src/backend/ScientificDefaults.cpp            | 78 +++++++++------
 2 files changed, 142 insertions(+), 31 deletions(-)

diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
index 8a0eca2def..800d9d8ab4 100644
--- a/include/openPMD/backend/ScientificDefaults.hpp
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "openPMD/IO/Access.hpp"
+#include <iostream>
 #include <type_traits>
 
 namespace openPMD::detail
@@ -27,6 +28,89 @@ using CallResult_t = typename IsCallable<F>::type;
 
 namespace openPMD::internal
 {
+template <typename, typename, typename>
+struct ConfigAttributeWithSetter;
+
+template <typename RecordType, typename GetDefaultValue>
+struct ConfigAttribute
+{
+    using DefaultValue = detail::CallResult_t<GetDefaultValue>;
+    template <typename S>
+    using SetterType = RecordType &(
+        RecordType::
+            *)(std::conditional_t<
+               std::is_void_v<S>,
+               std::remove_reference_t<detail::CallResult_t<GetDefaultValue>>,
+               S>);
+
+    RecordType &child;
+    char const *attrName;
+    GetDefaultValue &&getDefaultValue;
+
+    ConfigAttribute(
+        RecordType &child_in,
+        char const *attrName_in,
+        GetDefaultValue &&getDefaultValue_in)
+        : child(child_in)
+        , attrName(attrName_in)
+        , getDefaultValue(std::forward<GetDefaultValue>(getDefaultValue_in))
+    {}
+
+    ConfigAttribute(ConfigAttribute const &) = delete;
+    ConfigAttribute(ConfigAttribute &&) = default;
+
+    ConfigAttribute &operator=(ConfigAttribute const &) = delete;
+    ConfigAttribute &operator=(ConfigAttribute &&) = default;
+
+    template <typename S = void>
+    [[nodiscard]] auto
+    withSetter(SetterType<S>) && -> ConfigAttributeWithSetter<
+        RecordType,
+        GetDefaultValue,
+        SetterType<S>>;
+
+    auto get() -> DefaultValue
+    {
+        if constexpr (detail::IsCallable_v<GetDefaultValue>)
+        {
+            return std::forward<GetDefaultValue>(getDefaultValue)();
+        }
+        else
+        {
+            return std::forward<GetDefaultValue>(getDefaultValue);
+        }
+    }
+};
+
+template <
+    typename RecordType,
+    typename GetDefaultValue,
+    typename SetDefaultValue>
+struct ConfigAttributeWithSetter : ConfigAttribute<RecordType, GetDefaultValue>
+{
+    using parent_t = ConfigAttribute<RecordType, GetDefaultValue>;
+    using DefaultValue = typename parent_t::DefaultValue;
+
+    ConfigAttributeWithSetter(parent_t &&par, SetDefaultValue setter_in)
+        : parent_t(std::move(par)), setter(setter_in)
+    {}
+
+    SetDefaultValue setter;
+    void set(DefaultValue &&val)
+    {
+        (this->child.*setter)(std::forward<DefaultValue>(val));
+    }
+
+    void operator()()
+    {
+        if (this->child.containsAttribute(this->attrName))
+        {
+            return;
+        }
+        set(this->get());
+    }
+};
+
 template <typename Child> // CRT
 class ScientificDefaults
 {
@@ -37,6 +121,17 @@ class ScientificDefaults
     template <typename F>
     using setter_t = Child &(Child::*)();
 
+    template <typename GetDefaultValue>
+    [[nodiscard]] auto
+    defaultAttribute(char const *attrName, GetDefaultValue &&getDefaultValue)
+        -> ConfigAttribute<Child, GetDefaultValue>
+    {
+        return ConfigAttribute{
+            asChild(),
+            attrName,
+            std::forward<GetDefaultValue>(getDefaultValue)};
+    }
+
     template <typename Setter = void, typename V>
     void addDefaultFor_worker(char const *key, V &&value, Setter &&setter);
 
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index c2202611e5..df49426e75 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -18,6 +18,18 @@
 
 namespace openPMD::internal
 {
+template <typename RecordType, typename GetDefaultValue>
+template <typename S>
+auto ConfigAttribute<RecordType, GetDefaultValue>::withSetter(
+    SetterType<S> setter)
+    && -> ConfigAttributeWithSetter<RecordType, GetDefaultValue, SetterType<S>>
+{
+    return ConfigAttributeWithSetter<
+        RecordType,
+        GetDefaultValue,
+        SetterType<S>>{std::move(*this), setter};
+}
+
 template <typename Child>
 auto ScientificDefaults<Child>::asChild() -> Child &
 {
@@ -189,19 +201,21 @@ void ScientificDefaults<Child>::addDefaults()
 
     if constexpr (std::is_same_v<Child, Iteration>)
     {
-        addDefaultFor("time", 0., &Iteration::setTime);
-        addDefaultFor("dt", 1., &Iteration::setDt);
-        addDefaultFor("timeUnitSI", 1.0, &Iteration::setTimeUnitSI);
+        defaultAttribute("time", 0.).withSetter (&Iteration::setTime)();
+        defaultAttribute("dt", 1.).withSetter (&Iteration::setDt)();
+        defaultAttribute("timeUnitSI", 1.0)
+            .withSetter (&Iteration::setTimeUnitSI)();
     }
     else if constexpr (std::is_same_v<Child, Mesh>)
     {
         auto dimensionality = asChild().retrieveDimensionality();
 
-        addDefaultFor("timeOffset", 0.f, &Mesh::setTimeOffset);
-        addDefaultFor(
-            "geometry", Mesh::Geometry::cartesian, &Mesh::setGeometry);
-        addDefaultFor("dataOrder", Mesh::DataOrder::C, &Mesh::setDataOrder);
-        addDefaultFor<std::vector<std::string> const &>(
+        defaultAttribute("timeOffset", 0.f).withSetter (&Mesh::setTimeOffset)();
+        defaultAttribute("geometry", Mesh::Geometry::cartesian)
+            .withSetter (&Mesh::setGeometry)();
+        defaultAttribute("dataOrder", Mesh::DataOrder::C)
+            .withSetter (&Mesh::setDataOrder)();
+        defaultAttribute(
             "axisLabels",
             [&]() -> std::vector<std::string> {
                 switch (dimensionality)
@@ -233,9 +247,10 @@ void ScientificDefaults<Child>::addDefaults()
                     }
                 }
                 return std::vector<std::string>{"x", "y", "z"};
-            },
-            &Mesh::setAxisLabels);
-        addDefaultFor<std::vector<double> const &>(
+            })
+            .template withSetter<std::vector<std::string> const &> (
+                &Mesh::setAxisLabels)();
+        defaultAttribute(
             "gridSpacing",
             [&]() {
                 if (dimensionality < 100)
@@ -246,9 +261,10 @@ void ScientificDefaults<Child>::addDefaults()
                 {
                     return std::vector<double>{1.0};
                 }
-            },
-            &Mesh::setGridSpacing);
-        addDefaultFor<std::vector<double> const &>(
+            })
+            .template withSetter<std::vector<double> const &> (
+                &Mesh::setGridSpacing)();
+        defaultAttribute(
             "gridGlobalOffset",
             [&]() {
                 if (dimensionality < 100)
@@ -259,14 +275,16 @@ void ScientificDefaults<Child>::addDefaults()
                 {
                     return std::vector<double>{0.0};
                 }
-            },
-            &Mesh::setGridGlobalOffset);
+            })
+            .template withSetter<std::vector<double> const &> (
+                &Mesh::setGridGlobalOffset)();
 
         addParentDefaults<BaseRecord<MeshRecordComponent>>();
     }
     else if constexpr (std::is_same_v<Child, Record>)
     {
-        addDefaultFor("timeOffset", 0.f, &Record::setTimeOffset);
+        defaultAttribute("timeOffset", 0.f)
+            .withSetter (&Record::setTimeOffset)();
         auto const &keyInParent = asChild().writable().ownKeyWithinParent;
 
         if (keyInParent == "position" || keyInParent == "positionOffset")
@@ -287,25 +305,23 @@ void ScientificDefaults<Child>::addDefaults()
     }
     else if constexpr (std::is_same_v<Child, RecordComponent>)
     {
-        addDefaultFor("unitSI", 1.0, &RecordComponent::setUnitSI);
+        defaultAttribute("unitSI", 1.0)
+            .withSetter (&RecordComponent::setUnitSI)();
     }
     else if constexpr (std::is_same_v<Child, MeshRecordComponent>)
     {
         // position
         auto dimensionality = asChild().getDimensionality();
-        addDefaultFor(
-            "position",
-            [&]() {
-                if (dimensionality < 100)
-                {
-                    return std::vector<double>(dimensionality, 0.5);
-                }
-                else
-                {
-                    return std::vector<double>{0.0};
-                }
-            },
-            &MeshRecordComponent::setPosition);
+        defaultAttribute("position", [&]() {
+            if (dimensionality < 100)
+            {
+                return std::vector<double>(dimensionality, 0.5);
+            }
+            else
+            {
+                return std::vector<double>{0.0};
+            }
+        }).withSetter (&MeshRecordComponent::setPosition)();
         addParentDefaults<RecordComponent>();
     }
     else if constexpr (std::is_same_v<Child, PatchRecordComponent>)

From 7cc2d4ee758878fc8046d773efe2e6265e8beb67 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 20 Jan 2026 17:10:45 +0100
Subject: [PATCH 21/22] WIP

---
 .../openPMD/backend/ScientificDefaults.hpp    | 139 ++++++++++++++++++
 src/backend/ScientificDefaults.cpp            |  36 +++++
 2 files changed, 175 insertions(+)

diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
index 800d9d8ab4..007f8c95ea 100644
--- a/include/openPMD/backend/ScientificDefaults.hpp
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -82,6 +82,93 @@ struct ConfigAttribute
     }
 };
 
+namespace attribute_read_result
+{
+    struct TypeUnmatched
+    {};
+    struct Success
+    {};
+} // namespace attribute_read_result
+using AttributeReadResult = std::variant<
+    attribute_read_result::Success,
+    attribute_read_result::TypeUnmatched,
+    error::ReadError>;
+
+struct AttributeReaderBottom
+{};
+
+template <
+    typename RecordType,
+    typename ExpectedAttributeType,
+    typename Functor,
+    typename RecursiveReader>
+struct AttributeReader
+{
+    RecursiveReader recursiveReader;
+    // : ComponentType&, ExpectedAttributeType const& -> optional<ReadError>
+    Functor functor;
+
+    AttributeReader(RecursiveReader recursiveReader_in, Functor functor_in)
+        : recursiveReader(std::move(recursiveReader_in))
+        , functor(std::move(functor_in))
+    {}
+
+    auto operator()(RecordType &record, Attribute const &attr)
+        -> AttributeReadResult
+    {
+        AttributeReadResult recursiveResult = [&]() {
+            if constexpr (std::
+                              is_same_v<RecursiveReader, AttributeReaderBottom>)
+            {
+                return attribute_read_result::TypeUnmatched{};
+            }
+            else
+            {
+                return recursiveGetter(record, attr);
+            }
+        }();
+        return std::visit(
+            auxiliary::overloaded{
+                [](attribute_read_result::Success &&success)
+                    -> AttributeReadResult { return success; },
+                [](error::ReadError &&err) -> AttributeReadResult {
+                    return std::move(err);
+                },
+                [this, &attr, &record](attribute_read_result::TypeUnmatched &&)
+                    -> AttributeReadResult {
+                    auto val = attr.getOptional<ExpectedAttributeType>();
+                    if (!val.has_value())
+                    {
+                        return attribute_read_result::TypeUnmatched{};
+                    }
+                    if constexpr (std::is_same_v<
+                                      void,
+                                      std::invoke_result_t<
+                                          Functor,
+                                          RecordType &,
+                                          ExpectedAttributeType>>)
+                    {
+                        this->functor(record, std::move(val));
+                        return attribute_read_result::Success{};
+                    }
+                    else
+                    {
+                        auto maybe_a_read_error =
+                            this->functor(record, std::move(val));
+                        if (maybe_a_read_error.has_value())
+                        {
+                            return std::move(*maybe_a_read_error);
+                        }
+                        return attribute_read_result::Success{};
+                    }
+                }},
+            std::move(recursiveResult));
+    }
+};
+
+template <typename, typename, typename, typename>
+struct ConfigAttributeWithSetterAndReader;
+
 template <
     typename RecordType,
     typename GetDefaultValue,
@@ -96,6 +183,26 @@ struct ConfigAttributeWithSetter : ConfigAttribute<RecordType, GetDefaultValue>
     {}
 
     SetDefaultValue setter;
+
+    template <typename ExpectedAttributeType, typename Functor>
+    [[nodiscard]] auto
+    withReader(Functor f) && -> ConfigAttributeWithSetterAndReader<
+        RecordType,
+        GetDefaultValue,
+        SetDefaultValue,
+        AttributeReader<
+            RecordType,
+            ExpectedAttributeType,
+            Functor,
+            AttributeReaderBottom>>;
+
+    [[nodiscard]] auto
+    configureReaders() && -> ConfigAttributeWithSetterAndReader<
+        RecordType,
+        GetDefaultValue,
+        SetDefaultValue,
+        AttributeReaderBottom>;
+
     void set(DefaultValue &&val)
     {
         (this->child.*setter)(std::forward<DefaultValue>(val));
@@ -111,6 +218,38 @@ struct ConfigAttributeWithSetter : ConfigAttribute<RecordType, GetDefaultValue>
     }
 };
 
+template <
+    typename RecordType,
+    typename GetDefaultValue,
+    typename SetDefaultValue,
+    typename AttributeReader_t>
+struct ConfigAttributeWithSetterAndReader
+    : ConfigAttributeWithSetter<RecordType, GetDefaultValue, SetDefaultValue>
+{
+    AttributeReader_t attributeReader;
+    using parent_t =
+        ConfigAttributeWithSetter<RecordType, GetDefaultValue, SetDefaultValue>;
+
+    ConfigAttributeWithSetterAndReader(
+        parent_t &&par, AttributeReader_t attributeReader_in)
+        : parent_t(std::move(par))
+        , attributeReader(std::move(attributeReader_in))
+    {}
+
+    template <typename ExpectedAttributeType, typename Functor>
+    [[nodiscard]] auto
+    withReader(Functor f) && -> ConfigAttributeWithSetterAndReader<
+        RecordType,
+        GetDefaultValue,
+        SetDefaultValue,
+        AttributeReader<
+            RecordType,
+            ExpectedAttributeType,
+            Functor,
+            AttributeReader_t>>
+    {}
+};
+
 template <typename Child> // CRT
 class ScientificDefaults
 {
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index df49426e75..a1795ee573 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -14,6 +14,7 @@
 #include "openPMD/backend/Writable.hpp"
 
 #include <iostream>
+#include <stdexcept>
 #include <utility>
 
 namespace openPMD::internal
@@ -30,6 +31,41 @@ auto ConfigAttribute<RecordType, GetDefaultValue>::withSetter(
         SetterType<S>>{std::move(*this), setter};
 }
 
+template <
+    typename RecordType,
+    typename GetDefaultValue,
+    typename SetDefaultValue>
+template <typename ExpectedAttributeType, typename Functor>
+[[nodiscard]] auto
+ConfigAttributeWithSetter<RecordType, GetDefaultValue, SetDefaultValue>::
+    withReader(Functor f) && -> ConfigAttributeWithSetterAndReader<
+        RecordType,
+        GetDefaultValue,
+        SetDefaultValue,
+        AttributeReader<
+            RecordType,
+            ExpectedAttributeType,
+            Functor,
+            AttributeReaderBottom>>
+{
+    throw std::runtime_error("Unimplemented!");
+}
+
+template <
+    typename RecordType,
+    typename GetDefaultValue,
+    typename SetDefaultValue>
+[[nodiscard]] auto
+ConfigAttributeWithSetter<RecordType, GetDefaultValue, SetDefaultValue>::
+    configureReaders() && -> ConfigAttributeWithSetterAndReader<
+        RecordType,
+        GetDefaultValue,
+        SetDefaultValue,
+        AttributeReaderBottom>
+{
+    return {std::move(*this), AttributeReaderBottom{}};
+}
+
 template <typename Child>
 auto ScientificDefaults<Child>::asChild() -> Child &
 {

From 0b8c9aa4f2299404ad9ae3e80adea65f7098e790 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Tue, 20 Jan 2026 18:30:43 +0100
Subject: [PATCH 22/22] continue

---
 .../openPMD/backend/ScientificDefaults.hpp    | 117 +++++++++--------
 src/backend/ScientificDefaults.cpp            | 119 +++++-------------
 2 files changed, 100 insertions(+), 136 deletions(-)

diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
index 007f8c95ea..3c1642c6ac 100644
--- a/include/openPMD/backend/ScientificDefaults.hpp
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -1,8 +1,12 @@
 #pragma once
 
+#include "openPMD/Error.hpp"
 #include "openPMD/IO/Access.hpp"
-#include <iostream>
+#include "openPMD/backend/Attribute.hpp"
+
+#include <stdexcept>
 #include <type_traits>
+#include <variant>
 
 namespace openPMD::detail
 {
@@ -84,6 +88,7 @@ struct ConfigAttribute
 
 namespace attribute_read_result
 {
+    // TODO: Enqueue tried types for error messages
     struct TypeUnmatched
     {};
     struct Success
@@ -95,7 +100,13 @@ using AttributeReadResult = std::variant<
     error::ReadError>;
 
 struct AttributeReaderBottom
-{};
+{
+    template <typename... Args>
+    auto operator()(Args &&...) -> AttributeReadResult
+    {
+        return attribute_read_result::TypeUnmatched{};
+    }
+};
 
 template <
     typename RecordType,
@@ -104,29 +115,19 @@ template <
     typename RecursiveReader>
 struct AttributeReader
 {
-    RecursiveReader recursiveReader;
     // : ComponentType&, ExpectedAttributeType const& -> optional<ReadError>
     Functor functor;
+    RecursiveReader recursiveReader;
 
-    AttributeReader(RecursiveReader recursiveReader_in, Functor functor_in)
-        : recursiveReader(std::move(recursiveReader_in))
-        , functor(std::move(functor_in))
+    AttributeReader(Functor functor_in, RecursiveReader recursiveReader_in)
+        : functor(std::move(functor_in))
+        , recursiveReader(std::move(recursiveReader_in))
     {}
 
     auto operator()(RecordType &record, Attribute const &attr)
         -> AttributeReadResult
     {
-        AttributeReadResult recursiveResult = [&]() {
-            if constexpr (std::
-                              is_same_v<RecursiveReader, AttributeReaderBottom>)
-            {
-                return attribute_read_result::TypeUnmatched{};
-            }
-            else
-            {
-                return recursiveGetter(record, attr);
-            }
-        }();
+        AttributeReadResult recursiveResult = recursiveReader(record, attr);
         return std::visit(
             auxiliary::overloaded{
                 [](attribute_read_result::Success &&success)
@@ -148,13 +149,13 @@ struct AttributeReader
                                           RecordType &,
                                           ExpectedAttributeType>>)
                     {
-                        this->functor(record, std::move(val));
+                        this->functor(record, std::move(*val));
                         return attribute_read_result::Success{};
                     }
                     else
                     {
                         auto maybe_a_read_error =
-                            this->functor(record, std::move(val));
+                            this->functor(record, std::move(*val));
                         if (maybe_a_read_error.has_value())
                         {
                             return std::move(*maybe_a_read_error);
@@ -208,13 +209,10 @@ struct ConfigAttributeWithSetter : ConfigAttribute<RecordType, GetDefaultValue>
         (this->child.*setter)(std::forward<DefaultValue>(val));
     }
 
-    void operator()()
+    template <typename... Args>
+    void operator()(Args &&...)
     {
-        if (this->child.containsAttribute(this->attrName))
-        {
-            return;
-        }
-        set(this->get());
+        throw std::runtime_error("Unimplemented");
     }
 };
 
@@ -247,7 +245,50 @@ struct ConfigAttributeWithSetterAndReader
             ExpectedAttributeType,
             Functor,
             AttributeReader_t>>
-    {}
+    {
+        return {
+            std::move(*static_cast<parent_t *>(this)),
+            AttributeReader<
+                RecordType,
+                ExpectedAttributeType,
+                Functor,
+                AttributeReader_t>{
+                std::move(f), std::move(this->attributeReader)}};
+    }
+
+    // TODO distinguish if we are parsing or writing
+    void operator()()
+    {
+        if (this->child.containsAttribute(this->attrName))
+        {
+            return;
+        }
+        this->set(this->get());
+        auto attribute = this->child.getAttribute(this->attrName);
+        auto dt = attribute.dtype;
+        AttributeReadResult readResult =
+            attributeReader(this->child, attribute);
+        std::visit(
+            auxiliary::overloaded{
+                [&](attribute_read_result::TypeUnmatched) {
+                    std::cerr
+                        << "Unexpected type '" << dt << "' for attribute '"
+                        << this->attrName << "' in '"
+                        << this->child.myPath().openPMDPath()
+                        << "'. Expected one of [UNIMPLEMENTED: PRINT TYPES "
+                           "HERE] or convertible to such a type."
+                        << std::endl;
+                },
+                [&](error::ReadError const &err) {
+                    std::cerr
+                        << "Unexpected error while trying to read attribute '"
+                        << this->attrName << "' in '"
+                        << this->child.myPath().openPMDPath()
+                        << "': " << err.what() << std::endl;
+                },
+                [](attribute_read_result::Success) { /* no-op */ }},
+            std::move(readResult));
+    }
 };
 
 template <typename Child> // CRT
@@ -271,30 +312,6 @@ class ScientificDefaults
             std::forward<GetDefaultValue>(getDefaultValue)};
     }
 
-    template <typename Setter = void, typename V>
-    void addDefaultFor_worker(char const *key, V &&value, Setter &&setter);
-
-    template <typename V>
-    void addDefaultFor_worker(char const *key, V &&value);
-
-    template <typename F, typename... Args>
-    void addDefaultFor_resolveValue(char const *key, F &&get_value, Args &&...);
-
-    // These two below overloads exist only for type inference purposes
-    // Apart from this, they just forward their arguments to
-    // addDefaultFor_resolveValue
-    template <typename Setter = void, typename F>
-    void addDefaultFor(
-        char const *key,
-        F &&get_value,
-        Child &(Child::*)(std::conditional_t<
-                          std::is_void_v<Setter>,
-                          std::remove_reference_t<detail::CallResult_t<F>>,
-                          Setter>));
-
-    template <typename F>
-    void addDefaultFor(char const *key, F &&get_value);
-
     template <typename Parent>
     void addParentDefaults();
 
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
index a1795ee573..a97f8646e3 100644
--- a/src/backend/ScientificDefaults.cpp
+++ b/src/backend/ScientificDefaults.cpp
@@ -1,5 +1,6 @@
 #include "openPMD/backend/ScientificDefaults.hpp"
 
+#include "openPMD/Error.hpp"
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Mesh.hpp"
 #include "openPMD/ParticleSpecies.hpp"
@@ -7,6 +8,7 @@
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/auxiliary/TypeTraits.hpp"
+#include "openPMD/backend/BaseRecord.hpp"
 #include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include "openPMD/backend/PatchRecord.hpp"
@@ -48,7 +50,9 @@ ConfigAttributeWithSetter<RecordType, GetDefaultValue, SetDefaultValue>::
             Functor,
             AttributeReaderBottom>>
 {
-    throw std::runtime_error("Unimplemented!");
+    return (std::move(*this))
+        .configureReaders()
+        .template withReader<ExpectedAttributeType>(std::move(f));
 }
 
 template <
@@ -78,85 +82,6 @@ auto ScientificDefaults<Child>::asChild() const -> Child const &
     return *static_cast<Child const *>(this);
 }
 
-template <typename Child>
-template <typename Setter, typename V>
-void ScientificDefaults<Child>::addDefaultFor_worker(
-    char const *, V &&value, Setter &&setter)
-{
-    (asChild().*setter)(std::forward<V>(value));
-}
-
-template <typename Child>
-template <typename V>
-void ScientificDefaults<Child>::addDefaultFor_worker(char const *key, V &&value)
-{
-    asChild().setAttribute(key, std::forward<V>(value));
-}
-
-template <typename Child>
-template <typename F, typename... Args>
-void ScientificDefaults<Child>::addDefaultFor_resolveValue(
-    char const *key, F &&get_value, Args &&...args)
-{
-    if (asChild().containsAttribute(key))
-    {
-        return;
-    }
-    auto value = [&]() {
-        if constexpr (detail::IsCallable_v<F>)
-        {
-            return get_value();
-        }
-        else
-        {
-            return get_value;
-        }
-    }();
-    constexpr bool debug = true;
-    if constexpr (debug)
-    {
-        std::cout << "\tInitializing default for '" << key << "' = '";
-        if constexpr (
-            auxiliary::IsVector_v<std::remove_reference_t<decltype(value)>> ||
-            auxiliary::IsArray_v<std::remove_reference_t<decltype(value)>>)
-        {
-            auxiliary::write_vec_to_stream(std::cout, value);
-        }
-        else if constexpr (std::is_same_v<
-                               std::remove_reference_t<decltype(value)>,
-                               unit_representations::AsMap>)
-        {
-            std::cout << "Unit_Map";
-        }
-        else
-        {
-            std::cout << value;
-        }
-        std::cout << "'" << std::endl;
-    }
-    addDefaultFor_worker(key, std::move(value), std::forward<Args>(args)...);
-}
-
-template <typename Child>
-template <typename Setter, typename F>
-void ScientificDefaults<Child>::addDefaultFor(
-    char const *key,
-    F &&get_value,
-    Child &(Child::*setter)(std::conditional_t<
-                            std::is_void_v<Setter>,
-                            std::remove_reference_t<detail::CallResult_t<F>>,
-                            Setter>))
-{
-    addDefaultFor_resolveValue(key, std::forward<F>(get_value), setter);
-}
-
-template <typename Child>
-template <typename F>
-void ScientificDefaults<Child>::addDefaultFor(char const *key, F &&get_value)
-{
-    addDefaultFor_resolveValue(key, std::forward<F>(get_value));
-}
-
 template <typename Child>
 template <typename Parent>
 void ScientificDefaults<Child>::addParentDefaults()
@@ -216,6 +141,7 @@ void ScientificDefaults<Child>::addDefaults()
 {
     std::cout << "Adding defaults for '" << asChild().myPath().openPMDPath()
               << "'" << std::endl;
+    using maybe_read_error = std::optional<error::ReadError>;
 
     // First some verifications
     if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
@@ -246,7 +172,20 @@ void ScientificDefaults<Child>::addDefaults()
     {
         auto dimensionality = asChild().retrieveDimensionality();
 
-        defaultAttribute("timeOffset", 0.f).withSetter (&Mesh::setTimeOffset)();
+        defaultAttribute("timeOffset", 0.f)
+            .withSetter(&Mesh::setTimeOffset)
+            .template withReader<std::string>([](Mesh &m, std::string val) {
+                if ("cartesian" == val)
+                    m.setGeometry(Mesh::Geometry::cartesian);
+                else if ("thetaMode" == val)
+                    m.setGeometry(Mesh::Geometry::thetaMode);
+                else if ("cylindrical" == val)
+                    m.setGeometry(Mesh::Geometry::cylindrical);
+                else if ("spherical" == val)
+                    m.setGeometry(Mesh::Geometry::spherical);
+                else
+                    m.setGeometry(std::move(val));
+            })();
         defaultAttribute("geometry", Mesh::Geometry::cartesian)
             .withSetter (&Mesh::setGeometry)();
         defaultAttribute("dataOrder", Mesh::DataOrder::C)
@@ -314,6 +253,9 @@ void ScientificDefaults<Child>::addDefaults()
             })
             .template withSetter<std::vector<double> const &> (
                 &Mesh::setGridGlobalOffset)();
+        defaultAttribute("unitDimension", unit_representations::AsArray{})
+            .template withSetter<unit_representations::AsArray const &> (
+                &Child::setUnitDimension)();
 
         addParentDefaults<BaseRecord<MeshRecordComponent>>();
     }
@@ -325,18 +267,25 @@ void ScientificDefaults<Child>::addDefaults()
 
         if (keyInParent == "position" || keyInParent == "positionOffset")
         {
-            addDefaultFor<unit_representations::AsMap const &>(
+            defaultAttribute(
                 "unitDimension",
                 []() {
                     return unit_representations::AsMap{{UnitDimension::L, 1.0}};
-                },
-                &Record::setUnitDimension);
+                })
+                .template withSetter<unit_representations::AsMap const &> (
+                    &Record::setUnitDimension)();
         }
+        defaultAttribute("unitDimension", unit_representations::AsArray{})
+            .template withSetter<unit_representations::AsArray const &> (
+                &Child::setUnitDimension)();
 
         addParentDefaults<BaseRecord<RecordComponent>>();
     }
     else if constexpr (std::is_same_v<Child, PatchRecord>)
     {
+        defaultAttribute("unitDimension", unit_representations::AsArray{})
+            .template withSetter<unit_representations::AsArray const &> (
+                &Child::setUnitDimension)();
         addParentDefaults<BaseRecord<PatchRecordComponent>>();
     }
     else if constexpr (std::is_same_v<Child, RecordComponent>)
@@ -366,8 +315,6 @@ void ScientificDefaults<Child>::addDefaults()
     }
     else if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
     {
-        addDefaultFor<unit_representations::AsArray const &>(
-            "unitDimension", unit_representations::AsArray{});
     }
 }