vtkFLUENTReader.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 vtkFLUENTReader_h
#define vtkFLUENTReader_h
 
#include "vtkDeprecation.h"      // For deprecation macro
#include "vtkIOGeometryModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
#include "vtkNew.h" // For vtkNew
 
#include <set>
#include <unordered_map>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDataArraySelection;
class vtkPoints;
class vtkTriangle;
class vtkTetra;
class vtkQuad;
class vtkHexahedron;
class vtkPyramid;
class vtkWedge;
class vtkConvexPointSet;
class vtkUnstructuredGrid;
 
class VTKIOGEOMETRY_EXPORT vtkFLUENTReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkFLUENTReader* New();
  vtkTypeMacro(vtkFLUENTReader, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);
 
 
  vtkGetMacro(NumberOfCells, vtkIdType);
 
 
  vtkGetMacro(CacheData, bool);
  vtkSetMacro(CacheData, bool);
  vtkBooleanMacro(CacheData, bool);
 
  int GetNumberOfCellArrays();
 
  const char* GetCellArrayName(int index);
 
 
  int GetCellArrayStatus(const char* name);
  void SetCellArrayStatus(const char* name, int status);
 
 
  void DisableAllCellArrays();
  void EnableAllCellArrays();
 
 
  vtkDataArraySelection* GetZoneSectionSelection();
 
 
  void SetDataByteOrderToBigEndian();
  void SetDataByteOrderToLittleEndian();
  int GetDataByteOrder();
  void SetDataByteOrder(int);
  const char* GetDataByteOrderAsString();
  //
  //  Structures
  //
  struct Cell;
  struct Face;
  struct Zone;
  struct ZoneSection;
  struct ScalarDataChunk;
  struct VectorDataChunk;
  struct SubSection;
 
  vtkMTimeType GetMTime() override;
 
protected:
  vtkFLUENTReader();
  ~vtkFLUENTReader() override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
 
  vtkSetMacro(SwapBytes, vtkTypeBool);
  vtkTypeBool GetSwapBytes() { return this->SwapBytes; }
  vtkBooleanMacro(SwapBytes, vtkTypeBool);
 
  virtual bool OpenCaseFile(const char* filename);
  virtual bool OpenDataFile(const char* filename);
  virtual int GetCaseChunk();
  virtual int GetCaseIndex();
  virtual void LoadVariableNames();
  virtual int GetDataIndex();
  virtual int GetDataChunk();
  virtual void GetSpeciesVariableNames();
 
  virtual int GetDimension();
  virtual void GetLittleEndianFlag();
  virtual void GetNodesAscii();
  virtual void GetNodesSinglePrecision();
  virtual void GetNodesDoublePrecision();
  virtual void GetCellsAscii();
  virtual void GetCellsBinary();
  virtual bool GetFacesAscii();
  virtual void GetFacesBinary();
  virtual void GetPeriodicShadowFacesAscii();
  virtual void GetPeriodicShadowFacesBinary();
  virtual void GetCellTreeAscii();
  virtual void GetCellTreeBinary();
  virtual void GetFaceTreeAscii();
  virtual void GetFaceTreeBinary();
  virtual void GetInterfaceFaceParentsAscii();
  virtual void GetInterfaceFaceParentsBinary();
  virtual void GetNonconformalGridInterfaceFaceInformationAscii();
  virtual void GetNonconformalGridInterfaceFaceInformationBinary();
  virtual void GetPartitionInfo() {}
  virtual void CleanCells();
  virtual void PopulateCellNodes();
  virtual int GetCaseBufferInt(int ptr);
  virtual float GetCaseBufferFloat(int ptr);
  virtual double GetCaseBufferDouble(int ptr);
  virtual void PopulateTriangleCell(size_t cellIdx);
  virtual void PopulateTetraCell(size_t cellIdx);
  virtual void PopulateQuadCell(size_t cellIdx);
  virtual void PopulateHexahedronCell(size_t cellIdx);
  virtual void PopulatePyramidCell(size_t cellIdx);
  virtual void PopulateWedgeCell(size_t cellIdx);
  virtual void PopulatePolyhedronCell(size_t cellIdx);
  virtual int GetDataBufferInt(int ptr);
  virtual float GetDataBufferFloat(int ptr);
  virtual double GetDataBufferDouble(int ptr);
  virtual void GetData(int dataType);
  virtual bool ParallelCheckCell(int vtkNotUsed(i)) { return true; }
 
  VTK_DEPRECATED_IN_9_5_0(
    "ReadZone is deprecated. It was an internal method an should not be used.")
  virtual void ReadZone();
  VTK_DEPRECATED_IN_9_5_0(
    "ParseCaseFile is deprecated. It was an internal method an should not be used.")
  virtual bool ParseCaseFile();
  VTK_DEPRECATED_IN_9_5_0(
    "ParseDataFile is deprecated. It was an internal method an should not be used.")
  virtual void ParseDataFile();
 
private:
  bool AreCellsEnabled();
  void DisableCellsAndFaces(std::vector<unsigned int>& disabledZones);
  void DisableZones(std::vector<unsigned int>& disabledZones, bool& areAllZonesDisabled);
  bool FillMultiblock(std::vector<unsigned int>& disabledZones,
    std::vector<size_t>& zoneIDToBlockIdx,
    std::vector<vtkSmartPointer<vtkUnstructuredGrid>>& blockUGs);
  void FillMultiblockData(std::vector<unsigned int>& disabledZones,
    std::vector<size_t>& zoneIDToBlockIdx,
    std::vector<vtkSmartPointer<vtkUnstructuredGrid>>& blockUGs);
  void GetArraysFromSubSections();
  void InitOutputBlocks(vtkMultiBlockDataSet* output, std::vector<size_t>& zoneIDToBlockIdx,
    std::vector<vtkSmartPointer<vtkUnstructuredGrid>>& blockUGs);
  void ParseDataZone(int index);
  void ParseDataZones(bool areCellsEnabled);
  void ParseZone(int index);
  void ParseZones(bool areCellsEnabled);
  bool PreParseDataFile();
  bool PreParseFluentFile();
  bool ReadDataZoneSectionId(unsigned int& zoneSectionId);
  bool ReadZoneSectionId(unsigned int& zoneSectionId);
  bool ReadZoneSection(int limit);
 
  void UpdateZoneSectionSelection();
 
  void FillMultiBlockFromFaces(std::vector<vtkSmartPointer<vtkUnstructuredGrid>>& blockUGs,
    const std::vector<size_t>& zoneIDToBlockIdx, std::vector<unsigned int> disabledZones);
 
  vtkFLUENTReader(const vtkFLUENTReader&) = delete;
  void operator=(const vtkFLUENTReader&) = delete;
 
  //
  //  Variables
  //
  vtkNew<vtkDataArraySelection> ZoneSectionSelection;
  vtkNew<vtkDataArraySelection> CellDataArraySelection;
  char* FileName = nullptr;
  vtkIdType NumberOfCells = 0;
  bool CacheData = true;
 
  istream* FluentFile = nullptr;
  istream* FluentDataFile = nullptr;
  std::string FluentBuffer;
  std::string DataBuffer;
 
  // File data cache
  vtkNew<vtkPoints> Points;
  std::vector<Cell> Cells;
  std::vector<Face> Faces;
  std::vector<ZoneSection> ZoneSections;
  std::map<size_t, std::string> VariableNames;
  std::vector<ScalarDataChunk> ScalarDataChunks;
  std::vector<VectorDataChunk> VectorDataChunks;
  std::vector<SubSection> SubSections;
 
  std::vector<std::string> ScalarVariableNames;
  std::vector<int> ScalarSubSectionIds;
  std::vector<std::string> VectorVariableNames;
  std::vector<int> VectorSubSectionIds;
 
  vtkTypeBool SwapBytes;
  int GridDimension = 0;
  int NumberOfScalars = 0;
  int NumberOfVectors = 0;
 
  std::vector<Zone> Zones;
  std::vector<Zone> DataZones;
  std::vector<Cell> CurrentCells;
  std::vector<Face> CurrentFaces;
  std::vector<ZoneSection> CurrentZoneSections;
 
  bool IsFilePreParsed = false;
};
 
VTK_ABI_NAMESPACE_END
#endif