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

CMakeLists.txt

@@ -426,6 +426,9 @@ set(CORE_SOURCE
         src/backend/PatchRecord.cpp
         src/backend/PatchRecordComponent.cpp
         src/backend/Writable.cpp
+        src/backend/ScientificDefaults.cpp
+        src/backend/ScientificDefaults_auxiliary.cpp
+        src/backend/ScientificDefaults_impl.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
 {
     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;
 
 public:
     Iteration(Iteration const &) = default;
@@ -268,6 +272,14 @@ class Iteration : public Attributable
     [[deprecated("This attribute is no longer set by the openPMD-api.")]] bool
     closedByWriter() const;
 
+    template <typename Visitor>
+    void visitHierarchy(Visitor &&v)
+    {
+        v(*this);
+        meshes.visitHierarchy(v);
+        particles.visitHierarchy(v);
+    }
+
     Container<Mesh> meshes{};
     Container<ParticleSpecies> particles{}; // particleSpecies?
 
@@ -337,6 +349,8 @@ class Iteration : public Attributable
     void readMeshes(std::string const &meshesPath);
     void readParticles(std::string const &particlesPath);
 
+    void setDefaultAttributes();
+
     /**
      * Status after beginning an IO step. Currently includes:
      * * The advance status (OK, OVER, RANDOMACCESS)
@@ -421,14 +435,17 @@ class Iteration : public Attributable
      *
      * @param w The Writable representing the parent.
      */
-    virtual void linkHierarchy(Writable &w);
+    void linkHierarchy(Writable &w) override;
 
     /**
      * @brief Access an iteration in read mode that has potentially not been
      *      parsed yet.
      *
      */
     void runDeferredParseAccess();
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // Iteration
 
 extern template float Iteration::time<float>() const;

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>
@@ -41,6 +43,7 @@ class Mesh : public BaseRecord<MeshRecordComponent>
 {
     friend class Container<Mesh>;
     friend class Iteration;
+    friend class internal::ScientificDefaults;
 
 public:
     Mesh(Mesh const &) = default;
@@ -328,8 +331,17 @@ class Mesh : public BaseRecord<MeshRecordComponent>
     void
     flush_impl(std::string const &, internal::FlushParams const &) override;
     void read();
+    auto retrieveDimensionality() const -> uint64_t;
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // 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,23 +24,34 @@
 #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
 {
     friend class Container<ParticleSpecies>;
     friend class Container<Record>;
     friend class Iteration;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults;
 
 public:
     ParticlePatches particlePatches;
 
+    template <typename Visitor>
+    void visitHierarchy(Visitor &&v)
+    {
+        Container<Record>::visitHierarchy(v);
+        particlePatches.visitHierarchy(v);
+    }
+
 private:
     ParticleSpecies();
 
@@ -53,6 +64,9 @@ class ParticleSpecies : public Container<Record>
     {
         return m_containerData;
     }
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 };
 
 namespace traits

include/openPMD/Record.hpp

@@ -23,6 +23,7 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
 #include <type_traits>
@@ -34,6 +35,7 @@ class Record : public BaseRecord<RecordComponent>
     friend class Container<Record>;
     friend class Iteration;
     friend class ParticleSpecies;
+    friend class internal::ScientificDefaults;
 
 public:
     Record(Record const &) = default;
@@ -55,8 +57,13 @@ class Record : public BaseRecord<RecordComponent>
     flush_impl(std::string const &, internal::FlushParams const &) override;
 
     [[nodiscard]] internal::HomogenizeExtents read();
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // 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
+    , protected internal::ScientificDefaults
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -128,6 +131,7 @@ class RecordComponent : public BaseRecordComponent
     friend class MeshRecordComponent;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults;
 
 public:
     enum class Allocation
@@ -482,11 +486,17 @@ class RecordComponent : public BaseRecordComponent
     auto visit(Args &&...args) -> decltype(Visitor::template call<char>(
         std::declval<RecordComponent &>(), std::forward<Args>(args)...));
 
+    template <typename Visitor>
+    void visitHierarchy(Visitor &&v)
+    {
+        v(*this);
+    }
+
     static constexpr char const *const SCALAR = "\vScalar";
 
 protected:
     void flush(std::string const &, internal::FlushParams const &);
-    void read(bool require_unit_si);
+    void read();
 
 private:
     /**
@@ -534,12 +544,15 @@ OPENPMD_protected
         BaseRecordComponent::setData(m_recordComponentData);
     }
 
-    void readBase(bool require_unit_si);
+    void readBase();
 
     template <typename T>
     void verifyChunk(Offset const &, Extent const &) const;
 
     void verifyChunk(Datatype, Offset const &, Extent const &) const;
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // RecordComponent
 
 namespace internal

include/openPMD/Series.hpp

@@ -778,6 +778,13 @@ class Series : public Attributable
      */
     void close();
 
+    template <typename Visitor>
+    void visitHierarchy(Visitor &&v)
+    {
+        v(*this);
+        get().iterations.visitHierarchy(v);
+    }
+
     /**
      * This overrides Attributable::iterationFlush() which will fail on Series.
      */

include/openPMD/auxiliary/TypeTraits.hpp

@@ -124,6 +124,22 @@ namespace detail
     {
         constexpr static bool value = true;
     };
+
+    template <typename T>
+    struct ScalarType
+    {
+        using type = T;
+    };
+    template <typename T>
+    struct ScalarType<std::vector<T>>
+    {
+        using type = T;
+    };
+    template <typename T, size_t N>
+    struct ScalarType<std::array<T, N>>
+    {
+        using type = T;
+    };
 } // namespace detail
 
 template <typename T>
@@ -141,6 +157,12 @@ using IsPointer_t = typename detail::IsPointer<T>::type;
 template <typename C>
 inline constexpr bool IsChar_v = detail::IsChar<C>::value;
 
+template <typename T>
+using ScalarType_t = typename detail::ScalarType<T>::type;
+
+template <typename T>
+using VectorType_t = std::vector<ScalarType_t<T>>;
+
 /** Emulate in the C++ concept ContiguousContainer
  *
  * Users can implement this trait for a type to signal it can be used as
@@ -203,6 +225,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,7 @@ namespace internal
     class IterationData;
     class SeriesData;
     struct HomogenizeExtents;
+    struct ConfigAttribute;
 
     class SharedAttributableData
     {
@@ -244,6 +245,7 @@ class Attributable
     friend class internal::AttributableData;
     friend class Snapshots;
     friend struct internal::HomogenizeExtents;
+    friend struct internal::ConfigAttribute;
 
 protected:
     // tag for internal constructor
@@ -276,6 +278,7 @@ class Attributable
     template <typename T>
     bool setAttribute(std::string const &key, T value);
     bool setAttribute(std::string const &key, char const value[]);
+    bool setAttribute(std::string const &key, Attribute value);
     /** @}
      */
 

include/openPMD/backend/Attribute.hpp

@@ -115,9 +115,30 @@ class Attribute
     template <typename U>
     std::optional<U> getOptional() const;
 
-private:
     template <typename U>
-    std::variant<U, std::runtime_error> get_impl() const;
+    std::variant<U, std::runtime_error> getOrError() const;
+
+    /**
+     * Force this attribute into a vector type.
+     * If it is scalar, convert to a vector with a single element.
+     * If it is an array, convert it to a vector.
+     *
+     * @return On success, a new Attribute with underlying vector type.
+     *         On failure, an error with a description of what went wrong
+     *         (e.g. when the base type is bool).
+     */
+    [[nodiscard]] std::variant<Attribute, std::runtime_error>
+    requireVector() const;
+    /**
+     * Force this attribute into a scalar type.
+     * If it is a vector attribute with a single entry, convert to a scalar.
+     *
+     * @return On success, a new Attribute with underlying scalar type.
+     *         On failure, an error with a description of what went wrong
+     *         (e.g. when a vector with size other than 1 was provided).
+     */
+    [[nodiscard]] std::variant<Attribute, std::runtime_error>
+    requireScalar() const;
 };
 
 namespace detail