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 <map>    // std::map
#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 vtkMultiBlockDataSet;
class vtkPoints;
class vtkTriangle;
class vtkTetra;
class vtkQuad;
class vtkHexahedron;
class vtkPyramid;
class vtkUnstructuredGrid;
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);


  vtkSetMacro(RenameArrays, bool);
  vtkGetMacro(RenameArrays, bool);


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

  int GetNumberOfFaceArrays();

  const char* GetFaceArrayName(int index);


  int GetFaceArrayStatus(const char* name);
  void SetFaceArrayStatus(const char* name, int status);


  void DisableAllFaceArrays();
  void EnableAllFaceArrays();


  vtkSetMacro(ReadFaces, bool);
  vtkGetMacro(ReadFaces, bool);
  vtkBooleanMacro(ReadFaces, bool);

  vtkMTimeType GetMTime() override;

  //
  //  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;
  };

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;
  bool RenameArrays = false;
  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;

  vtkTypeBool SwapBytes = 0;
  int GridDimension = 0;
  DataState FileState = DataState::NOT_LOADED;

private:
  vtkFLUENTCFFReader(const vtkFLUENTCFFReader&) = delete;
  void operator=(const vtkFLUENTCFFReader&) = delete;

  struct FaceZone
  {
    std::string name;
    int minId;
    int maxId;
    int zoneType;
  };

  struct DataChunk
  {
    std::string variableName;
    vtkIdType zoneId;
    size_t dim;
    std::vector<double> dataVector;
  };

  typedef long long hid_t;
  void ReadFieldMetaData(hid_t parentGroup, int iphase, std::vector<std::string>& container);

  void ParseUDMData(
    std::vector<vtkSmartPointer<vtkUnstructuredGrid>>& grid, const DataChunk& vectorDataChunk);

  void CreateFaces(vtkMultiBlockDataSet* output);

  void FillDataArrayForFaceZone(const FaceZone& zone, vtkUnstructuredGrid* faceGrid,
    const std::map<unsigned int, vtkIdType>& faceIdToLocalIndex);

  std::vector<DataChunk> DataChunks;
  std::vector<std::string> PreReadData;
  std::vector<std::string> PreReadFaceData;
  int NumberOfArrays = 0;

  std::map<int, FaceZone> FaceZonesById;

  vtkNew<vtkDataArraySelection> FaceDataArraySelection;
  bool ReadFaces = false;
};
VTK_ABI_NAMESPACE_END
#endif