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

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

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>;
@@ -362,9 +366,6 @@ class BaseRecord
      */
     bool scalar() const;
 
-protected:
-    void readBase();
-
 private:
     void flush(std::string const &, internal::FlushParams const &) final;
     virtual void
@@ -381,6 +382,21 @@ namespace detail
 
     template <typename BaseRecord>
     void verifyNonscalar(BaseRecord *self);
+
+    template <typename T>
+    struct IsBaseRecord
+    {
+        constexpr static bool value = false;
+    };
+
+    template <typename T>
+    struct IsBaseRecord<BaseRecord<T>>
+    {
+        constexpr static bool value = true;
+    };
+
+    template <typename T>
+    constexpr bool IsBaseRecord_v = IsBaseRecord<T>::value;
 } // namespace detail
 
 template <typename T_elem>

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