vtkOpenFOAMReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkOpenFOAMReader_h
#define vtkOpenFOAMReader_h
 
#include "vtkIOGeometryModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
 
#include <mutex> // For std::mutex
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCollection;
class vtkCharArray;
class vtkDataArraySelection;
class vtkDoubleArray;
class vtkStringArray;
class vtkTable;
class vtkUnsignedCharArray;
 
class vtkOpenFOAMReaderPrivate;
 
#define VTK_OPENFOAM_TIME_PROFILING 0
 
class VTKIOGEOMETRY_EXPORT vtkOpenFOAMReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  // Access for implementation class
  friend class vtkOpenFOAMReaderPrivate;
 
  static vtkOpenFOAMReader* New();
  vtkTypeMacro(vtkOpenFOAMReader, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  int CanReadFile(VTK_FILEPATH const char*);
 
 
  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);
 
 
  vtkSetMacro(SequentialProcessing, bool);
  vtkGetMacro(SequentialProcessing, bool);
  vtkBooleanMacro(SequentialProcessing, bool);
 
  vtkGetObjectMacro(CellDataArraySelection, vtkDataArraySelection);
 
  int GetNumberOfCellArrays()
  {
    return this->GetNumberOfSelectionArrays(this->CellDataArraySelection);
  }
 
  int GetCellArrayStatus(const char* name)
  {
    return this->GetSelectionArrayStatus(this->CellDataArraySelection, name);
  }
  void SetCellArrayStatus(const char* name, int status)
  {
    this->SetSelectionArrayStatus(this->CellDataArraySelection, name, status);
  }
 
  const char* GetCellArrayName(int index)
  {
    return this->GetSelectionArrayName(this->CellDataArraySelection, index);
  }
 
  void DisableAllCellArrays() { this->DisableAllSelectionArrays(this->CellDataArraySelection); }
  void EnableAllCellArrays() { this->EnableAllSelectionArrays(this->CellDataArraySelection); }
 
  vtkGetObjectMacro(PointDataArraySelection, vtkDataArraySelection);
 
  int GetNumberOfPointArrays()
  {
    return this->GetNumberOfSelectionArrays(this->PointDataArraySelection);
  }
 
  int GetPointArrayStatus(const char* name)
  {
    return this->GetSelectionArrayStatus(this->PointDataArraySelection, name);
  }
  void SetPointArrayStatus(const char* name, int status)
  {
    this->SetSelectionArrayStatus(this->PointDataArraySelection, name, status);
  }
 
  const char* GetPointArrayName(int index)
  {
    return this->GetSelectionArrayName(this->PointDataArraySelection, index);
  }
 
  void DisableAllPointArrays() { this->DisableAllSelectionArrays(this->PointDataArraySelection); }
  void EnableAllPointArrays() { this->EnableAllSelectionArrays(this->PointDataArraySelection); }
 
  vtkGetObjectMacro(LagrangianDataArraySelection, vtkDataArraySelection);
 
  int GetNumberOfLagrangianArrays()
  {
    return this->GetNumberOfSelectionArrays(this->LagrangianDataArraySelection);
  }
 
  int GetLagrangianArrayStatus(const char* name)
  {
    return this->GetSelectionArrayStatus(this->LagrangianDataArraySelection, name);
  }
  void SetLagrangianArrayStatus(const char* name, int status)
  {
    this->SetSelectionArrayStatus(this->LagrangianDataArraySelection, name, status);
  }
 
  const char* GetLagrangianArrayName(int index)
  {
    return this->GetSelectionArrayName(this->LagrangianDataArraySelection, index);
  }
 
  void DisableAllLagrangianArrays()
  {
    this->DisableAllSelectionArrays(this->LagrangianDataArraySelection);
  }
  void EnableAllLagrangianArrays()
  {
    this->EnableAllSelectionArrays(this->LagrangianDataArraySelection);
  }
 
  vtkGetObjectMacro(PatchDataArraySelection, vtkDataArraySelection);
 
  int GetNumberOfPatchArrays()
  {
    return this->GetNumberOfSelectionArrays(this->PatchDataArraySelection);
  }
 
  int GetPatchArrayStatus(const char* name)
  {
    return this->GetSelectionArrayStatus(this->PatchDataArraySelection, name);
  }
  void SetPatchArrayStatus(const char* name, int status)
  {
    this->SetSelectionArrayStatus(this->PatchDataArraySelection, name, status);
  }
 
  const char* GetPatchArrayName(int index)
  {
    return this->GetSelectionArrayName(this->PatchDataArraySelection, index);
  }
 
  void DisableAllPatchArrays() { this->DisableAllSelectionArrays(this->PatchDataArraySelection); }
  void EnableAllPatchArrays() { this->EnableAllSelectionArrays(this->PatchDataArraySelection); }
 
 
  vtkSetMacro(CreateCellToPoint, vtkTypeBool);
  vtkGetMacro(CreateCellToPoint, vtkTypeBool);
  vtkBooleanMacro(CreateCellToPoint, vtkTypeBool);
 
 
  vtkSetMacro(SizeAverageCellToPoint, vtkTypeBool);
  vtkGetMacro(SizeAverageCellToPoint, vtkTypeBool);
  vtkBooleanMacro(SizeAverageCellToPoint, vtkTypeBool);
 
 
  vtkSetMacro(CacheMesh, vtkTypeBool);
  vtkGetMacro(CacheMesh, vtkTypeBool);
  vtkBooleanMacro(CacheMesh, vtkTypeBool);
 
  // Option for reading old binary lagrangian/positions format
 
  vtkSetMacro(PositionsIsIn13Format, vtkTypeBool);
  vtkGetMacro(PositionsIsIn13Format, vtkTypeBool);
  vtkBooleanMacro(PositionsIsIn13Format, vtkTypeBool);
 
 
  vtkSetMacro(SkipZeroTime, bool);
  vtkGetMacro(SkipZeroTime, bool);
  vtkBooleanMacro(SkipZeroTime, bool);
 
 
  vtkSetMacro(ListTimeStepsByControlDict, vtkTypeBool);
  vtkGetMacro(ListTimeStepsByControlDict, vtkTypeBool);
  vtkBooleanMacro(ListTimeStepsByControlDict, vtkTypeBool);
 
 
  vtkSetMacro(AddDimensionsToArrayNames, vtkTypeBool);
  vtkGetMacro(AddDimensionsToArrayNames, vtkTypeBool);
  vtkBooleanMacro(AddDimensionsToArrayNames, vtkTypeBool);
 
 
  vtkSetMacro(ReadZones, vtkTypeBool);
  vtkGetMacro(ReadZones, vtkTypeBool);
  vtkBooleanMacro(ReadZones, vtkTypeBool);
 
 
  virtual void SetUse64BitLabels(bool val);
  vtkGetMacro(Use64BitLabels, bool);
  vtkBooleanMacro(Use64BitLabels, bool);
 
 
  vtkGetMacro(CopyDataToCellZones, bool);
  vtkSetMacro(CopyDataToCellZones, bool);
  vtkBooleanMacro(CopyDataToCellZones, bool);
 
 
  virtual void SetUse64BitFloats(bool val);
  vtkGetMacro(Use64BitFloats, bool);
  vtkBooleanMacro(Use64BitFloats, bool);
 
  void SetRefresh()
  {
    this->Refresh = true;
    this->Modified();
  }
 
  void SetParent(vtkOpenFOAMReader* parent) { this->Parent = parent; }
 
#ifndef __VTK_WRAP__
  int MakeInformationVector(vtkInformationVector*, const vtkStdString& procDirName,
    vtkStringArray* timeNames = nullptr, vtkDoubleArray* timeValues = nullptr,
    const std::vector<vtkSmartPointer<vtkUnsignedCharArray>>&
      populateMeshIndicesFileChecksPerPrivateReader = {});
#endif
 
  double GetTimeValue() const;
  bool SetTimeValue(double);
  vtkStringArray* GetTimeNames();
  vtkDoubleArray* GetTimeValues();
 
#ifndef __VTK_WRAP__
  std::vector<vtkSmartPointer<vtkUnsignedCharArray>> GetPopulateMeshIndicesFileChecksPerReader();
  std::vector<vtkSmartPointer<vtkTable>> GetMarshalledMetadataPerReader();
  void SetMarshalledMetadataPerReader(const std::vector<vtkSmartPointer<vtkTable>>&);
#endif
 
  int MakeMetaDataAtTimeStep(bool listNextTimeStep, bool skipComputingMetaData = false);
 
  virtual double ComputeProgress();
 
#if VTK_OPENFOAM_TIME_PROFILING
  long long GetRequestInformationTimeInMicroseconds() const;
  long long GetRequestDataTimeInMicroseconds() const;
  size_t GetRequestInformationBytes() const;
  size_t GetRequestDataBytes() const;
  virtual void InitializeRequestInformation();
  virtual void InitializeRequestData();
  virtual void PrintRequestInformation();
  virtual void PrintRequestData();
#endif
 
protected:
  // refresh flag
  bool Refresh;
 
  bool SequentialProcessing;
 
  // for creating cell-to-point translated data
  vtkTypeBool CreateCellToPoint;
 
  // for running size average for cell to point calculation
  vtkTypeBool SizeAverageCellToPoint = false;
 
  // for caching mesh
  vtkTypeBool CacheMesh;
 
  // for decomposing polyhedra on-the-fly
  vtkTypeBool DecomposePolyhedra;
  vtkGetMacro(DecomposePolyhedra, vtkTypeBool);
 
  // for lagrangian/positions without extra data (OF 1.4 - 2.4)
  vtkTypeBool PositionsIsIn13Format;
 
  // for reading point/face/cell-Zones
  vtkTypeBool ReadZones;
 
  // Ignore 0/ directory
  bool SkipZeroTime;
 
  // determine if time directories are listed according to controlDict
  vtkTypeBool ListTimeStepsByControlDict;
 
  // add dimensions to array names
  vtkTypeBool AddDimensionsToArrayNames;
 
  // Expect label size to be 64-bit integers instead of 32-bit.
  bool Use64BitLabels;
 
  // Expect float data to be 64-bit floats instead of 32-bit.
  // Note that vtkFloatArrays may still be used -- this just tells the reader how to
  // parse the binary data.
  bool Use64BitFloats;
 
  // The data of internal mesh are copied to cell zones
  bool CopyDataToCellZones;
 
  char* FileName;
  vtkCharArray* CasePath;
  std::vector<vtkSmartPointer<vtkObject>> Readers;
 
  // DataArraySelection for Patch / Region Data
  vtkDataArraySelection* PatchDataArraySelection;
  vtkDataArraySelection* CellDataArraySelection;
  vtkDataArraySelection* PointDataArraySelection;
  vtkDataArraySelection* LagrangianDataArraySelection;
 
  // old selection status
  vtkMTimeType PatchSelectionMTimeOld;
  vtkGetMacro(PatchSelectionMTimeOld, vtkMTimeType);
  vtkMTimeType CellSelectionMTimeOld;
  vtkGetMacro(CellSelectionMTimeOld, vtkMTimeType);
  vtkMTimeType PointSelectionMTimeOld;
  vtkGetMacro(PointSelectionMTimeOld, vtkMTimeType);
  vtkMTimeType LagrangianSelectionMTimeOld;
  vtkGetMacro(LagrangianSelectionMTimeOld, vtkMTimeType);
 
  // preserved old information
  std::string FileNameOld;
  vtkGetMacro(FileNameOld, std::string);
  bool SkipZeroTimeOld;
  vtkGetMacro(SkipZeroTimeOld, bool);
  int ListTimeStepsByControlDictOld;
  vtkGetMacro(ListTimeStepsByControlDictOld, int);
  int CreateCellToPointOld;
  vtkGetMacro(CreateCellToPointOld, int);
  int DecomposePolyhedraOld;
  vtkGetMacro(DecomposePolyhedraOld, int);
  int PositionsIsIn13FormatOld;
  vtkGetMacro(PositionsIsIn13FormatOld, int);
  int AddDimensionsToArrayNamesOld;
  vtkGetMacro(AddDimensionsToArrayNamesOld, int);
  int ReadZonesOld;
  vtkGetMacro(ReadZonesOld, int);
  bool Use64BitLabelsOld;
  vtkGetMacro(Use64BitLabelsOld, bool);
  bool Use64BitFloatsOld;
  vtkGetMacro(Use64BitFloatsOld, bool);
 
  vtkOpenFOAMReader();
  ~vtkOpenFOAMReader() override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  void CreateCasePath(vtkStdString&, vtkStdString&);
  void SetTimeInformation(vtkInformationVector*, vtkDoubleArray*);
  void CreateCharArrayFromString(vtkCharArray*, const char*, vtkStdString&);
  void UpdateStatus();
  void UpdateProgress(vtkOpenFOAMReaderPrivate* reader, double progress);
 
private:
  vtkOpenFOAMReader* Parent;
 
  vtkOpenFOAMReader(const vtkOpenFOAMReader&) = delete;
  void operator=(const vtkOpenFOAMReader&) = delete;
 
  int GetNumberOfSelectionArrays(vtkDataArraySelection*);
  int GetSelectionArrayStatus(vtkDataArraySelection*, const char*);
  void SetSelectionArrayStatus(vtkDataArraySelection*, const char*, int);
  const char* GetSelectionArrayName(vtkDataArraySelection*, int);
  void DisableAllSelectionArrays(vtkDataArraySelection*);
  void EnableAllSelectionArrays(vtkDataArraySelection*);
 
  void AddSelectionNames(vtkDataArraySelection*, vtkStringArray*);
 
  // Print some time information (names, current time-step)
  void PrintTimes(std::ostream& os, vtkIndent indent = vtkIndent(), bool full = false) const;
 
  std::mutex ArraySelectionMutex;
  std::mutex ProgressMutex;
 
#if VTK_OPENFOAM_TIME_PROFILING
  long long RequestInformationTimeInMicroseconds = 0;
  size_t RequestDataBytes = 0;
  long long RequestDataTimeInMicroseconds = 0;
  size_t RequestInformationBytes = 0;
#endif
};
 
VTK_ABI_NAMESPACE_END
#endif