9.1/html/vtkFLUENTReader_8h_source.html

/*=========================================================================


  Program:   Visualization Toolkit

  Module:    vtkFLUENTReader.h


  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen

  All rights reserved.

  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.


     This software is distributed WITHOUT ANY WARRANTY; without even

     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

     PURPOSE.  See the above copyright notice for more information.


=========================================================================*/

#ifndef vtkFLUENTReader_h

#define vtkFLUENTReader_h


#include "vtkIOGeometryModule.h" // For export macro

#include "vtkMultiBlockDataSetAlgorithm.h"


class vtkDataArraySelection;

class vtkPoints;

class vtkTriangle;

class vtkTetra;

class vtkQuad;

class vtkHexahedron;

class vtkPyramid;

class vtkWedge;

class vtkConvexPointSet;


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


  int GetNumberOfCellArrays(void);


  const char* GetCellArrayName(int index);


  int GetCellArrayStatus(const char* name);

  void SetCellArrayStatus(const char* name, int status);


  void DisableAllCellArrays();

  void EnableAllCellArrays();


  void SetDataByteOrderToBigEndian();

  void SetDataByteOrderToLittleEndian();

  int GetDataByteOrder();

  void SetDataByteOrder(int);

  const char* GetDataByteOrderAsString();

  //

  //  Structures

  //

  struct Cell;

  struct Face;

  struct ScalarDataChunk;

  struct VectorDataChunk;

  struct stdString;

  struct intVector;

  struct doubleVector;

  struct stringVector;

  struct cellVector;

  struct faceVector;

  struct stdMap;

  struct scalarDataVector;

  struct vectorDataVector;

  struct intVectorVector;


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

  virtual int GetCaseIndex();

  virtual void LoadVariableNames();

  virtual int GetDataIndex();

  virtual int GetDataChunk();

  virtual void GetSpeciesVariableNames();


  virtual void ParseCaseFile();

  virtual int GetDimension();

  virtual void GetLittleEndianFlag();

  virtual void GetNodesAscii();

  virtual void GetNodesSinglePrecision();

  virtual void GetNodesDoublePrecision();

  virtual void GetCellsAscii();

  virtual void GetCellsBinary();

  virtual void 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(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 void ParseDataFile();

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


  //

  //  Variables

  //

  vtkDataArraySelection* CellDataArraySelection;

  char* FileName;

  vtkIdType NumberOfCells;

  int NumberOfCellArrays;


  istream* FluentCaseFile;

  istream* FluentDataFile;

  stdString* CaseBuffer;

  stdString* DataBuffer;


  vtkPoints* Points;

  vtkTriangle* Triangle;

  vtkTetra* Tetra;

  vtkQuad* Quad;

  vtkHexahedron* Hexahedron;

  vtkPyramid* Pyramid;

  vtkWedge* Wedge;

  vtkConvexPointSet* ConvexPointSet;


  cellVector* Cells;

  faceVector* Faces;

  stdMap* VariableNames;

  intVector* CellZones;

  scalarDataVector* ScalarDataChunks;

  vectorDataVector* VectorDataChunks;


  intVectorVector* SubSectionZones;

  intVector* SubSectionIds;

  intVector* SubSectionSize;


  stringVector* ScalarVariableNames;

  intVector* ScalarSubSectionIds;

  stringVector* VectorVariableNames;

  intVector* VectorSubSectionIds;


  vtkTypeBool SwapBytes;

  int GridDimension;

  int DataPass;

  int NumberOfScalars;

  int NumberOfVectors;


private:

  vtkFLUENTReader(const vtkFLUENTReader&) = delete;

  void operator=(const vtkFLUENTReader&) = delete;

};

#endif