v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


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


  vtkSetStringMacro(FileName);

  vtkGetStringMacro(FileName);


  vtkGetMacro(NumberOfCells,int);


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

  int RequestInformation(vtkInformation *,

    vtkInformationVector **, vtkInformationVector *);

  int RequestData(vtkInformation *, vtkInformationVector **,

    vtkInformationVector *);


  vtkSetMacro(SwapBytes,int);

  int GetSwapBytes() {return this->SwapBytes;}

  vtkBooleanMacro(SwapBytes,int);


  vtkDataArraySelection* CellDataArraySelection;

  char * FileName;

  int NumberOfCells;

  int NumberOfCellArrays;

  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

  //

  ifstream *FluentCaseFile;

  ifstream *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;


  int SwapBytes;

  int GridDimension;

  int DataPass;

  int NumberOfScalars;

  int NumberOfVectors;


private:

  vtkFLUENTReader(const vtkFLUENTReader&);  // Not implemented.

  void operator=(const vtkFLUENTReader&);  // Not implemented.

};

#endif