vtkMultiBlockPLOT3DReader.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkMultiBlockPLOT3DReader.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 vtkMultiBlockPLOT3DReader_h
#define vtkMultiBlockPLOT3DReader_h
 
#include "vtkIOParallelModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
 
class vtkDataArray;
class vtkUnsignedCharArray;
class vtkIntArray;
class vtkStructuredGrid;
class vtkMultiProcessController;
 
struct vtkMultiBlockPLOT3DReaderInternals;
 
class VTKIOPARALLEL_EXPORT vtkMultiBlockPLOT3DReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkMultiBlockPLOT3DReader *New();
  vtkTypeMacro(vtkMultiBlockPLOT3DReader,vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  void SetFileName(const char* name) { this->SetXYZFileName(name); }
  const char* GetFileName() { return this->GetXYZFileName(); }
  virtual void SetXYZFileName( const char* );
  vtkGetStringMacro(XYZFileName);
 
 
  vtkSetStringMacro(QFileName);
  vtkGetStringMacro(QFileName);
 
 
  vtkSetStringMacro(FunctionFileName);
  vtkGetStringMacro(FunctionFileName);
 
 
  vtkSetMacro(AutoDetectFormat, int);
  vtkGetMacro(AutoDetectFormat, int);
  vtkBooleanMacro(AutoDetectFormat, int);
 
 
  vtkSetMacro(BinaryFile, int);
  vtkGetMacro(BinaryFile, int);
  vtkBooleanMacro(BinaryFile, int);
 
 
  vtkSetMacro(MultiGrid, int);
  vtkGetMacro(MultiGrid, int);
  vtkBooleanMacro(MultiGrid, int);
 
 
  vtkSetMacro(HasByteCount, int);
  vtkGetMacro(HasByteCount, int);
  vtkBooleanMacro(HasByteCount, int);
 
 
  vtkSetMacro(IBlanking, int);
  vtkGetMacro(IBlanking, int);
  vtkBooleanMacro(IBlanking, int);
 
 
  vtkSetMacro(TwoDimensionalGeometry, int);
  vtkGetMacro(TwoDimensionalGeometry, int);
  vtkBooleanMacro(TwoDimensionalGeometry, int);
 
 
  vtkSetMacro(DoublePrecision, int);
  vtkGetMacro(DoublePrecision, int);
  vtkBooleanMacro(DoublePrecision, int);
 
 
  vtkSetMacro(ForceRead, int);
  vtkGetMacro(ForceRead, int);
  vtkBooleanMacro(ForceRead, int);
 
 
  void SetByteOrderToBigEndian();
  void SetByteOrderToLittleEndian();
  vtkSetMacro(ByteOrder, int);
  vtkGetMacro(ByteOrder, int);
  const char *GetByteOrderAsString();
 
 
  vtkSetMacro(R,double);
  vtkGetMacro(R,double);
 
 
  vtkSetMacro(Gamma,double);
  vtkGetMacro(Gamma,double);
 
 
  void SetScalarFunctionNumber(int num);
  vtkGetMacro(ScalarFunctionNumber,int);
 
 
  void SetVectorFunctionNumber(int num);
  vtkGetMacro(VectorFunctionNumber,int);
 
 
  void AddFunction(int functionNumber);
  void RemoveFunction(int);
  void RemoveAllFunctions();
 
  virtual int CanReadBinaryFile(const char* fname);
 
 
  void SetController(vtkMultiProcessController *c);
  vtkGetObjectMacro(Controller, vtkMultiProcessController);
 
//BTX
  enum
  {
    FILE_BIG_ENDIAN=0,
    FILE_LITTLE_ENDIAN=1
  };
//ETX
 
protected:
  vtkMultiBlockPLOT3DReader();
  ~vtkMultiBlockPLOT3DReader();
 
  vtkDataArray* CreateFloatArray();
 
  int CheckFile(FILE*& fp, const char* fname);
  int CheckGeometryFile(FILE*& xyzFp);
  int CheckSolutionFile(FILE*& qFp);
  int CheckFunctionFile(FILE*& fFp);
 
  int GetByteCountSize();
  int SkipByteCount (FILE* fp);
  int ReadIntBlock  (FILE* fp, int n, int*   block);
 
  vtkIdType ReadValues(
    FILE* fp,
    int n,
    vtkDataArray* scalar);
  virtual int ReadIntScalar(
    void* vfp,
    int extent[6], int wextent[6],
    vtkDataArray* scalar, vtkTypeUInt64 offset);
  virtual int ReadScalar(
    void* vfp,
    int extent[6], int wextent[6],
    vtkDataArray* scalar, vtkTypeUInt64 offset);
  virtual int ReadVector(
    void* vfp,
    int extent[6], int wextent[6],
    int numDims, vtkDataArray* vector, vtkTypeUInt64 offset);
  virtual int OpenFileForDataRead(void*& fp, const char* fname);
  virtual void CloseFile(void* fp);
 
  int GetNumberOfBlocksInternal(FILE* xyzFp, int allocate);
 
  int ReadGeometryHeader(FILE* fp);
  int ReadQHeader(FILE* fp, bool checkGrid, int& nq, int& nqc, int& overflow);
  int ReadFunctionHeader(FILE* fp, int* nFunctions);
 
  void CalculateFileSize(FILE* fp);
 
  int AutoDetectionCheck(FILE* fp);
 
  void AssignAttribute(int fNumber, vtkStructuredGrid* output,
                       int attributeType);
  void MapFunction(int fNumber, vtkStructuredGrid* output);
  void ComputeTemperature(vtkStructuredGrid* output);
  void ComputePressure(vtkStructuredGrid* output);
  void ComputeEnthalpy(vtkStructuredGrid* output);
  void ComputeKineticEnergy(vtkStructuredGrid* output);
  void ComputeVelocityMagnitude(vtkStructuredGrid* output);
  void ComputeEntropy(vtkStructuredGrid* output);
  void ComputeSwirl(vtkStructuredGrid* output);
  void ComputeVelocity(vtkStructuredGrid* output);
  void ComputeVorticity(vtkStructuredGrid* output);
  void ComputePressureGradient(vtkStructuredGrid* output);
  void ComputePressureCoefficient(vtkStructuredGrid* output);
  void ComputeMachNumber(vtkStructuredGrid* output);
  void ComputeSoundSpeed(vtkStructuredGrid* output);
  void ComputeVorticityMagnitude(vtkStructuredGrid* output);
  void ComputeStrainRate(vtkStructuredGrid* output);
 
  // Returns a vtkFloatArray or a vtkDoubleArray depending
  // on DoublePrecision setting
  vtkDataArray* NewFloatArray();
 
  // Delete references to any existing vtkPoints and
  // I-blank arrays. The next Update() will (re)read
  // the XYZ file.
  void ClearGeometryCache();
 
  //plot3d FileNames
  char *XYZFileName;
  char *QFileName;
  char *FunctionFileName;
 
  int BinaryFile;
  int HasByteCount;
  int TwoDimensionalGeometry;
  int MultiGrid;
  int ForceRead;
  int ByteOrder;
  int IBlanking;
  int DoublePrecision;
  int AutoDetectFormat;
 
  int ExecutedGhostLevels;
 
  size_t FileSize;
 
  //parameters used in computing derived functions
  double R;
  double Gamma;
  double Uvinf;
  double Vvinf;
  double Wvinf;
 
  //functions to read that are not scalars or vectors
  vtkIntArray *FunctionList;
 
  int ScalarFunctionNumber;
  int VectorFunctionNumber;
 
  virtual int FillOutputPortInformation(int port, vtkInformation* info);
 
  virtual int RequestData(vtkInformation*,
                          vtkInformationVector**,
                          vtkInformationVector*);
  virtual int RequestInformation(vtkInformation*,
                                 vtkInformationVector**,
                                 vtkInformationVector*);
 
  vtkMultiBlockPLOT3DReaderInternals* Internal;
 
  vtkMultiProcessController *Controller;
 
private:
  vtkMultiBlockPLOT3DReader(const vtkMultiBlockPLOT3DReader&);  // Not implemented.
  void operator=(const vtkMultiBlockPLOT3DReader&);  // Not implemented.
};
 
#endif