VTK  9.0.1
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  {
85  return this->GetNumberOfSelectionArrays(this->CellDataArraySelection);
86  }
87 
92  int GetCellArrayStatus(const char* name)
93  {
94  return this->GetSelectionArrayStatus(this->CellDataArraySelection, name);
95  }
96  void SetCellArrayStatus(const char* name, int status)
97  {
98  this->SetSelectionArrayStatus(this->CellDataArraySelection, name, status);
99  }
100 
105  const char* GetCellArrayName(int index)
106  {
107  return this->GetSelectionArrayName(this->CellDataArraySelection, index);
108  }
109 
113  void DisableAllCellArrays() { this->DisableAllSelectionArrays(this->CellDataArraySelection); }
114  void EnableAllCellArrays() { this->EnableAllSelectionArrays(this->CellDataArraySelection); }
115 
120  {
121  return this->GetNumberOfSelectionArrays(this->PointDataArraySelection);
122  }
123 
128  int GetPointArrayStatus(const char* name)
129  {
130  return this->GetSelectionArrayStatus(this->PointDataArraySelection, name);
131  }
132  void SetPointArrayStatus(const char* name, int status)
133  {
134  this->SetSelectionArrayStatus(this->PointDataArraySelection, name, status);
135  }
136 
141  const char* GetPointArrayName(int index)
142  {
143  return this->GetSelectionArrayName(this->PointDataArraySelection, index);
144  }
145 
149  void DisableAllPointArrays() { this->DisableAllSelectionArrays(this->PointDataArraySelection); }
150  void EnableAllPointArrays() { this->EnableAllSelectionArrays(this->PointDataArraySelection); }
151 
156  {
157  return this->GetNumberOfSelectionArrays(this->LagrangianDataArraySelection);
158  }
159 
165  {
166  return this->GetSelectionArrayStatus(this->LagrangianDataArraySelection, name);
167  }
168  void SetLagrangianArrayStatus(const char* name, int status)
169  {
170  this->SetSelectionArrayStatus(this->LagrangianDataArraySelection, name, status);
171  }
172 
177  const char* GetLagrangianArrayName(int index)
178  {
179  return this->GetSelectionArrayName(this->LagrangianDataArraySelection, index);
180  }
181 
186  {
187  this->DisableAllSelectionArrays(this->LagrangianDataArraySelection);
188  }
190  {
191  this->EnableAllSelectionArrays(this->LagrangianDataArraySelection);
192  }
193 
198  {
199  return this->GetNumberOfSelectionArrays(this->PatchDataArraySelection);
200  }
201 
206  int GetPatchArrayStatus(const char* name)
207  {
208  return this->GetSelectionArrayStatus(this->PatchDataArraySelection, name);
209  }
210  void SetPatchArrayStatus(const char* name, int status)
211  {
212  this->SetSelectionArrayStatus(this->PatchDataArraySelection, name, status);
213  }
214 
219  const char* GetPatchArrayName(int index)
220  {
221  return this->GetSelectionArrayName(this->PatchDataArraySelection, index);
222  }
223 
227  void DisableAllPatchArrays() { this->DisableAllSelectionArrays(this->PatchDataArraySelection); }
228  void EnableAllPatchArrays() { this->EnableAllSelectionArrays(this->PatchDataArraySelection); }
229 
231 
234  vtkSetMacro(CreateCellToPoint, vtkTypeBool);
235  vtkGetMacro(CreateCellToPoint, vtkTypeBool);
236  vtkBooleanMacro(CreateCellToPoint, vtkTypeBool);
238 
240 
243  vtkSetMacro(CacheMesh, vtkTypeBool);
244  vtkGetMacro(CacheMesh, vtkTypeBool);
245  vtkBooleanMacro(CacheMesh, vtkTypeBool);
247 
249 
252  vtkSetMacro(DecomposePolyhedra, vtkTypeBool);
253  vtkGetMacro(DecomposePolyhedra, vtkTypeBool);
254  vtkBooleanMacro(DecomposePolyhedra, vtkTypeBool);
256 
257  // Option for reading old binary lagrangian/positions format
259 
265  vtkSetMacro(PositionsIsIn13Format, vtkTypeBool);
266  vtkGetMacro(PositionsIsIn13Format, vtkTypeBool);
267  vtkBooleanMacro(PositionsIsIn13Format, vtkTypeBool);
269 
271 
275  vtkSetMacro(SkipZeroTime, bool);
276  vtkGetMacro(SkipZeroTime, bool);
277  vtkBooleanMacro(SkipZeroTime, bool);
279 
281 
284  vtkSetMacro(ListTimeStepsByControlDict, vtkTypeBool);
285  vtkGetMacro(ListTimeStepsByControlDict, vtkTypeBool);
286  vtkBooleanMacro(ListTimeStepsByControlDict, vtkTypeBool);
288 
290 
293  vtkSetMacro(AddDimensionsToArrayNames, vtkTypeBool);
294  vtkGetMacro(AddDimensionsToArrayNames, vtkTypeBool);
295  vtkBooleanMacro(AddDimensionsToArrayNames, vtkTypeBool);
297 
299 
302  vtkSetMacro(ReadZones, vtkTypeBool);
303  vtkGetMacro(ReadZones, vtkTypeBool);
304  vtkBooleanMacro(ReadZones, vtkTypeBool);
306 
308 
311  virtual void SetUse64BitLabels(bool val);
312  vtkGetMacro(Use64BitLabels, bool);
313  vtkBooleanMacro(Use64BitLabels, bool);
315 
317 
321  vtkGetMacro(CopyDataToCellZones, bool);
322  vtkSetMacro(CopyDataToCellZones, bool);
323  vtkBooleanMacro(CopyDataToCellZones, bool);
325 
327 
332  virtual void SetUse64BitFloats(bool val);
333  vtkGetMacro(Use64BitFloats, bool);
334  vtkBooleanMacro(Use64BitFloats, bool);
336 
337  void SetRefresh()
338  {
339  this->Refresh = true;
340  this->Modified();
341  }
342 
343  void SetParent(vtkOpenFOAMReader* parent) { this->Parent = parent; }
344  int MakeInformationVector(vtkInformationVector*, const vtkStdString&);
345  bool SetTimeValue(const double);
346  vtkDoubleArray* GetTimeValues();
347  int MakeMetaDataAtTimeStep(const bool);
348 
349  friend class vtkOpenFOAMReaderPrivate;
350 
351 protected:
352  // refresh flag
353  bool Refresh;
354 
355  // for creating cell-to-point translated data
357 
358  // for caching mesh
360 
361  // for decomposing polyhedra on-the-fly
363 
364  // for lagrangian/positions without extra data (OF 1.4 - 2.4)
366 
367  // for reading point/face/cell-Zones
369 
370  // Ignore 0/ directory
372 
373  // determine if time directories are listed according to controlDict
375 
376  // add dimensions to array names
378 
379  // Expect label size to be 64-bit integers instead of 32-bit.
381 
382  // Expect float data to be 64-bit floats instead of 32-bit.
383  // Note that vtkFloatArrays may still be used -- this just tells the reader how to
384  // parse the binary data.
386 
387  // The data of internal mesh are copied to cell zones
389 
390  char* FileName;
393 
394  // DataArraySelection for Patch / Region Data
399 
400  // old selection status
405 
406  // preserved old information
417 
418  // paths to Lagrangians
420 
421  // number of reader instances
423  // index of the active reader
425 
427  ~vtkOpenFOAMReader() override;
430 
431  void CreateCasePath(vtkStdString&, vtkStdString&);
432  void SetTimeInformation(vtkInformationVector*, vtkDoubleArray*);
433  void CreateCharArrayFromString(vtkCharArray*, const char*, vtkStdString&);
434  void UpdateStatus();
435  void UpdateProgress(double);
436 
437 private:
438  vtkOpenFOAMReader* Parent;
439 
440  vtkOpenFOAMReader(const vtkOpenFOAMReader&) = delete;
441  void operator=(const vtkOpenFOAMReader&) = delete;
442 
443  int GetNumberOfSelectionArrays(vtkDataArraySelection*);
444  int GetSelectionArrayStatus(vtkDataArraySelection*, const char*);
445  void SetSelectionArrayStatus(vtkDataArraySelection*, const char*, int);
446  const char* GetSelectionArrayName(vtkDataArraySelection*, int);
447  void DisableAllSelectionArrays(vtkDataArraySelection*);
448  void EnableAllSelectionArrays(vtkDataArraySelection*);
449 
450  void AddSelectionNames(vtkDataArraySelection*, vtkStringArray*);
451 };
452 
453 #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:293
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:52
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