Documentation/release/dev/multithread-openfoamreader.md

+## vtkOpenFOAMReader: Multithreaded Reading of case files
+
+`vtkOpenFOAMReader` now supports multithreaded reading of case files. This feature is of by default, but it can be
+enabled using the`SetSequentialProcessing(false)`. It can be useful to enabled when reading large case files that
+are stored on a network drive. If the case file is stored on a local drive, it is recommended to keep this feature off.

IO/Geometry/vtkOpenFOAMReader.cxx

@@ -1029,6 +1029,9 @@ public:
   void SetupInformation(const std::string& casePath, const std::string& regionName,
     const std::string& procName, vtkOpenFOAMReaderPrivate* master, bool requirePolyMesh = true);
 
+  void SetProgress(double progress) { this->Progress = progress; }
+  double GetProgress() const { return this->Progress; }
+
 private:
   vtkOpenFOAMReader* Parent;
 
@@ -1054,6 +1057,8 @@ private:
   int InternalMeshSelectionStatus;
   int InternalMeshSelectionStatusOld;
 
+  double Progress = 0;
+
   // filenames / directories
   vtkStringArray* VolFieldFiles;
   vtkStringArray* DimFieldFiles;
@@ -8581,7 +8586,7 @@ void vtkOpenFOAMReaderPrivate::InterpolateCellToPoint(vtkFloatArray* pData, vtkF
           auto lenIt = length.begin() + first;
           auto vcIt = vc.begin() + first;
           for (auto it = reduce.begin() + first; it != reduce.begin() + last;
-               ++it, ++volIt, ++areaIt, ++lenIt, ++vcIt)
+            ++it, ++volIt, ++areaIt, ++lenIt, ++vcIt)
           {
             *it = (*volIt > 0
                 ? *volIt
@@ -9131,7 +9136,7 @@ void vtkOpenFOAMReaderPrivate::GetVolFieldAtTimeStep(
         // assign cell values to additional points
         const vtkIdType nAddPoints = this->AdditionalCellIds->GetNumberOfTuples();
         for (vtkIdType pointi = 0, newPointi = this->NumPoints; pointi < nAddPoints;
-             ++pointi, ++newPointi)
+          ++pointi, ++newPointi)
         {
           ctpData->SetTuple(newPointi, this->AdditionalCellIds->GetValue(pointi), iData);
         }
@@ -10490,10 +10495,12 @@ bool vtkOpenFOAMReaderPrivate::GetAreaMesh(
 // return 0 if there's any error, 1 if success
 int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
 {
+  this->Parent->UpdateProgress(this, 0.0);
   if (!this->HasPolyMesh())
   {
     // Ignore a region without a mesh, but will normally be precluded earlier
     vtkWarningMacro("Called RequestData without a mesh.");
+    this->Parent->UpdateProgress(this, 1.0);
     return 1;
   }
 
@@ -10612,7 +10619,7 @@ int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
     {
       return 0;
     }
-    this->Parent->UpdateProgress(0.2);
+    this->Parent->UpdateProgress(this, 0.2);
   }
 
   if (createEulerians && recreateInternalMesh)
@@ -10626,7 +10633,7 @@ int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
     {
       return 0;
     }
-    this->Parent->UpdateProgress(0.3);
+    this->Parent->UpdateProgress(this, 0.3);
   }
 
   if (createEulerians &&
@@ -10645,7 +10652,7 @@ int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
     {
       return 0;
     }
-    this->Parent->UpdateProgress(0.4);
+    this->Parent->UpdateProgress(this, 0.4);
   }
 
   // Create internal mesh, only if required for display
@@ -10810,7 +10817,7 @@ int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
   // Don't need mesh points beyond here...
   // Be explicit: pointArray = vtkSmartPointer<vtkFloatArray>{};
 
-  this->Parent->UpdateProgress(0.5);
+  this->Parent->UpdateProgress(this, 0.5);
 
   // Eulerian variables
   if (updateVariables && createEulerians)
@@ -10882,23 +10889,23 @@ int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
     for (vtkIdType i = 0; i < this->VolFieldFiles->GetNumberOfValues(); ++i)
     {
       this->GetVolFieldAtTimeStep(this->VolFieldFiles->GetValue(i));
-      this->Parent->UpdateProgress(0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
+      this->Parent->UpdateProgress(this, 0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
     }
     for (vtkIdType i = 0; i < this->DimFieldFiles->GetNumberOfValues(); ++i)
     {
       this->GetVolFieldAtTimeStep(this->DimFieldFiles->GetValue(i), true); // Internal field
-      this->Parent->UpdateProgress(0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
+      this->Parent->UpdateProgress(this, 0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
     }
     for (vtkIdType i = 0; i < this->PointFieldFiles->GetNumberOfValues(); ++i)
     {
       this->GetPointFieldAtTimeStep(this->PointFieldFiles->GetValue(i));
-      this->Parent->UpdateProgress(0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
+      this->Parent->UpdateProgress(this, 0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
     }
 #if VTK_FOAMFILE_FINITE_AREA
     for (vtkIdType i = 0; i < this->AreaFieldFiles->GetNumberOfValues(); ++i)
     {
       this->GetAreaFieldAtTimeStep(this->AreaFieldFiles->GetValue(i));
-      this->Parent->UpdateProgress(0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
+      this->Parent->UpdateProgress(this, 0.5 + (0.5 * ++nFieldsRead) / nFieldsToRead);
     }
 #endif
   }
@@ -10992,7 +10999,7 @@ int vtkOpenFOAMReaderPrivate::RequestData(vtkMultiBlockDataSet* output)
   }
   this->InternalMeshSelectionStatusOld = this->InternalMeshSelectionStatus;
 
-  this->Parent->UpdateProgress(1.0);
+  this->Parent->UpdateProgress(this, 1.0);
   return 1;
 }
 
@@ -11006,6 +11013,8 @@ vtkOpenFOAMReader::vtkOpenFOAMReader()
   // must be false to avoid reloading by vtkAppendCompositeDataLeaves::Update()
   this->Refresh = false;
 
+  this->SequentialProcessing = false;
+
   // initialize file name
   this->FileName = nullptr;
 
@@ -11059,7 +11068,6 @@ vtkOpenFOAMReader::vtkOpenFOAMReader()
   // Lagrangian paths
   this->LagrangianPaths = vtkStringArray::New();
 
-  this->CurrentReaderIndex = 0;
   this->Use64BitLabels = false;
   this->Use64BitFloats = true;
   this->Use64BitLabelsOld = false;
@@ -11257,6 +11265,8 @@ int vtkOpenFOAMReader::RequestInformation(vtkInformation* vtkNotUsed(request),
   return 1;
 }
 
+static std::atomic<int> Id = 0;
+
 //------------------------------------------------------------------------------
 // RequestData
 int vtkOpenFOAMReader::RequestData(vtkInformation* vtkNotUsed(request),
@@ -11265,6 +11275,11 @@ int vtkOpenFOAMReader::RequestData(vtkInformation* vtkNotUsed(request),
   vtkInformation* outInfo = outputVector->GetInformationObject(0);
   auto* output = vtkMultiBlockDataSet::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
 
+  int readerId = Id++;
+  // std::cout << readerId << " vtkOpenFOAMReader::RequestData has " << this->Readers.size()
+  //           << " readers" << std::endl;
+  auto start = std::chrono::high_resolution_clock::now();
+
   // Times
   {
     int nTimes(0); // Also used for logic
@@ -11293,7 +11308,6 @@ int vtkOpenFOAMReader::RequestData(vtkInformation* vtkNotUsed(request),
     {
       return 0;
     }
-    this->CurrentReaderIndex = 0;
   }
 
   // Create dataset
@@ -11305,19 +11319,41 @@ int vtkOpenFOAMReader::RequestData(vtkInformation* vtkNotUsed(request),
     (reader = vtkOpenFOAMReaderPrivate::SafeDownCast(this->Readers[0]))->GetRegionName().empty())
   {
     ret = reader->RequestData(output);
-    this->Parent->CurrentReaderIndex++;
   }
   else
   {
-    for (auto& readerObj : this->Readers)
+    // Reader each file in parallel
+    std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> subOutputs(this->Readers.size());
+    auto readersProcessing = [&](vtkIdType begin, vtkIdType end) -> void
+    {
+      for (vtkIdType readerId = begin; readerId < end; ++readerId)
+      {
+        auto localReader = vtkOpenFOAMReaderPrivate::SafeDownCast(this->Readers[readerId]);
+        if (!localReader)
+        {
+          continue;
+        }
+        auto subOutput = vtkSmartPointer<vtkMultiBlockDataSet>::New();
+        const int res = localReader->RequestData(subOutput);
+        subOutputs[readerId] = res ? subOutput : nullptr;
+      }
+    };
+    if (this->GetSequentialProcessing())
+    {
+      readersProcessing(0, static_cast<vtkIdType>(this->Readers.size()));
+    }
+    else
+    {
+      vtkSMPTools::For(0, static_cast<vtkIdType>(this->Readers.size()), readersProcessing);
+    }
+    for (size_t i = 0; i < this->Readers.size(); ++i)
     {
-      reader = vtkOpenFOAMReaderPrivate::SafeDownCast(readerObj);
+      reader = vtkOpenFOAMReaderPrivate::SafeDownCast(this->Readers[i]);
       if (!reader)
       {
         continue;
       }
-      auto subOutput = vtkSmartPointer<vtkMultiBlockDataSet>::New();
-      if (reader->RequestData(subOutput))
+      if (auto& subOutput = subOutputs[i])
       {
         std::string regionName(reader->GetRegionName());
         if (regionName.empty())
@@ -11333,7 +11369,6 @@ int vtkOpenFOAMReader::RequestData(vtkInformation* vtkNotUsed(request),
       {
         ret = 0;
       }
-      this->Parent->CurrentReaderIndex++;
     }
   }
 
@@ -11341,6 +11376,10 @@ int vtkOpenFOAMReader::RequestData(vtkInformation* vtkNotUsed(request),
   {
     this->UpdateStatus();
   }
+  auto end = std::chrono::high_resolution_clock::now();
+  // std::cout << readerId << " vtkOpenFOAMReader::RequestData: Elapsed time: "
+  //           << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms"
+  //           << std::endl;
 
   return ret;
 }
@@ -11744,11 +11783,37 @@ void vtkOpenFOAMReader::UpdateStatus()
 }
 
 //------------------------------------------------------------------------------
-void vtkOpenFOAMReader::UpdateProgress(double amount)
+double vtkOpenFOAMReader::ComputeProgress()
 {
-  this->vtkAlgorithm::UpdateProgress(
-    (static_cast<double>(this->Parent->CurrentReaderIndex) + amount) /
-    static_cast<double>(this->Parent->Readers.size()));
+  // get valid readers
+  std::vector<vtkOpenFOAMReaderPrivate*> readers;
+  for (auto& readerObj : this->Readers)
+  {
+    if (auto reader = vtkOpenFOAMReaderPrivate::SafeDownCast(readerObj))
+    {
+      readers.push_back(reader);
+    }
+  }
+  // compute the current progress
+  if (!readers.empty())
+  {
+    // compute the current progress
+    const double sum = std::accumulate(readers.begin(), readers.end(), 0.0,
+      [](double acc, const auto& reader) { return acc + reader->GetProgress(); });
+    return sum / readers.size();
+  }
+  return 1.0;
+}
+
+//------------------------------------------------------------------------------
+void vtkOpenFOAMReader::UpdateProgress(vtkOpenFOAMReaderPrivate* reader, double amount)
+{
+  // Update progress for the reader
+  reader->SetProgress(amount);
+  // lock the progress mutex
+  std::lock_guard<std::mutex> lock(this->ProgressMutex);
+  // update the progress
+  this->vtkAlgorithm::UpdateProgress(this->GetProgress());
 }
 
 VTK_ABI_NAMESPACE_END

IO/Geometry/vtkOpenFOAMReader.h

@@ -38,6 +38,8 @@
 #include "vtkIOGeometryModule.h" // For export macro
 #include "vtkMultiBlockDataSetAlgorithm.h"
 
+#include <mutex> // For std::mutex
+
 VTK_ABI_NAMESPACE_BEGIN
 class vtkCollection;
 class vtkCharArray;
@@ -70,6 +72,22 @@ public:
   vtkGetFilePathMacro(FileName);
   ///@}
 
+  ///@{
+  /**
+   * Set/Get If sequential (instead of multithreaded) processing is utilized for reading each case
+   * files.
+   *
+   * By default, this is off because if on, it may yield better results if data are located at a
+   * network drive since the speed of reading data is limited by the network speed. Nonetheless, it
+   * may be slower if data are located at a local drive (most common case) since the speed of
+   * reading data is limited by the speed of the local drive, which is substantially faster than the
+   * network speed.
+   */
+  vtkSetMacro(SequentialProcessing, bool);
+  vtkGetMacro(SequentialProcessing, bool);
+  vtkBooleanMacro(SequentialProcessing, bool);
+  ///@}
+
   /**
    * Get the number of cell arrays available in the input.
    */
@@ -349,10 +367,17 @@ public:
 
   int MakeMetaDataAtTimeStep(bool);
 
+  /**
+   * Compute the progress of the reader.
+   */
+  virtual double ComputeProgress();
+
 protected:
   // refresh flag
   bool Refresh;
 
+  bool SequentialProcessing;
+
   // for creating cell-to-point translated data
   vtkTypeBool CreateCellToPoint;
 
@@ -437,9 +462,6 @@ protected:
   // paths to Lagrangians
   vtkStringArray* LagrangianPaths;
 
-  // index of the active reader
-  int CurrentReaderIndex;
-
   vtkOpenFOAMReader();
   ~vtkOpenFOAMReader() override;
   int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
@@ -449,7 +471,7 @@ protected:
   void SetTimeInformation(vtkInformationVector*, vtkDoubleArray*);
   void CreateCharArrayFromString(vtkCharArray*, const char*, vtkStdString&);
   void UpdateStatus();
-  void UpdateProgress(double);
+  void UpdateProgress(vtkOpenFOAMReaderPrivate* reader, double progress);
 
 private:
   vtkOpenFOAMReader* Parent;
@@ -468,6 +490,8 @@ private:
 
   // Print some time information (names, current time-step)
   void PrintTimes(std::ostream& os, vtkIndent indent = vtkIndent(), bool full = false) const;
+
+  std::mutex ProgressMutex;
 };
 
 VTK_ABI_NAMESPACE_END

IO/Parallel/vtkPOpenFOAMReader.cxx

@@ -65,12 +65,15 @@
 #include "vtkMultiBlockDataSet.h"
 #include "vtkMultiProcessController.h"
 #include "vtkObjectFactory.h"
+#include "vtkSMPTools.h"
 #include "vtkSortDataArray.h"
 #include "vtkStreamingDemandDrivenPipeline.h"
 #include "vtkStringArray.h"
 
+#include <algorithm>
 #include <cctype>
 #include <cstring>
+#include <numeric>
 
 //------------------------------------------------------------------------------
 
@@ -94,6 +97,9 @@ vtkSmartPointer<vtkOpenFOAMReader> NewFoamReader(vtkOpenFOAMReader* parent)
   reader->SetSkipZeroTime(parent->GetSkipZeroTime());
   reader->SetUse64BitLabels(parent->GetUse64BitLabels());
   reader->SetUse64BitFloats(parent->GetUse64BitFloats());
+  // This function is only used in the decomposed case, so we are basically multithread (if asked)
+  // over the processor dirs, but not over all /polyMesh/faces files of each processor dir.
+  reader->SetSequentialProcessing(true);
 
   return reader;
 }
@@ -390,6 +396,7 @@ int vtkPOpenFOAMReader::RequestInformation(
   const bool isRootProc = (this->ProcessId == 0);
   const bool isParallel = (this->NumProcesses > 1);
   int returnCode = 1;
+  auto start = std::chrono::high_resolution_clock::now();
 
   // Set handle piece request for all cases. Even if the reconstructed case is not actually
   // distributed, we need all processes to go through RequestData every time in order to go through
@@ -491,6 +498,7 @@ int vtkPOpenFOAMReader::RequestInformation(
 
         processorDirs = ::ScanForProcessorDirs(dir);
         nProcessorDirs = static_cast<int>(processorDirs->GetNumberOfTuples());
+        std::cout << "nProcessorDirs: " << nProcessorDirs << std::endl;
 
         if (nProcessorDirs)
         {
@@ -557,25 +565,46 @@ int vtkPOpenFOAMReader::RequestInformation(
     // Create reader instances for processor subdirectories,
     // skip first one since it has already been created above
 
+    std::vector<std::string> procDirNames;
     for (int dirIndex = (this->ProcessId ? this->ProcessId : this->NumProcesses);
-         dirIndex < nProcessorDirs; dirIndex += this->NumProcesses)
+      dirIndex < nProcessorDirs; dirIndex += this->NumProcesses)
     {
       const std::string procDirName = ::ProcessorDirName(processorDirs, dirIndex);
       vtkFoamDebug(<< "Additional processor dir: " << procDirName << "\n");
+      procDirNames.push_back(procDirName);
+    }
 
-      auto subReader = ::NewFoamReader(this);
-
-      // If getting metadata failed, simply skip the reader instance
-      if (subReader->MakeInformationVector(nullptr, procDirName, timeNames, timeValues) &&
-        subReader->MakeMetaDataAtTimeStep(true))
-      {
-        this->Superclass::Readers.emplace_back(subReader);
-      }
-      else
+    std::vector<vtkSmartPointer<vtkObject>> procReaders(procDirNames.size(), nullptr);
+    auto readersMakeInformationVector = [&](vtkIdType begin, vtkIdType end) -> void
+    {
+      for (vtkIdType i = begin; i < end; ++i)
       {
-        vtkWarningMacro(<< "Removing reader for processor subdirectory " << procDirName);
+        auto subReader = ::NewFoamReader(this);
+        // std::cout << procDirNames[i] << std::endl;
+        // If getting metadata failed, simply skip the reader instance
+        if (subReader->MakeInformationVector(nullptr, procDirNames[i], timeNames, timeValues) &&
+          subReader->MakeMetaDataAtTimeStep(true))
+        {
+          procReaders[i] = subReader;
+        }
+        else
+        {
+          vtkWarningMacro(<< "Removing reader for processor subdirectory " << procDirNames[i]);
+        }
       }
+    };
+    if (this->GetSequentialProcessing())
+    {
+      readersMakeInformationVector(0, static_cast<vtkIdType>(procReaders.size()));
+    }
+    else
+    {
+      vtkSMPTools::For(0, static_cast<vtkIdType>(procReaders.size()), readersMakeInformationVector);
     }
+    // move valid readers to the main list
+    std::copy_if(std::make_move_iterator(procReaders.begin()),
+      std::make_move_iterator(procReaders.end()), std::back_inserter(this->Superclass::Readers),
+      [](const auto& reader) { return reader != nullptr; });
 
     // Cleanup
     if (!isRootProc || (nProcessorDirs == 0))
@@ -593,6 +622,10 @@ int vtkPOpenFOAMReader::RequestInformation(
     this->GatherMetaData();
     this->Superclass::Refresh = false;
   }
+  auto end = std::chrono::high_resolution_clock::now();
+  std::cout << "vtkPOpenFOAMReader::RequestInformation: Elapsed time: "
+            << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms"
+            << std::endl;
 
   return returnCode;
 }
@@ -605,6 +638,7 @@ int vtkPOpenFOAMReader::RequestData(
   const bool isParallel = (this->NumProcesses > 1);
   int returnCode = 1;
 
+  auto start = std::chrono::high_resolution_clock::now();
   vtkSmartPointer<vtkMultiProcessController> splitController;
   vtkInformation* outInfo = outputVector->GetInformationObject(0);
   auto* output = vtkMultiBlockDataSet::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
@@ -661,25 +695,46 @@ int vtkPOpenFOAMReader::RequestData(
     vtkAppendCompositeDataLeaves* append = vtkAppendCompositeDataLeaves::New();
     // append->AppendFieldDataOn();
 
-    this->Superclass::CurrentReaderIndex = 0;
-    for (auto& readerObj : this->Superclass::Readers)
+    std::vector<int> updatedReaders(this->Superclass::Readers.size(), 0);
+    auto readersProcessing = [&](vtkIdType begin, vtkIdType end) -> void
     {
-      vtkOpenFOAMReader* reader = vtkOpenFOAMReader::SafeDownCast(readerObj);
-      if (!reader)
+      for (vtkIdType i = begin; i < end; ++i)
       {
-        continue;
-      }
-      // even if the child readers themselves are not modified, mark
-      // them as modified if "this" has been modified, since they
-      // refer to the property of "this"
-      if ((nTimes && reader->SetTimeValue(requestedTimeValue)) ||
-        (this->MTimeOld != this->GetMTime()))
-      {
-        reader->Modified();
+        vtkOpenFOAMReader* reader = vtkOpenFOAMReader::SafeDownCast(this->Superclass::Readers[i]);
+        if (!reader)
+        {
+          continue;
+        }
+        // even if the child readers themselves are not modified, mark
+        // them as modified if "this" has been modified, since they
+        // refer to the property of "this"
+        if ((nTimes && reader->SetTimeValue(requestedTimeValue)) ||
+          (this->MTimeOld != this->GetMTime()))
+        {
+          reader->Modified();
+        }
+        if (reader->MakeMetaDataAtTimeStep(false))
+        {
+          reader->Update();
+          updatedReaders[i] = 1;
+        }
       }
-      if (reader->MakeMetaDataAtTimeStep(false))
+    };
+    if (this->GetSequentialProcessing())
+    {
+      readersProcessing(0, static_cast<vtkIdType>(this->Superclass::Readers.size()));
+    }
+    else
+    {
+      vtkSMPTools::For(
+        0, static_cast<vtkIdType>(this->Superclass::Readers.size()), readersProcessing);
+    }
+    for (size_t i = 0; i < this->Superclass::Readers.size(); ++i)
+    {
+      if (updatedReaders[i])
       {
-        append->AddInputConnection(reader->GetOutputPort());
+        append->AddInputConnection(
+          vtkOpenFOAMReader::SafeDownCast(this->Superclass::Readers[i])->GetOutputPort());
       }
     }
 
@@ -729,6 +784,10 @@ int vtkPOpenFOAMReader::RequestData(
 
   this->Superclass::UpdateStatus();
   this->MTimeOld = this->GetMTime();
+  auto end = std::chrono::high_resolution_clock::now();
+  std::cout << "vtkPOpenFOAMReader::RequestData: Elapsed time: "
+            << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms"
+            << std::endl;
 
   return returnCode;
 }
@@ -952,4 +1011,26 @@ void vtkPOpenFOAMReader::AllGather(vtkDataArraySelection* sa)
     }
   }
 }
+
+//------------------------------------------------------------------------------
+double vtkPOpenFOAMReader::ComputeProgress()
+{
+  // get valid readers
+  std::vector<vtkOpenFOAMReader*> readers;
+  for (auto& readerObj : this->Superclass::Readers)
+  {
+    if (auto reader = vtkOpenFOAMReader::SafeDownCast(readerObj))
+    {
+      readers.push_back(reader);
+    }
+  }
+  // compute the current progress
+  if (!readers.empty())
+  {
+    const double sum = std::accumulate(readers.begin(), readers.end(), 0.0,
+      [](double acc, const auto& reader) { return acc + reader->ComputeProgress(); });
+    return sum / readers.size();
+  }
+  return 1.0;
+}
 VTK_ABI_NAMESPACE_END

IO/Parallel/vtkPOpenFOAMReader.h

@@ -54,6 +54,12 @@ public:
   vtkGetObjectMacro(Controller, vtkMultiProcessController);
   ///@}
 
+
+  /**
+   * Compute the progress of the reader.
+   */
+  double ComputeProgress() override;
+
 protected:
   vtkPOpenFOAMReader();
   ~vtkPOpenFOAMReader() override;