Write scientific defaults upon close (Iteration::close or Series::close)

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

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;

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
 {

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;

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
 {

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
@@ -486,7 +491,7 @@ class RecordComponent : public BaseRecordComponent
 
 protected:
     void flush(std::string const &, internal::FlushParams const &);
-    void read(bool require_unit_si);
+    void read();
 
 private:
     /**
@@ -534,7 +539,7 @@ OPENPMD_protected
         BaseRecordComponent::setData(m_recordComponentData);
     }
 
-    void readBase(bool require_unit_si);
+    void readBase();
 
     template <typename T>
     void verifyChunk(Offset const &, Extent const &) const;

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

include/openPMD/backend/Attributable.hpp

@@ -57,6 +57,8 @@ namespace internal
     class IterationData;
     class SeriesData;
     struct HomogenizeExtents;
+    template <typename, typename, typename, typename>
+    struct ConfigAttributeWithSetterAndReader;
 
     class SharedAttributableData
     {
@@ -244,6 +246,8 @@ class Attributable
     friend class internal::AttributableData;
     friend class Snapshots;
     friend struct internal::HomogenizeExtents;
+    template <typename, typename, typename, typename>
+    friend struct internal::ConfigAttributeWithSetterAndReader;
 
 protected:
     // tag for internal constructor

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>;

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

include/openPMD/backend/MeshRecordComponent.hpp

@@ -21,6 +21,7 @@
 #pragma once
 
 #include "openPMD/RecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <vector>
 
@@ -32,14 +33,18 @@ 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;
     template <typename>
     friend class BaseRecord;
     template <typename, typename>
     friend class internal::BaseRecordData;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     friend class Mesh;
 

include/openPMD/backend/PatchRecord.hpp

@@ -22,20 +22,25 @@
 
 #include "openPMD/backend/BaseRecord.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
-#include <unordered_map>
 
 namespace openPMD
 {
-class PatchRecord : public BaseRecord<PatchRecordComponent>
+class PatchRecord
+    : public BaseRecord<PatchRecordComponent>
+    , internal::ScientificDefaults<PatchRecord>
 {
     friend class Container<PatchRecord>;
     friend class ParticleSpecies;
     friend class ParticlePatches;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
-    PatchRecord &setUnitDimension(std::map<UnitDimension, double> const &);
+    PatchRecord &setUnitDimension(unit_representations::AsMap const &);
+    PatchRecord &setUnitDimension(unit_representations::AsArray const &udim);
     ~PatchRecord() override = default;
 
 private:

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:
     /**