VTK
vtkOpenFOAMReader.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkOpenFOAMReader.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
45 #ifndef vtkOpenFOAMReader_h
46 #define vtkOpenFOAMReader_h
47 
48 #include "vtkIOGeometryModule.h" // For export macro
50 
51 class vtkCollection;
52 class vtkCharArray;
54 class vtkDoubleArray;
55 class vtkStdString;
56 class vtkStringArray;
57 
58 class vtkOpenFOAMReaderPrivate;
59 
60 class VTKIOGEOMETRY_EXPORT vtkOpenFOAMReader : public vtkMultiBlockDataSetAlgorithm
61 {
62 public:
63  static vtkOpenFOAMReader *New();
65  void PrintSelf(ostream &, vtkIndent) override;
66 
70  int CanReadFile(const char *);
71 
73 
76  vtkSetStringMacro(FileName);
77  vtkGetStringMacro(FileName);
79 
84  { return this->GetNumberOfSelectionArrays(this->CellDataArraySelection); }
85 
90  int GetCellArrayStatus(const char *name)
91  { return this->GetSelectionArrayStatus(this->CellDataArraySelection, name); }
92  void SetCellArrayStatus(const char *name, int status)
93  { this->SetSelectionArrayStatus(this->CellDataArraySelection, name, status); }
94 
99  const char *GetCellArrayName(int index)
100  { return this->GetSelectionArrayName(this->CellDataArraySelection, index); }
101 
106  { this->DisableAllSelectionArrays(this->CellDataArraySelection); }
108  { this->EnableAllSelectionArrays(this->CellDataArraySelection); }
109 
114  { return this->GetNumberOfSelectionArrays(this->PointDataArraySelection); }
115 
120  int GetPointArrayStatus(const char *name)
121  { return this->GetSelectionArrayStatus(this->PointDataArraySelection, name); }
122  void SetPointArrayStatus(const char *name, int status)
123  { this->SetSelectionArrayStatus(this->PointDataArraySelection,
124  name, status); }
125 
130  const char *GetPointArrayName(int index)
131  { return this->GetSelectionArrayName(this->PointDataArraySelection, index); }
132 
137  { this->DisableAllSelectionArrays(this->PointDataArraySelection); }
139  { this->EnableAllSelectionArrays(this->PointDataArraySelection); }
140 
145  { return this->GetNumberOfSelectionArrays(
146  this->LagrangianDataArraySelection); }
147 
153  { return this->GetSelectionArrayStatus(this->LagrangianDataArraySelection,
154  name); }
155  void SetLagrangianArrayStatus(const char *name, int status)
156  { this->SetSelectionArrayStatus(this->LagrangianDataArraySelection, name,
157  status); }
158 
163  const char* GetLagrangianArrayName(int index)
164  { return this->GetSelectionArrayName(this->LagrangianDataArraySelection,
165  index); }
166 
171  { this->DisableAllSelectionArrays(this->LagrangianDataArraySelection); }
173  { this->EnableAllSelectionArrays(this->LagrangianDataArraySelection); }
174 
179  { return this->GetNumberOfSelectionArrays(this->PatchDataArraySelection); }
180 
185  int GetPatchArrayStatus(const char *name)
186  { return this->GetSelectionArrayStatus(this->PatchDataArraySelection, name); }
187  void SetPatchArrayStatus(const char *name, int status)
188  { this->SetSelectionArrayStatus(this->PatchDataArraySelection, name,
189  status); }
190 
195  const char *GetPatchArrayName(int index)
196  { return this->GetSelectionArrayName(this->PatchDataArraySelection, index); }
197 
202  { this->DisableAllSelectionArrays(this->PatchDataArraySelection); }
204  { this->EnableAllSelectionArrays(this->PatchDataArraySelection); }
205 
207 
210  vtkSetMacro(CreateCellToPoint, vtkTypeBool);
211  vtkGetMacro(CreateCellToPoint, vtkTypeBool);
212  vtkBooleanMacro(CreateCellToPoint, vtkTypeBool);
214 
216 
219  vtkSetMacro(CacheMesh, vtkTypeBool);
220  vtkGetMacro(CacheMesh, vtkTypeBool);
221  vtkBooleanMacro(CacheMesh, vtkTypeBool);
223 
225 
228  vtkSetMacro(DecomposePolyhedra, vtkTypeBool);
229  vtkGetMacro(DecomposePolyhedra, vtkTypeBool);
230  vtkBooleanMacro(DecomposePolyhedra, vtkTypeBool);
232 
233  // Option for reading old binary lagrangian/positions format
235 
241  vtkSetMacro(PositionsIsIn13Format, vtkTypeBool);
242  vtkGetMacro(PositionsIsIn13Format, vtkTypeBool);
243  vtkBooleanMacro(PositionsIsIn13Format, vtkTypeBool);
245 
247 
251  vtkSetMacro(SkipZeroTime, bool);
252  vtkGetMacro(SkipZeroTime, bool);
253  vtkBooleanMacro(SkipZeroTime, bool);
255 
257 
260  vtkSetMacro(ListTimeStepsByControlDict, vtkTypeBool);
261  vtkGetMacro(ListTimeStepsByControlDict, vtkTypeBool);
262  vtkBooleanMacro(ListTimeStepsByControlDict, vtkTypeBool);
264 
266 
269  vtkSetMacro(AddDimensionsToArrayNames, vtkTypeBool);
270  vtkGetMacro(AddDimensionsToArrayNames, vtkTypeBool);
271  vtkBooleanMacro(AddDimensionsToArrayNames, vtkTypeBool);
273 
275 
278  vtkSetMacro(ReadZones, vtkTypeBool);
279  vtkGetMacro(ReadZones, vtkTypeBool);
280  vtkBooleanMacro(ReadZones, vtkTypeBool);
282 
284 
287  virtual void SetUse64BitLabels(bool val);
288  vtkGetMacro(Use64BitLabels, bool)
289  vtkBooleanMacro(Use64BitLabels, bool)
291 
293 
297  vtkGetMacro(CopyDataToCellZones, bool)
298  vtkSetMacro(CopyDataToCellZones, bool)
299  vtkBooleanMacro(CopyDataToCellZones, bool)
301 
303 
308  virtual void SetUse64BitFloats(bool val);
309  vtkGetMacro(Use64BitFloats, bool)
310  vtkBooleanMacro(Use64BitFloats, bool)
312 
313  void SetRefresh() { this->Refresh = true; this->Modified(); }
314 
315  void SetParent(vtkOpenFOAMReader *parent) { this->Parent = parent; }
316  int MakeInformationVector(vtkInformationVector *, const vtkStdString &);
317  bool SetTimeValue(const double);
318  vtkDoubleArray *GetTimeValues();
319  int MakeMetaDataAtTimeStep(const bool);
320 
321  friend class vtkOpenFOAMReaderPrivate;
322 
323 protected:
324  // refresh flag
325  bool Refresh;
326 
327  // for creating cell-to-point translated data
329 
330  // for caching mesh
332 
333  // for decomposing polyhedra on-the-fly
335 
336  // for lagrangian/positions without extra data (OF 1.4 - 2.4)
338 
339  // for reading point/face/cell-Zones
341 
342  // Ignore 0/ directory
344 
345  // determine if time directories are listed according to controlDict
347 
348  // add dimensions to array names
350 
351  // Expect label size to be 64-bit integers instead of 32-bit.
353 
354  // Expect float data to be 64-bit floats instead of 32-bit.
355  // Note that vtkFloatArrays may still be used -- this just tells the reader how to
356  // parse the binary data.
358 
359  // The data of internal mesh are copied to cell zones
361 
362  char *FileName;
365 
366  // DataArraySelection for Patch / Region Data
371 
372  // old selection status
377 
378  // preserved old information
389 
390  // paths to Lagrangians
392 
393  // number of reader instances
395  // index of the active reader
397 
399  ~vtkOpenFOAMReader() override;
401  vtkInformationVector *) override;
403  vtkInformationVector *) override;
404 
405  void CreateCasePath(vtkStdString &, vtkStdString &);
406  void SetTimeInformation(vtkInformationVector *, vtkDoubleArray *);
407  void CreateCharArrayFromString(vtkCharArray *, const char *, vtkStdString &);
408  void UpdateStatus();
409  void UpdateProgress(double);
410 
411 private:
412  vtkOpenFOAMReader *Parent;
413 
414  vtkOpenFOAMReader(const vtkOpenFOAMReader&) = delete;
415  void operator=(const vtkOpenFOAMReader&) = delete;
416 
417  int GetNumberOfSelectionArrays(vtkDataArraySelection *);
418  int GetSelectionArrayStatus(vtkDataArraySelection *, const char *);
419  void SetSelectionArrayStatus(vtkDataArraySelection *, const char *, int);
420  const char *GetSelectionArrayName(vtkDataArraySelection *, int);
421  void DisableAllSelectionArrays(vtkDataArraySelection *);
422  void EnableAllSelectionArrays(vtkDataArraySelection *);
423 
424  void AddSelectionNames(vtkDataArraySelection *, vtkStringArray *);
425 };
426 
427 #endif
int GetCellArrayStatus(const char *name)
Get/Set whether the cell array with the given name is to be read.
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:34
void SetParent(vtkOpenFOAMReader *parent)
void SetLagrangianArrayStatus(const char *name, int status)
int GetPatchArrayStatus(const char *name)
Get/Set whether the Patch with the given name is to be read.
void SetPointArrayStatus(const char *name, int status)
vtkMTimeType LagrangianSelectionMTimeOld
Store vtkAlgorithm input/output information.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:302
int GetNumberOfCellArrays(void)
Get the number of cell arrays available in the input.
vtkDataArraySelection * LagrangianDataArraySelection
int GetPointArrayStatus(const char *name)
Get/Set whether the point array with the given name is to be read.
vtkMTimeType CellSelectionMTimeOld
const char * GetCellArrayName(int index)
Get the name of the cell array with the given index in the input.
vtkStringArray * LagrangianPaths
vtkDataArraySelection * CellDataArraySelection
a vtkAbstractArray subclass for strings
vtkTypeBool ListTimeStepsByControlDict
const char * GetPatchArrayName(int index)
Get the name of the Patch with the given index in the input.
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
int GetNumberOfLagrangianArrays(void)
Get the number of Lagrangian arrays available in the input.
const char * GetLagrangianArrayName(int index)
Get the name of the Lagrangian array with the given index in the input.
dynamic, self-adjusting array of double
vtkTypeBool CreateCellToPoint
static vtkMultiBlockDataSetAlgorithm * New()
vtkStdString * FileNameOld
int vtkTypeBool
Definition: vtkABI.h:69
void DisableAllCellArrays()
Turn on/off all cell arrays.
dynamic, self-adjusting array of char
Definition: vtkCharArray.h:35
vtkTypeBool AddDimensionsToArrayNames
int GetNumberOfPatchArrays(void)
Get the number of Patches (including Internal Mesh) available in the input.
a simple class to control print indentation
Definition: vtkIndent.h:33
Store on/off settings for data arrays for a vtkSource.
vtkDataArraySelection * PointDataArraySelection
reads a dataset in OpenFOAM format
virtual void Modified()
Update the modification time for this object.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkMTimeType PatchSelectionMTimeOld
void DisableAllPatchArrays()
Turn on/off all Patches including the Internal Mesh.
void DisableAllLagrangianArrays()
Turn on/off all Lagrangian arrays.
const char * GetPointArrayName(int index)
Get the name of the point array with the given index in the input.
void UpdateProgress(double amount)
Update the progress of the process object.
int GetNumberOfPointArrays(void)
Get the number of point arrays available in the input.
create and manipulate ordered lists of objects
Definition: vtkCollection.h:48
vtkTypeBool PositionsIsIn13Format
void SetPatchArrayStatus(const char *name, int status)
vtkCharArray * CasePath
void DisableAllPointArrays()
Turn on/off all point arrays.
int GetLagrangianArrayStatus(const char *name)
Get/Set whether the Lagrangian array with the given name is to be read.
Store zero or more vtkInformation instances.
vtkCollection * Readers
vtkMTimeType PointSelectionMTimeOld
void SetCellArrayStatus(const char *name, int status)
vtkTypeBool DecomposePolyhedra
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
vtkDataArraySelection * PatchDataArraySelection