Fix dirty handling filebased

Author: franzpoeschel

src/Iteration.cpp

@@ -401,16 +401,28 @@ void Iteration::flush(internal::FlushParams const &flushParams)
          * meshesPath and particlesPath are stored there */
         Series s = retrieveSeries();
 
-        if (!meshes.empty() || s.containsAttribute("meshesPath"))
-        {
-            if (!s.containsAttribute("meshesPath") &&
-                flushParams.flushLevel != FlushLevel::CreateOrOpenFiles)
+        auto set_and_get_mp_path =
+            [&](char const *attrName,
+                char const *defaultVal,
+                Series &(Series::*set)(std::string const &)) -> std::string {
+            if (s.containsAttribute(attrName))
+            {
+                return s.getAttribute(attrName).get<std::string>();
+            }
+            else
             {
-                s.setMeshesPath("meshes/");
+                (s.*set)(defaultVal);
+                return defaultVal;
             }
+        };
+
+        if (!meshes.empty() || s.containsAttribute("meshesPath"))
+        {
+            auto meshesPath = set_and_get_mp_path(
+                "meshesPath", "meshes/", &Series::setMeshesPath);
             if (meshes.dirtyRecursive())
             {
-                meshes.flush(s.meshesPath(), flushParams);
+                meshes.flush(meshesPath, flushParams);
                 for (auto &m : meshes)
                 {
                     m.second.flush(m.first, flushParams);
@@ -424,14 +436,11 @@ void Iteration::flush(internal::FlushParams const &flushParams)
 
         if (!particles.empty() || s.containsAttribute("particlesPath"))
         {
-            if (!s.containsAttribute("particlesPath") &&
-                flushParams.flushLevel != FlushLevel::CreateOrOpenFiles)
-            {
-                s.setParticlesPath("particles/");
-            }
+            auto particlesPath = set_and_get_mp_path(
+                "particlesPath", "particles/", &Series::setParticlesPath);
             if (particles.dirtyRecursive())
             {
-                particles.flush(s.particlesPath(), flushParams);
+                particles.flush(particlesPath, flushParams);
                 for (auto &species : particles)
                 {
                     species.second.flush(species.first, flushParams);

src/Series.cpp

@@ -1493,6 +1493,12 @@ void Series::flushFileBased(
     case Access::APPEND_RANDOM_ACCESS:
     case Access::APPEND_LINEAR: {
         bool allDirty = dirty();
+        // In flush level SkeletonOnly, we might need to set some attributes
+        // (especially: particlesPath, meshesPath), but cannot flush them yet
+        // (as writing attributes is only permissible at higher flush levels).
+        // This flag records if the Series became dirty during this flush. If
+        // yes, we set the Series back to dirty at the end of flushing.
+        bool hasBecomeDirty = false;
         for (auto it = begin; it != end; ++it)
         {
             // Phase 1
@@ -1545,9 +1551,27 @@ void Series::flushFileBased(
              * TODO: Ideally, we would skip this in SkeletonOnly flush mode, but
              * for some reason, this leads to hanging parallel tests..?
              */
+            if (flushParams.flushLevel == FlushLevel::SkeletonOnly)
+            {
+                if (allDirty && !dirty())
+                {
+                    throw error::Internal(
+                        "Flush mode SkeletonOnly must not unset dirty flags.");
+                }
+                hasBecomeDirty |=
+                    flushParams.flushLevel == FlushLevel::SkeletonOnly &&
+                    !allDirty && dirty();
+            }
             setDirty(allDirty);
         }
-        determineUnsetDirty(flushParams.flushLevel);
+        if (!hasBecomeDirty)
+        {
+            determineUnsetDirty(flushParams.flushLevel);
+        }
+        else
+        {
+            setDirty(true);
+        }
         // Phase 3
         if (flushIOHandler)
         {