You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
8.7 KiB
C++
297 lines
8.7 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkMFIXReader.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.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkMFIXReader
|
|
* @brief reads a dataset in MFIX file format
|
|
*
|
|
* vtkMFIXReader creates an unstructured grid dataset. It reads a restart
|
|
* file and a set of sp files. The restart file contains the mesh
|
|
* information. MFIX meshes are either cylindrical or rectilinear, but
|
|
* this reader will convert them to an unstructured grid. The sp files
|
|
* contain transient data for the cells. Each sp file has one or more
|
|
* variables stored inside it.
|
|
*
|
|
* @par Thanks:
|
|
* Thanks to Phil Nicoletti and Brian Dotson at the National Energy
|
|
* Technology Laboratory who developed this class.
|
|
* Please address all comments to Brian Dotson (brian.dotson@netl.doe.gov)
|
|
*
|
|
* @sa
|
|
* vtkGAMBITReader
|
|
*/
|
|
|
|
#ifndef vtkMFIXReader_h
|
|
#define vtkMFIXReader_h
|
|
|
|
#include "vtkIOGeometryModule.h" // For export macro
|
|
#include "vtkUnstructuredGridAlgorithm.h"
|
|
|
|
class vtkDataArraySelection;
|
|
class vtkDoubleArray;
|
|
class vtkStringArray;
|
|
class vtkIntArray;
|
|
class vtkFloatArray;
|
|
class vtkXMLUnstructuredGridWriter;
|
|
class vtkWedge;
|
|
class vtkQuad;
|
|
class vtkHexahedron;
|
|
class vtkPoints;
|
|
class vtkStdString;
|
|
|
|
class VTKIOGEOMETRY_EXPORT vtkMFIXReader : public vtkUnstructuredGridAlgorithm
|
|
{
|
|
public:
|
|
static vtkMFIXReader* New();
|
|
vtkTypeMacro(vtkMFIXReader, vtkUnstructuredGridAlgorithm);
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
|
|
//@{
|
|
/**
|
|
* Specify the file name of the MFIX Restart data file to read.
|
|
*/
|
|
vtkSetStringMacro(FileName);
|
|
vtkGetStringMacro(FileName);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the total number of cells. The number of cells is only valid after a
|
|
* successful read of the data file is performed.
|
|
*/
|
|
vtkGetMacro(NumberOfCells, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the total number of nodes. The number of nodes is only valid after a
|
|
* successful read of the data file is performed.
|
|
*/
|
|
vtkGetMacro(NumberOfPoints, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the number of data components at the nodes and cells.
|
|
*/
|
|
vtkGetMacro(NumberOfCellFields, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Which TimeStep to read.
|
|
*/
|
|
vtkSetMacro(TimeStep, int);
|
|
vtkGetMacro(TimeStep, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Returns the number of timesteps.
|
|
*/
|
|
vtkGetMacro(NumberOfTimeSteps, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Which TimeStepRange to read
|
|
*/
|
|
vtkGetVector2Macro(TimeStepRange, int);
|
|
vtkSetVector2Macro(TimeStepRange, int);
|
|
//@}
|
|
|
|
/**
|
|
* Get the number of cell arrays available in the input.
|
|
*/
|
|
int GetNumberOfCellArrays(void);
|
|
|
|
/**
|
|
* Get the name of the cell array with the given index in
|
|
* the input.
|
|
*/
|
|
const char* GetCellArrayName(int index);
|
|
|
|
//@{
|
|
/**
|
|
* Get/Set whether the cell array with the given name is to
|
|
* be read.
|
|
*/
|
|
int GetCellArrayStatus(const char* name);
|
|
void SetCellArrayStatus(const char* name, int status);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Turn on/off all cell arrays.
|
|
*/
|
|
void DisableAllCellArrays();
|
|
void EnableAllCellArrays();
|
|
//@}
|
|
|
|
/**
|
|
* Get the range of cell data.
|
|
*/
|
|
void GetCellDataRange(int cellComp, float* min, float* max);
|
|
|
|
protected:
|
|
vtkMFIXReader();
|
|
~vtkMFIXReader() override;
|
|
int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
|
|
int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
|
|
|
|
//
|
|
// ParaView Variables
|
|
//
|
|
|
|
char* FileName;
|
|
int RequestInformationFlag;
|
|
int MakeMeshFlag;
|
|
int NumberOfPoints;
|
|
int NumberOfCells;
|
|
int NumberOfCellFields;
|
|
vtkIntArray* VectorLength;
|
|
vtkFloatArray* Minimum;
|
|
vtkFloatArray* Maximum;
|
|
vtkDataArraySelection* CellDataArraySelection;
|
|
int TimeStep;
|
|
int ActualTimeStep;
|
|
int CurrentTimeStep;
|
|
int NumberOfTimeSteps;
|
|
int* TimeSteps;
|
|
int TimeStepRange[2];
|
|
int TimeStepWasReadOnce;
|
|
|
|
//
|
|
// MFIX Variables
|
|
//
|
|
|
|
vtkFloatArray** CellDataArray; // Arrays for variables that will
|
|
// attach to mesh
|
|
vtkPoints* Points; // Points array for building grid
|
|
vtkUnstructuredGrid* Mesh; // Unstructured Grid
|
|
vtkHexahedron* AHexahedron; // Hexahedron type cell
|
|
vtkWedge* AWedge; // Wedge type cell
|
|
vtkQuad* AQuad; // Quad type cell
|
|
vtkIntArray* Flag; // Cell Flag array
|
|
vtkDoubleArray* Dx; // Cell widths in x axis
|
|
vtkDoubleArray* Dy; // Cell widths in y axis
|
|
vtkDoubleArray* Dz; // Cell widths in z axis
|
|
vtkIntArray* NMax; // Array to hold number of species per phase
|
|
vtkDoubleArray* C; // Array used to parse restart file
|
|
vtkIntArray* TempI; // Array used to parse restart file
|
|
vtkDoubleArray* TempD; // Array used to parse restart file
|
|
vtkIntArray* SpxFileExists; // Array for keeping track of
|
|
// what spx files exist.
|
|
|
|
char FileExtension[15];
|
|
char DataBuffer[513];
|
|
char Version[120];
|
|
float VersionNumber;
|
|
int DimensionIc;
|
|
int DimensionBc;
|
|
int DimensionC;
|
|
int DimensionIs;
|
|
double Ce;
|
|
double Cf;
|
|
double Phi;
|
|
double PhiW;
|
|
double DeltaTime;
|
|
double XMinimum;
|
|
char RunName[256];
|
|
vtkStringArray* VariableNames;
|
|
vtkIntArray* VariableComponents;
|
|
int IMinimum1;
|
|
int JMinimum1;
|
|
int KMinimum1;
|
|
int IMaximum;
|
|
int JMaximum;
|
|
int KMaximum;
|
|
int IMaximum1;
|
|
int JMaximum1;
|
|
int KMaximum1;
|
|
int IMaximum2;
|
|
int JMaximum2;
|
|
int KMaximum2;
|
|
int IJMaximum2;
|
|
int IJKMaximum2;
|
|
int MMAX;
|
|
int NumberOfSPXFilesUsed;
|
|
double XLength;
|
|
double YLength;
|
|
double ZLength;
|
|
int NumberOfScalars;
|
|
int NumberOfReactionRates;
|
|
bool BkEpsilon;
|
|
char CoordinateSystem[17];
|
|
char Units[17];
|
|
|
|
//
|
|
// SPX Variables
|
|
//
|
|
|
|
int MaximumTimestep; // maximum timesteps amongst the variables
|
|
int SPXRecordsPerTimestep; // number of records in a single
|
|
// timestep for a variable
|
|
vtkIntArray* SPXToNVarTable; // number of variables in each spx file
|
|
vtkIntArray* VariableToSkipTable; // skip value for each variable, this
|
|
// is needed in spx files
|
|
// with more than one variable.
|
|
vtkIntArray* VariableTimesteps; // number of timesteps for each variable
|
|
vtkIntArray* VariableTimestepTable; // Since the number of timesteps
|
|
// vary between variables
|
|
// this is a table that looks
|
|
// up the appropriate timestep
|
|
// for the particular variable.
|
|
vtkIntArray* variableIndexToSPX; // This gives the spx file number for the
|
|
// particular variable.
|
|
vtkIntArray* VariableIndexToSPX; // This gives the spx file number for the
|
|
// particular variable.
|
|
vtkIntArray* SPXTimestepIndexTable; // This a table look up for the index
|
|
// into a file for a certain variable.
|
|
|
|
private:
|
|
vtkMFIXReader(const vtkMFIXReader&) = delete;
|
|
void operator=(const vtkMFIXReader&) = delete;
|
|
|
|
void MakeMesh(vtkUnstructuredGrid* output);
|
|
void SwapDouble(double& value);
|
|
void SwapFloat(float& value);
|
|
void SwapInt(int& value);
|
|
vtkStdString ConvertIntToString(int in);
|
|
int ConvertCharToInt(char in);
|
|
int ConvertStringToInt(const vtkStdString& in);
|
|
void GetInt(istream& in, int& val);
|
|
void GetDouble(istream& in, double& val);
|
|
void GetFloat(istream& in, float& val);
|
|
void SkipBytes(istream& in, int n);
|
|
void RestartVersionNumber(const char* buffer);
|
|
void GetBlockOfDoubles(istream& in, vtkDoubleArray* v, int n);
|
|
void GetBlockOfFloats(istream& in, vtkFloatArray* v, int n);
|
|
void GetBlockOfInts(istream& in, vtkIntArray* v, int n);
|
|
void ReadRestartFile();
|
|
void GetVariableAtTimestep(int vari, int tstep, vtkFloatArray* v);
|
|
void CreateVariableNames();
|
|
void GetTimeSteps();
|
|
void MakeTimeStepTable(int nvars);
|
|
void SetProjectName(const char* infile);
|
|
void MakeSPXTimeStepIndexTable(int nvars);
|
|
void CalculateMaxTimeStep();
|
|
void GetNumberOfVariablesInSPXFiles();
|
|
void FillVectorVariable(int xindex, int yindex, int zindex, vtkFloatArray* v);
|
|
void ConvertVectorFromCylindricalToCartesian(int xindex, int zindex);
|
|
void GetAllTimes(vtkInformationVector* outputVector);
|
|
};
|
|
|
|
#endif
|