Revert incorrect changes to ForceStaticMeshFilter

Filters/Temporal/Testing/Cxx/TestForceStaticMesh.cxx

 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 // SPDX-License-Identifier: BSD-3-Clause
+
 #include "vtkActor.h"
 #include "vtkConeSource.h"
 #include "vtkDataSetMapper.h"
 #include "vtkForceStaticMesh.h"
 #include "vtkGenerateTimeSteps.h"
 #include "vtkGroupDataSetsFilter.h"
-#include "vtkImageData.h"
-#include "vtkInformation.h"
-#include "vtkInformationVector.h"
+#include "vtkLogger.h"
 #include "vtkNew.h"
 #include "vtkObjectFactory.h"
 #include "vtkPartitionedDataSetCollection.h"
-#include "vtkPointData.h"
 #include "vtkRandomAttributeGenerator.h"
 #include "vtkRenderWindow.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
-#include "vtkStreamingDemandDrivenPipeline.h"
-#include "vtkUnstructuredGrid.h"
+#include "vtkType.h"
+#include <cstdlib>
+
+//------------------------------------------------------------------------------
+void GetPartitionsMeshMTimes(
+  vtkPartitionedDataSetCollection* pdsc, std::vector<vtkMTimeType>& times)
+{
+  vtkSmartPointer<vtkCompositeDataIterator> iter;
+  iter.TakeReference(pdsc->NewIterator());
+  for (iter->GoToFirstItem(); !iter->IsDoneWithTraversal(); iter->GoToNextItem())
+  {
+    auto ds = vtkDataSet::SafeDownCast(iter->GetCurrentDataObject());
+    vtkMTimeType time = ds ? ds->GetMeshMTime() : -1;
+    times.push_back(time);
+  }
+}
 
 //------------------------------------------------------------------------------
 // Program main
@@ -57,22 +69,29 @@ int TestForceStaticMesh(int vtkNotUsed(argc), char* vtkNotUsed(argv)[])
 
   auto outputPDC =
     vtkPartitionedDataSetCollection::SafeDownCast(forceStatic->GetOutputDataObject(0));
-  auto outputPD = vtkPolyData::SafeDownCast(outputPDC->GetPartitionAsDataObject(0, 0));
-  const auto initMeshTime = outputPD->GetMeshMTime();
+
+  std::vector<vtkMTimeType> beforeMeshMTimes;
+  ::GetPartitionsMeshMTimes(outputPDC, beforeMeshMTimes);
 
   forceStatic->UpdateTimeStep(2); // update scalars, not mesh
 
   outputPDC = vtkPartitionedDataSetCollection::SafeDownCast(forceStatic->GetOutputDataObject(0));
-  outputPD = vtkPolyData::SafeDownCast(outputPDC->GetPartitionAsDataObject(0, 0));
-  if (outputPD->GetMeshMTime() == initMeshTime)
-  {
-    std::cout << "Time comparison OK." << std::endl;
-  }
-  else
+  std::vector<vtkMTimeType> afterMeshMTimes;
+  ::GetPartitionsMeshMTimes(outputPDC, afterMeshMTimes);
+
+  for (auto beforeIt = beforeMeshMTimes.begin(), afterIt = afterMeshMTimes.begin();
+       beforeIt != beforeMeshMTimes.end() && afterIt != afterMeshMTimes.end();
+       ++beforeIt, ++afterIt)
   {
-    std::cerr << "ERROR: GetMeshMTime has changed, mesh not static !" << std::endl;
+    if (*beforeIt != *afterIt)
+    {
+      vtkLog(ERROR, "GetMeshMTime has changed, mesh not static !");
+      return EXIT_FAILURE;
+    }
   }
 
+  auto outputPD = vtkPolyData::SafeDownCast(outputPDC->GetPartitionAsDataObject(0, 0));
+
   vtkNew<vtkDataSetMapper> mapper;
   mapper->SetInputData(outputPD);
   mapper->SetScalarRange(0, 30);

Filters/Temporal/vtkForceStaticMesh.cxx

@@ -83,88 +83,95 @@ int vtkForceStaticMesh::RequestData(vtkInformation* vtkNotUsed(request),
 //------------------------------------------------------------------------------
 bool vtkForceStaticMesh::IsValidCache(vtkDataSet* input)
 {
-  bool validCache = this->CacheInitialized;
-  if (validCache)
+  if (!this->CacheInitialized || !this->Cache)
   {
-    if (!this->Cache)
-    {
-      // Not initialized
-      validCache = false;
-    }
-    vtkDataSet* internalCache = vtkDataSet::SafeDownCast(this->Cache);
-    if (input->GetMeshMTime() > internalCache->GetMeshMTime())
-    {
-      vtkWarningMacro("Cache has been invalidated, mesh modification time is more recent: "
-        << input->GetMeshMTime() << " (input) > " << internalCache->GetMeshMTime() << " (cache)");
-      validCache = false;
-    }
+    // Not initialized
+    return false;
+  }
+
+  vtkDataSet* internalCache = vtkDataSet::SafeDownCast(this->Cache);
+  if (input->GetNumberOfPoints() != internalCache->GetNumberOfPoints())
+  {
+    vtkWarningMacro("Cache has been invalidated, the number of points in input changed, from "
+      << internalCache->GetNumberOfPoints() << " to " << input->GetNumberOfPoints());
+    return false;
+  }
+
+  if (input->GetNumberOfCells() != internalCache->GetNumberOfCells())
+  {
+    vtkWarningMacro("Cache has been invalidated, the number of cells in input changed, from "
+      << internalCache->GetNumberOfCells() << " to " << input->GetNumberOfCells());
+    return false;
   }
-  return validCache;
+
+  return true;
 }
 
 //------------------------------------------------------------------------------
 bool vtkForceStaticMesh::IsValidCache(vtkCompositeDataSet* input)
 {
-  bool validCache = this->CacheInitialized;
-  if (validCache)
+  if (!this->CacheInitialized || !this->Cache)
+  {
+    // Not initialized
+    return false;
+  }
+
+  vtkCompositeDataSet* internalCache = vtkCompositeDataSet::SafeDownCast(this->Cache);
+  assert(internalCache);
+
+  // Dataset-wide comparisons
+  if (input->GetNumberOfPoints() != internalCache->GetNumberOfPoints())
   {
-    if (!this->Cache)
+    vtkWarningMacro("Cache has been invalidated, the number of points in input changed, from "
+      << internalCache->GetNumberOfPoints() << " to " << input->GetNumberOfPoints());
+    return false;
+  }
+
+  if (input->GetNumberOfCells() != internalCache->GetNumberOfCells())
+  {
+    vtkWarningMacro("Cache has been invalidated, the number of cells in input changed, from "
+      << internalCache->GetNumberOfCells() << " to " << input->GetNumberOfCells());
+    return false;
+  }
+
+  // Per block comparisons
+  auto compIterator = vtkSmartPointer<vtkCompositeDataIterator>::Take(internalCache->NewIterator());
+  for (compIterator->InitTraversal(); !compIterator->IsDoneWithTraversal();
+       compIterator->GoToNextItem())
+  {
+    // Both composite must have the same structure by construction,
+    // we can use the GetDataSet with iterator from other composite
+    vtkDataSet* cacheBlock = vtkDataSet::SafeDownCast(internalCache->GetDataSet(compIterator));
+    vtkDataSet* inputBlock = vtkDataSet::SafeDownCast(input->GetDataSet(compIterator));
+
+    if ((cacheBlock == nullptr) != (inputBlock == nullptr))
     {
-      // Not initialized
-      validCache = false;
+      // if one of them is dataset and not the other:
+      // not the same internal structure, invalid cache
+      return false;
     }
-    vtkCompositeDataSet* internalCache = vtkCompositeDataSet::SafeDownCast(this->Cache);
-    assert(internalCache);
 
-    // Global parameters
-    if (input->GetNumberOfPoints() != internalCache->GetNumberOfPoints())
+    if (!cacheBlock /*&& inputBlock */)
     {
-      vtkWarningMacro("Cache has been invalidated, the number of points in input changed, from "
-        << internalCache->GetNumberOfPoints() << " to " << input->GetNumberOfPoints());
-      validCache = false;
+      // Skip non-dataset blocks
+      continue;
     }
-    if (input->GetNumberOfCells() != internalCache->GetNumberOfCells())
+
+    if (inputBlock->GetNumberOfPoints() != cacheBlock->GetNumberOfPoints())
     {
-      vtkWarningMacro("Cache has been invalidated, the number of cells in input changed, from "
-        << internalCache->GetNumberOfCells() << " to " << input->GetNumberOfCells());
-      validCache = false;
+      vtkWarningMacro("Cache has been invalidated, the number of points in a block changed, from "
+        << cacheBlock->GetNumberOfPoints() << " to " << inputBlock->GetNumberOfPoints());
+      return false;
     }
 
-    // Per block parameters
-
-    auto compIterator =
-      vtkSmartPointer<vtkCompositeDataIterator>::Take(internalCache->NewIterator());
-    for (compIterator->InitTraversal(); !compIterator->IsDoneWithTraversal();
-         compIterator->GoToNextItem())
+    if (inputBlock->GetNumberOfCells() != cacheBlock->GetNumberOfCells())
     {
-      // Both composite must have the same structure by construction,
-      // we can use the GetDataSet with iterator from other composite
-      vtkDataSet* cacheBlock = vtkDataSet::SafeDownCast(internalCache->GetDataSet(compIterator));
-      vtkDataSet* inputBlock = vtkDataSet::SafeDownCast(input->GetDataSet(compIterator));
-
-      if ((cacheBlock == nullptr) != (inputBlock == nullptr))
-      {
-        // if one of them is dataset and not the other:
-        // not the same internal structure, invalid cache
-        validCache = false;
-        break;
-      }
-
-      if (cacheBlock /*&& inputBlock */)
-      {
-        if (inputBlock->GetMeshMTime() > cacheBlock->GetMeshMTime())
-        {
-          vtkWarningMacro(
-            "Cache has been invalidated, a block's mesh modification time is more recent"
-            << inputBlock->GetMeshMTime() << " (input) > " << cacheBlock->GetMeshMTime()
-            << " (cache)");
-          validCache = false;
-          break;
-        }
-      }
+      vtkWarningMacro("Cache has been invalidated, the number of cells in a block changed, from "
+        << cacheBlock->GetNumberOfCells() << " to " << inputBlock->GetNumberOfCells());
+      return false;
     }
   }
-  return validCache;
+  return true;
 }
 
 //------------------------------------------------------------------------------