vtkFLUENTCFFReader.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 vtkFLUENTCFFReader_h
#define vtkFLUENTCFFReader_h
 
#include <memory> // std::unique_ptr
 
#include "vtkIOFLUENTCFFModule.h" // For export macro
 
#include "vtkMultiBlockDataSetAlgorithm.h"
#include "vtkNew.h" // For vtkNew
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDataArraySelection;
class vtkPoints;
class vtkTriangle;
class vtkTetra;
class vtkQuad;
class vtkHexahedron;
class vtkPyramid;
class vtkWedge;
 
class VTKIOFLUENTCFF_EXPORT vtkFLUENTCFFReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkFLUENTCFFReader* New();
  vtkTypeMacro(vtkFLUENTCFFReader, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(FileName, std::string);
  vtkGetMacro(FileName, std::string);
 
 
  vtkGetMacro(NumberOfCells, vtkIdType);
 
  int GetNumberOfCellArrays();
 
  const char* GetCellArrayName(int index);
 
 
  int GetCellArrayStatus(const char* name);
  void SetCellArrayStatus(const char* name, int status);
 
 
  void DisableAllCellArrays();
  void EnableAllCellArrays();
 
  //
  //  Structures
  //
  struct Cell
  {
    int type;
    int zone;
    std::vector<int> faces;
    int parent;
    int child;
    std::vector<int> nodes;
    std::vector<int> nodesOffset;
    std::vector<int> childId;
  };
  struct Face
  {
    int type;
    unsigned int zone;
    std::vector<int> nodes;
    int c0;
    int c1;
    int periodicShadow;
    int parent;
    int child;
    int interfaceFaceParent;
    int interfaceFaceChild;
    int ncgParent;
    int ncgChild;
  };
  struct ScalarDataChunk
  {
    std::string variableName;
    vtkIdType zoneId;
    std::vector<double> scalarData;
  };
  struct VectorDataChunk
  {
    std::string variableName;
    vtkIdType zoneId;
    size_t dim;
    std::vector<double> vectorData;
  };
 
protected:
  vtkFLUENTCFFReader();
  ~vtkFLUENTCFFReader() override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  enum DataState
  {
    NOT_LOADED = 0,
    AVAILABLE = 1,
    LOADED = 2,
    ERROR = 3
  };
 
 
  virtual bool OpenCaseFile(const std::string& filename);
  virtual DataState OpenDataFile(const std::string& filename);
 
  virtual void GetNumberOfCellZones();
 
  virtual int ParseCaseFile();
 
  virtual int GetDimension();
 
 
  virtual void GetNodesGlobal();
  virtual void GetCellsGlobal();
  virtual void GetFacesGlobal();
 
  virtual void GetNodes();
 
  virtual void GetCells();
 
  virtual void GetFaces();
 
  virtual void GetPeriodicShadowFaces();
 
  virtual void GetCellOverset();
 
  virtual void GetCellTree();
 
  virtual void GetFaceTree();
 
  virtual void GetInterfaceFaceParents();
 
  virtual void GetNonconformalGridInterfaceFaceInformation();
 
  virtual void CleanCells();
 
 
  virtual void PopulateCellNodes();
  virtual void PopulateCellTree();
 
 
  virtual void PopulateTriangleCell(int i);
  virtual void PopulateTetraCell(int i);
  virtual void PopulateQuadCell(int i);
  virtual void PopulateHexahedronCell(int i);
  virtual void PopulatePyramidCell(int i);
  virtual void PopulateWedgeCell(int i);
  virtual void PopulatePolyhedronCell(int i);
 
  virtual int GetData();
 
  virtual int GetMetaData();
 
  //
  //  Variables
  //
  vtkNew<vtkDataArraySelection> CellDataArraySelection;
  std::string FileName;
  vtkIdType NumberOfCells = 0;
  int NumberOfCellArrays = 0;
 
  struct vtkInternals;
  std::unique_ptr<vtkInternals> HDFImpl;
 
  vtkNew<vtkPoints> Points;
  vtkNew<vtkTriangle> Triangle;
  vtkNew<vtkTetra> Tetra;
  vtkNew<vtkQuad> Quad;
  vtkNew<vtkHexahedron> Hexahedron;
  vtkNew<vtkPyramid> Pyramid;
  vtkNew<vtkWedge> Wedge;
 
  std::vector<Cell> Cells;
  std::vector<Face> Faces;
  std::vector<int> CellZones;
  std::vector<ScalarDataChunk> ScalarDataChunks;
  std::vector<VectorDataChunk> VectorDataChunks;
  std::vector<std::string> PreReadScalarData;
  std::vector<std::string> PreReadVectorData;
 
  vtkTypeBool SwapBytes = 0;
  int GridDimension = 0;
  DataState FileState = DataState::NOT_LOADED;
  int NumberOfScalars = 0;
  int NumberOfVectors = 0;
 
private:
  vtkFLUENTCFFReader(const vtkFLUENTCFFReader&) = delete;
  void operator=(const vtkFLUENTCFFReader&) = delete;
};
VTK_ABI_NAMESPACE_END
#endif