Add gridUnitDimension in ScientificDefaults

franzpoeschel · franzpoeschel · commit d8c66a671754 · 2026-01-23T11:06:27.000+01:00
requires distinguishing openPMD standard versions
diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/Access.hpp"
 
 #include <type_traits>
@@ -25,15 +26,15 @@ class ScientificDefaults
         -> ConfigAttribute<Child, GetDefaultValue>;
 
     template <typename Parent, bool write>
-    void addParentDefaults();
+    void addParentDefaults(OpenpmdStandard);
 
     template <bool write>
-    void defaults_impl();
+    void defaults_impl(OpenpmdStandard);
 
 protected:
-    void addDefaultsRecursively();
-    void addDefaults();
-    void readDefaults();
+    void addDefaultsRecursively(OpenpmdStandard);
+    void addDefaults(OpenpmdStandard);
+    void readDefaults(OpenpmdStandard);
 };
 
 template <typename Child>
diff --git a/src/Iteration.cpp b/src/Iteration.cpp
@@ -113,7 +113,7 @@ Iteration &Iteration::close(bool _flush)
 
     if (access::write(IOHandler()->m_frontendAccess))
     {
-        addDefaultsRecursively();
+        addDefaultsRecursively(IOHandler()->m_standard);
     }
 
     if (_flush)
@@ -503,7 +503,8 @@ void Iteration::read_impl(std::string const &groupPath)
     pOpen.path = groupPath;
     IOHandler()->enqueue(IOTask(this, pOpen));
 
-    internal::ScientificDefaults<Iteration>::readDefaults();
+    internal::ScientificDefaults<Iteration>::readDefaults(
+        IOHandler()->m_standard);
 
     /* Find the root point [Series] of this file,
      * meshesPath and particlesPath are stored there */
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
@@ -412,18 +412,6 @@ void Mesh::flush_impl(
                     comp.second.flush(comp.first, flushParams);
             }
         }
-        if (!containsAttribute("gridUnitSI"))
-        {
-            if (IOHandler()->m_standard < OpenpmdStandard::v_2_0_0)
-            {
-                setGridUnitSI(1);
-            }
-            else
-            {
-                setGridUnitSIPerDimension(
-                    std::vector<double>(retrieveDimensionality(), 1));
-            }
-        }
         flushAttributes(flushParams);
     }
 }
@@ -434,50 +422,7 @@ void Mesh::read()
         IOHandler()->m_verify_homogeneous_extents);
     internal::EraseStaleEntries<Mesh> map{*this};
 
-    internal::ScientificDefaults<Mesh>::readDefaults();
-
-    Parameter<Operation::READ_ATT> aRead;
-
-    // TODO move this to ScientificDefaults
-    aRead.name = "gridUnitSI";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (IOHandler()->m_standard >= OpenpmdStandard::v_2_0_0)
-    {
-        if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                           .getOptional<std::vector<double>>();
-            val.has_value())
-            setGridUnitSIPerDimension(val.value());
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'gridUnitSI' "
-                "(expected vector of double, found " +
-                    datatypeToString(
-                        Attribute(Attribute::from_any, *aRead.m_resource)
-                            .dtype) +
-                    ")");
-    }
-    else
-    {
-        if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                           .getOptional<double>();
-            val.has_value())
-            setGridUnitSI(val.value());
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'gridUnitSI' "
-                "(expected double, found " +
-                    datatypeToString(
-                        Attribute(Attribute::from_any, *aRead.m_resource)
-                            .dtype) +
-                    ")");
-    }
+    internal::ScientificDefaults<Mesh>::readDefaults(IOHandler()->m_standard);
 
     if (scalar())
     {
diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp
@@ -768,7 +768,8 @@ inline bool BaseRecord<T_elem>::scalar() const
 template <typename T_elem>
 inline void BaseRecord<T_elem>::readBase()
 {
-    internal::ScientificDefaults<BaseRecord<T_elem>>::readDefaults();
+    internal::ScientificDefaults<BaseRecord<T_elem>>::readDefaults(
+        this->IOHandler()->m_standard);
 }
 
 template <typename T_elem>
diff --git a/src/backend/MeshRecordComponent.cpp b/src/backend/MeshRecordComponent.cpp
@@ -39,7 +39,8 @@ MeshRecordComponent::MeshRecordComponent(
 
 void MeshRecordComponent::read()
 {
-    internal::ScientificDefaults<MeshRecordComponent>::readDefaults();
+    internal::ScientificDefaults<MeshRecordComponent>::readDefaults(
+        IOHandler()->m_standard);
 
     readBase();
 }
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
@@ -1,4 +1,5 @@
 #include "openPMD/backend/ScientificDefaults.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/ThrowError.hpp"
 #include "openPMD/backend/ScientificDefaults_internal.hpp"
 
@@ -99,23 +100,23 @@ template <typename GetDefaultValue>
 
 template <typename Child>
 template <typename Parent, bool write>
-void ScientificDefaults<Child>::addParentDefaults()
+void ScientificDefaults<Child>::addParentDefaults(OpenpmdStandard standard)
 {
     // Cannot directly call read_impl as it is private
     if constexpr (write)
     {
-        asChild().ScientificDefaults<Parent>::addDefaults();
+        asChild().ScientificDefaults<Parent>::addDefaults(standard);
     }
     else
     {
-        asChild().ScientificDefaults<Parent>::readDefaults();
+        asChild().ScientificDefaults<Parent>::readDefaults(standard);
     }
 }
 
 template <typename Child>
-void ScientificDefaults<Child>::addDefaultsRecursively()
+void ScientificDefaults<Child>::addDefaultsRecursively(OpenpmdStandard standard)
 {
-    addDefaults();
+    addDefaults(standard);
     if constexpr (IsContainer_v<Child>)
     {
         using Container_t = AsContainer_t<Child>;
@@ -125,7 +126,8 @@ void ScientificDefaults<Child>::addDefaultsRecursively()
             for (auto &[_, right] : asChild())
             {
                 (void)_;
-                right.ScientificDefaults<mapped_type>::addDefaultsRecursively();
+                right.ScientificDefaults<mapped_type>::addDefaultsRecursively(
+                    standard);
             }
         }
     }
@@ -136,20 +138,22 @@ void ScientificDefaults<Child>::addDefaultsRecursively()
         for (auto &[_, right] : asChild().meshes)
         {
             (void)_;
-            right.ScientificDefaults<Mesh>::addDefaultsRecursively();
+            right.ScientificDefaults<Mesh>::addDefaultsRecursively(standard);
         }
         for (auto &[_, right] : asChild().particles)
         {
             (void)_;
-            right.ScientificDefaults<ParticleSpecies>::addDefaultsRecursively();
+            right.ScientificDefaults<ParticleSpecies>::addDefaultsRecursively(
+                standard);
         }
     }
     else if constexpr (std::is_same_v<Child, ParticleSpecies>)
     {
         for (auto &[_, right] : asChild().particlePatches)
         {
             (void)_;
-            right.ScientificDefaults<PatchRecord>::addDefaultsRecursively();
+            right.ScientificDefaults<PatchRecord>::addDefaultsRecursively(
+                standard);
         }
     }
 }
@@ -220,7 +224,7 @@ auto ensureFloatingScalar(SetterFunctor &&set)
 
 template <typename Child>
 template <bool write>
-void ScientificDefaults<Child>::defaults_impl()
+void ScientificDefaults<Child>::defaults_impl(OpenpmdStandard standard)
 {
     using maybe_read_error = std::optional<error::ReadError>;
     constexpr auto const wor = write ? WriteOrRead::Write : WriteOrRead::Read;
@@ -376,7 +380,32 @@ void ScientificDefaults<Child>::defaults_impl()
                 asChild().setAttribute("timeOffset", val);
             }))(wor);
 
-        addParentDefaults<BaseRecord<MeshRecordComponent>, write>();
+        if (standard >= OpenpmdStandard::v_2_0_0)
+        {
+            defaultAttribute(
+                "gridUnitSI",
+                [&]() {
+                    if (dimensionality < 100)
+                    {
+                        return std::vector<double>(dimensionality, 1.);
+                    }
+                    else
+                    {
+                        return std::vector<double>{1.};
+                    }
+                })
+                .template withSetter<std::vector<double> const &>(
+                    &Mesh::setGridUnitSIPerDimension)
+                .withReader()(wor);
+        }
+        else
+        {
+            defaultAttribute("gridUnitSI", 1.0)
+                .withSetter(&Mesh::setGridUnitSI)
+                .withReader()(wor);
+        }
+
+        addParentDefaults<BaseRecord<MeshRecordComponent>, write>(standard);
     }
     else if constexpr (std::is_same_v<Child, Record>)
     {
@@ -401,11 +430,11 @@ void ScientificDefaults<Child>::defaults_impl()
                 asChild().setAttribute("timeOffset", val);
             }))(wor);
 
-        addParentDefaults<BaseRecord<RecordComponent>, write>();
+        addParentDefaults<BaseRecord<RecordComponent>, write>(standard);
     }
     else if constexpr (std::is_same_v<Child, PatchRecord>)
     {
-        addParentDefaults<BaseRecord<PatchRecordComponent>, write>();
+        addParentDefaults<BaseRecord<PatchRecordComponent>, write>(standard);
     }
     else if constexpr (std::is_same_v<Child, RecordComponent>)
     {
@@ -434,7 +463,7 @@ void ScientificDefaults<Child>::defaults_impl()
                 this->asChild().setPosition(static_cast<decltype(val)>(val));
             }))(wor);
 
-        addParentDefaults<RecordComponent, write>();
+        addParentDefaults<RecordComponent, write>(standard);
     }
     else if constexpr (std::is_same_v<Child, PatchRecordComponent>)
     {
@@ -451,15 +480,15 @@ void ScientificDefaults<Child>::defaults_impl()
 }
 
 template <typename Child>
-void ScientificDefaults<Child>::addDefaults()
+void ScientificDefaults<Child>::addDefaults(OpenpmdStandard standard)
 {
-    defaults_impl</* write = */ true>();
+    defaults_impl</* write = */ true>(standard);
 }
 
 template <typename Child>
-void ScientificDefaults<Child>::readDefaults()
+void ScientificDefaults<Child>::readDefaults(OpenpmdStandard standard)
 {
-    defaults_impl</* write = */ false>();
+    defaults_impl</* write = */ false>(standard);
 }
 
 template class ScientificDefaults<Iteration>;

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ Iteration &Iteration::close(bool _flush)`
`113`	`113`
`114`	`114`	`if (access::write(IOHandler()->m_frontendAccess))`
`115`	`115`	`{`
`116`		`- addDefaultsRecursively();`
	`116`	`+ addDefaultsRecursively(IOHandler()->m_standard);`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`if (_flush)`
`@@ -503,7 +503,8 @@ void Iteration::read_impl(std::string const &groupPath)`
`503`	`503`	`pOpen.path = groupPath;`
`504`	`504`	`IOHandler()->enqueue(IOTask(this, pOpen));`
`505`	`505`
`506`		`- internal::ScientificDefaults<Iteration>::readDefaults();`
	`506`	`+ internal::ScientificDefaults<Iteration>::readDefaults(`
	`507`	`+ IOHandler()->m_standard);`
`507`	`508`
`508`	`509`	`/* Find the root point [Series] of this file,`
`509`	`510`	`* meshesPath and particlesPath are stored there */`
Original file line number	Diff line number	Diff line change
`@@ -768,7 +768,8 @@ inline bool BaseRecord<T_elem>::scalar() const`
`768`	`768`	`template <typename T_elem>`
`769`	`769`	`inline void BaseRecord<T_elem>::readBase()`
`770`	`770`	`{`
`771`		`- internal::ScientificDefaults<BaseRecord<T_elem>>::readDefaults();`
	`771`	`+ internal::ScientificDefaults<BaseRecord<T_elem>>::readDefaults(`
	`772`	`+ this->IOHandler()->m_standard);`
`772`	`773`	`}`
`773`	`774`
`774`	`775`	`template <typename T_elem>`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,8 @@ MeshRecordComponent::MeshRecordComponent(`
`39`	`39`
`40`	`40`	`void MeshRecordComponent::read()`
`41`	`41`	`{`
`42`		`- internal::ScientificDefaults<MeshRecordComponent>::readDefaults();`
	`42`	`+ internal::ScientificDefaults<MeshRecordComponent>::readDefaults(`
	`43`	`+ IOHandler()->m_standard);`
`43`	`44`
`44`	`45`	`readBase();`
`45`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#include "openPMD/backend/ScientificDefaults.hpp"`
	`2`	`+#include "openPMD/IO/AbstractIOHandler.hpp"`
`2`	`3`	`#include "openPMD/ThrowError.hpp"`
`3`	`4`	`#include "openPMD/backend/ScientificDefaults_internal.hpp"`
`4`	`5`
`@@ -99,23 +100,23 @@ template <typename GetDefaultValue>`
`99`	`100`
`100`	`101`	`template <typename Child>`
`101`	`102`	`template <typename Parent, bool write>`
`102`		`-void ScientificDefaults<Child>::addParentDefaults()`
	`103`	`+void ScientificDefaults<Child>::addParentDefaults(OpenpmdStandard standard)`
`103`	`104`	`{`
`104`	`105`	`// Cannot directly call read_impl as it is private`
`105`	`106`	`if constexpr (write)`
`106`	`107`	`{`
`107`		`- asChild().ScientificDefaults<Parent>::addDefaults();`
	`108`	`+ asChild().ScientificDefaults<Parent>::addDefaults(standard);`
`108`	`109`	`}`
`109`	`110`	`else`
`110`	`111`	`{`
`111`		`- asChild().ScientificDefaults<Parent>::readDefaults();`
	`112`	`+ asChild().ScientificDefaults<Parent>::readDefaults(standard);`
`112`	`113`	`}`
`113`	`114`	`}`
`114`	`115`
`115`	`116`	`template <typename Child>`
`116`		`-void ScientificDefaults<Child>::addDefaultsRecursively()`
	`117`	`+void ScientificDefaults<Child>::addDefaultsRecursively(OpenpmdStandard standard)`
`117`	`118`	`{`
`118`		`- addDefaults();`
	`119`	`+ addDefaults(standard);`
`119`	`120`	`if constexpr (IsContainer_v<Child>)`
`120`	`121`	`{`
`121`	`122`	`using Container_t = AsContainer_t<Child>;`
`@@ -125,7 +126,8 @@ void ScientificDefaults<Child>::addDefaultsRecursively()`
`125`	`126`	`for (auto &[_, right] : asChild())`
`126`	`127`	`{`
`127`	`128`	`(void)_;`
`128`		`- right.ScientificDefaults<mapped_type>::addDefaultsRecursively();`
	`129`	`+ right.ScientificDefaults<mapped_type>::addDefaultsRecursively(`
	`130`	`+ standard);`
`129`	`131`	`}`
`130`	`132`	`}`
`131`	`133`	`}`
`@@ -136,20 +138,22 @@ void ScientificDefaults<Child>::addDefaultsRecursively()`
`136`	`138`	`for (auto &[_, right] : asChild().meshes)`
`137`	`139`	`{`
`138`	`140`	`(void)_;`
`139`		`- right.ScientificDefaults<Mesh>::addDefaultsRecursively();`
	`141`	`+ right.ScientificDefaults<Mesh>::addDefaultsRecursively(standard);`
`140`	`142`	`}`
`141`	`143`	`for (auto &[_, right] : asChild().particles)`
`142`	`144`	`{`
`143`	`145`	`(void)_;`
`144`		`- right.ScientificDefaults<ParticleSpecies>::addDefaultsRecursively();`
	`146`	`+ right.ScientificDefaults<ParticleSpecies>::addDefaultsRecursively(`
	`147`	`+ standard);`
`145`	`148`	`}`
`146`	`149`	`}`
`147`	`150`	`else if constexpr (std::is_same_v<Child, ParticleSpecies>)`
`148`	`151`	`{`
`149`	`152`	`for (auto &[_, right] : asChild().particlePatches)`
`150`	`153`	`{`
`151`	`154`	`(void)_;`
`152`		`- right.ScientificDefaults<PatchRecord>::addDefaultsRecursively();`
	`155`	`+ right.ScientificDefaults<PatchRecord>::addDefaultsRecursively(`
	`156`	`+ standard);`
`153`	`157`	`}`
`154`	`158`	`}`
`155`	`159`	`}`
`@@ -220,7 +224,7 @@ auto ensureFloatingScalar(SetterFunctor &&set)`
`220`	`224`
`221`	`225`	`template <typename Child>`
`222`	`226`	`template <bool write>`
`223`		`-void ScientificDefaults<Child>::defaults_impl()`
	`227`	`+void ScientificDefaults<Child>::defaults_impl(OpenpmdStandard standard)`
`224`	`228`	`{`
`225`	`229`	`using maybe_read_error = std::optional<error::ReadError>;`
`226`	`230`	`constexpr auto const wor = write ? WriteOrRead::Write : WriteOrRead::Read;`
`@@ -376,7 +380,32 @@ void ScientificDefaults<Child>::defaults_impl()`
`376`	`380`	`asChild().setAttribute("timeOffset", val);`
`377`	`381`	`}))(wor);`
`378`	`382`
`379`		`- addParentDefaults<BaseRecord<MeshRecordComponent>, write>();`
	`383`	`+ if (standard >= OpenpmdStandard::v_2_0_0)`
	`384`	`+ {`
	`385`	`+ defaultAttribute(`
	`386`	`+ "gridUnitSI",`
	`387`	`+ [&]() {`
	`388`	`+ if (dimensionality < 100)`
	`389`	`+ {`
	`390`	`+ return std::vector<double>(dimensionality, 1.);`
	`391`	`+ }`
	`392`	`+ else`
	`393`	`+ {`
	`394`	`+ return std::vector<double>{1.};`
	`395`	`+ }`
	`396`	`+ })`
	`397`	`+ .template withSetter<std::vector<double> const &>(`
	`398`	`+ &Mesh::setGridUnitSIPerDimension)`
	`399`	`+ .withReader()(wor);`
	`400`	`+ }`
	`401`	`+ else`
	`402`	`+ {`
	`403`	`+ defaultAttribute("gridUnitSI", 1.0)`
	`404`	`+ .withSetter(&Mesh::setGridUnitSI)`
	`405`	`+ .withReader()(wor);`
	`406`	`+ }`
	`407`	`+`
	`408`	`+ addParentDefaults<BaseRecord<MeshRecordComponent>, write>(standard);`
`380`	`409`	`}`
`381`	`410`	`else if constexpr (std::is_same_v<Child, Record>)`
`382`	`411`	`{`
`@@ -401,11 +430,11 @@ void ScientificDefaults<Child>::defaults_impl()`
`401`	`430`	`asChild().setAttribute("timeOffset", val);`
`402`	`431`	`}))(wor);`
`403`	`432`
`404`		`- addParentDefaults<BaseRecord<RecordComponent>, write>();`
	`433`	`+ addParentDefaults<BaseRecord<RecordComponent>, write>(standard);`
`405`	`434`	`}`
`406`	`435`	`else if constexpr (std::is_same_v<Child, PatchRecord>)`
`407`	`436`	`{`
`408`		`- addParentDefaults<BaseRecord<PatchRecordComponent>, write>();`
	`437`	`+ addParentDefaults<BaseRecord<PatchRecordComponent>, write>(standard);`
`409`	`438`	`}`
`410`	`439`	`else if constexpr (std::is_same_v<Child, RecordComponent>)`
`411`	`440`	`{`
`@@ -434,7 +463,7 @@ void ScientificDefaults<Child>::defaults_impl()`
`434`	`463`	`this->asChild().setPosition(static_cast<decltype(val)>(val));`
`435`	`464`	`}))(wor);`
`436`	`465`
`437`		`- addParentDefaults<RecordComponent, write>();`
	`466`	`+ addParentDefaults<RecordComponent, write>(standard);`
`438`	`467`	`}`
`439`	`468`	`else if constexpr (std::is_same_v<Child, PatchRecordComponent>)`
`440`	`469`	`{`
`@@ -451,15 +480,15 @@ void ScientificDefaults<Child>::defaults_impl()`
`451`	`480`	`}`
`452`	`481`
`453`	`482`	`template <typename Child>`
`454`		`-void ScientificDefaults<Child>::addDefaults()`
	`483`	`+void ScientificDefaults<Child>::addDefaults(OpenpmdStandard standard)`
`455`	`484`	`{`
`456`		`- defaults_impl</* write = */ true>();`
	`485`	`+ defaults_impl</* write = */ true>(standard);`
`457`	`486`	`}`
`458`	`487`
`459`	`488`	`template <typename Child>`
`460`		`-void ScientificDefaults<Child>::readDefaults()`
	`489`	`+void ScientificDefaults<Child>::readDefaults(OpenpmdStandard standard)`
`461`	`490`	`{`
`462`		`- defaults_impl</* write = */ false>();`
	`491`	`+ defaults_impl</* write = */ false>(standard);`
`463`	`492`	`}`
`464`	`493`
`465`	`494`	`template class ScientificDefaults<Iteration>;`