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..4aed643472 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;
@@ -153,6 +156,7 @@ class Iteration : public Attributable
     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 d0bf81ddef..4ff5d3749d 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,10 +39,14 @@ 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;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     Mesh(Mesh const &) = default;
@@ -328,8 +334,14 @@ class Mesh : public BaseRecord<MeshRecordComponent>
     void
     flush_impl(std::string const &, internal::FlushParams const &) override;
     void read();
+    auto retrieveDimensionality() const -> uint64_t;
 }; // 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..075d5bb8cd 100644
--- a/include/openPMD/ParticleSpecies.hpp
+++ b/include/openPMD/ParticleSpecies.hpp
@@ -24,19 +24,24 @@
 #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>;
     friend class Iteration;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     ParticlePatches particlePatches;
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/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/auxiliary/TypeTraits.hpp b/include/openPMD/auxiliary/TypeTraits.hpp
index faf2b29472..150875d92e 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..90862f97fd 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>
@@ -179,6 +180,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 +199,8 @@ class BaseRecord
     friend class internal::ScalarIterator;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     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 963fd34802..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>
@@ -343,5 +344,13 @@ namespace internal
 
         ~EraseStaleEntries();
     };
+
+    template <typename T>
+    constexpr bool IsContainer_v = auxiliary::IsTemplateBaseOf_v<Container, T>;
+    template <typename T>
+    using AsContainer_t = auxiliary::AsTemplateBase_t<Container, T>;
+
+    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..5319985832 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;
@@ -40,6 +43,8 @@ class MeshRecordComponent : public RecordComponent
     friend class BaseRecord;
     template <typename, typename>
     friend class internal::BaseRecordData;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     friend class Mesh;
 
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/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
new file mode 100644
index 0000000000..8a0eca2def
--- /dev/null
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+#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 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();
+
+protected:
+    void finalize(Access);
+    void addDefaults();
+};
+
+template <typename Child>
+constexpr bool HasScientificDefaults_v =
+    std::is_base_of_v<ScientificDefaults<Child>, Child>;
+} // namespace openPMD::internal
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/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/Iteration.cpp b/src/Iteration.cpp
index ab35c1e3ae..438a33f974 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"
 
@@ -52,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";
 }
@@ -112,6 +110,12 @@ Iteration &Iteration::close(bool _flush)
         // yet keeps it re-openable)
         break;
     }
+
+    {
+        Access at = IOHandler()->m_frontendAccess;
+        finalize(at);
+    }
+
     if (_flush)
     {
         if (flag == StepStatus::DuringStep)
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index e93b2b5219..bf7952911a 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.);
     }
 }
 
@@ -269,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);
@@ -285,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->containsAttribute("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());
@@ -341,7 +335,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 +420,7 @@ void Mesh::flush_impl(
             else
             {
                 setGridUnitSIPerDimension(
-                    std::vector<double>(retrieveMeshDimensionality(*this), 1));
+                    std::vector<double>(retrieveDimensionality(), 1));
             }
         }
         flushAttributes(flushParams);
diff --git a/src/ParticleSpecies.cpp b/src/ParticleSpecies.cpp
index b3e7ea1f7e..b77258c461 100644
--- a/src/ParticleSpecies.cpp
+++ b/src/ParticleSpecies.cpp
@@ -175,23 +175,9 @@ 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)
-        {
-            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)
@@ -203,13 +189,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..cf8493a327 100644
--- a/src/Record.cpp
+++ b/src/Record.cpp
@@ -29,16 +29,15 @@
 
 namespace openPMD
 {
-Record::Record()
-{
-    setTimeOffset(0.f);
-}
+Record::Record() = default;
 
 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/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/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/BaseRecord.cpp b/src/backend/BaseRecord.cpp
index 37d6d7b126..23523818f1 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<                                             \
@@ -479,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
     {
@@ -487,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;
 }
 
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/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);
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
new file mode 100644
index 0000000000..172276c148
--- /dev/null
+++ b/src/backend/ScientificDefaults.cpp
@@ -0,0 +1,312 @@
+#include "openPMD/backend/ScientificDefaults.hpp"
+
+#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 "openPMD/backend/PatchRecord.hpp"
+#include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/Writable.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 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()
+{
+    asChild().ScientificDefaults<Parent>::addDefaults();
+}
+
+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>;
+        using mapped_type = typename Container_t::mapped_type;
+        if constexpr (HasScientificDefaults_v<mapped_type>)
+        {
+            for (auto &[_, right] : asChild())
+            {
+                (void)_;
+                right.ScientificDefaults<mapped_type>::finalize(at);
+            }
+        }
+    }
+    // sic! no else
+
+    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);
+        }
+    }
+}
+
+template <typename Child>
+void ScientificDefaults<Child>::addDefaults()
+{
+    std::cout << "Adding defaults for '" << asChild().myPath().openPMDPath()
+              << "'" << std::endl;
+
+    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();
+
+        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 &>(
+            "axisLabels",
+            [&]() -> 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)
+                    {
+                        // x1, x2, x3, x4, ...
+                        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) +
+                            "'. Seems a bit much."};
+                    }
+                }
+                return std::vector<std::string>{"x", "y", "z"};
+            },
+            &Mesh::setAxisLabels);
+        addDefaultFor<std::vector<double> const &>(
+            "gridSpacing",
+            [&]() {
+                if (dimensionality < 100)
+                {
+                    return std::vector<double>(dimensionality, 1.0);
+                }
+                else
+                {
+                    return std::vector<double>{1.0};
+                }
+            },
+            &Mesh::setGridSpacing);
+        addDefaultFor<std::vector<double> const &>(
+            "gridGlobalOffset",
+            [&]() {
+                if (dimensionality < 100)
+                {
+                    return std::vector<double>(dimensionality, 0.0);
+                }
+                else
+                {
+                    return std::vector<double>{0.0};
+                }
+            },
+            &Mesh::setGridGlobalOffset);
+
+        addParentDefaults<BaseRecord<MeshRecordComponent>>();
+    }
+    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>>();
+    }
+    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 &>(
+            "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>>;
+} // namespace openPMD::internal
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index ad22ae1cf8..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));
@@ -663,13 +666,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]")
@@ -689,11 +694,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);
@@ -754,12 +764,15 @@ 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 */
+    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);
     REQUIRE(m["z"].resetDataset(globalDataset).numAttributes() == 0);
 
+    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"};
@@ -768,12 +781,12 @@ 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 */
 
-    o.flush();
     REQUIRE(m["x"].unitSI() == 1);
     REQUIRE(m["x"].numAttributes() == 2); /* unitSI, position */
     REQUIRE(m["x"].position<double>() == pos);
@@ -794,24 +807,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);