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);


  vtkGetMacro(IgnoreRestartFiles, bool);
  vtkSetMacro(IgnoreRestartFiles, bool);
  vtkBooleanMacro(IgnoreRestartFiles, 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;

  // Ignore files with name ending by "_0".
  bool IgnoreRestartFiles = true;

#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