VTK  9.1.20211115
vtkSLACReader.h
Go to the documentation of this file.
1 // -*- c++ -*-
2 /*=========================================================================
3 
4  Program: Visualization Toolkit
5  Module: vtkSLACReader.h
6 
7  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
8  All rights reserved.
9  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
10 
11  This software is distributed WITHOUT ANY WARRANTY; without even
12  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
13  PURPOSE. See the above copyright notice for more information.
14 
15 =========================================================================*/
16 
17 /*-------------------------------------------------------------------------
18  Copyright 2008 Sandia Corporation.
19  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
20  the U.S. Government retains certain rights in this software.
21 -------------------------------------------------------------------------*/
22 
35 #ifndef vtkSLACReader_h
36 #define vtkSLACReader_h
37 
38 #include "vtkIONetCDFModule.h" // For export macro
40 
41 #include "vtkSmartPointer.h" // For internal method.
42 
44 class vtkDoubleArray;
45 class vtkIdTypeArray;
48 
49 class VTKIONETCDF_EXPORT vtkSLACReader : public vtkMultiBlockDataSetAlgorithm
50 {
51 public:
53  static vtkSLACReader* New();
54  void PrintSelf(ostream& os, vtkIndent indent) override;
55 
56  vtkGetFilePathMacro(MeshFileName);
57  vtkSetFilePathMacro(MeshFileName);
58 
60 
65  virtual void AddModeFileName(VTK_FILEPATH const char* fname);
66  virtual void RemoveAllModeFileNames();
67  virtual unsigned int GetNumberOfModeFileNames();
68  virtual VTK_FILEPATH const char* GetModeFileName(unsigned int idx);
70 
72 
75  vtkGetMacro(ReadInternalVolume, vtkTypeBool);
76  vtkSetMacro(ReadInternalVolume, vtkTypeBool);
77  vtkBooleanMacro(ReadInternalVolume, vtkTypeBool);
79 
81 
84  vtkGetMacro(ReadExternalSurface, vtkTypeBool);
85  vtkSetMacro(ReadExternalSurface, vtkTypeBool);
86  vtkBooleanMacro(ReadExternalSurface, vtkTypeBool);
88 
90 
94  vtkGetMacro(ReadMidpoints, vtkTypeBool);
95  vtkSetMacro(ReadMidpoints, vtkTypeBool);
96  vtkBooleanMacro(ReadMidpoints, vtkTypeBool);
98 
100 
104  virtual const char* GetVariableArrayName(int index);
105  virtual int GetVariableArrayStatus(const char* name);
106  virtual void SetVariableArrayStatus(const char* name, int status);
108 
110 
113  virtual void ResetFrequencyScales();
114  virtual void SetFrequencyScale(int index, double scale);
116 
118 
121  virtual void ResetPhaseShifts();
122  virtual void SetPhaseShift(int index, double shift);
124 
126 
132 
136  static int CanReadFile(VTK_FILEPATH const char* filename);
137 
143 
149 
151 
160 
162 
166  class VTKIONETCDF_EXPORT EdgeEndpoints
167  {
168  public:
170  : MinEndPoint(-1)
171  , MaxEndPoint(-1)
172  {
173  }
174  EdgeEndpoints(vtkIdType endpointA, vtkIdType endpointB)
175  {
176  if (endpointA < endpointB)
177  {
178  this->MinEndPoint = endpointA;
179  this->MaxEndPoint = endpointB;
180  }
181  else
182  {
183  this->MinEndPoint = endpointB;
184  this->MaxEndPoint = endpointA;
185  }
186  }
187  inline vtkIdType GetMinEndPoint() const { return this->MinEndPoint; }
188  inline vtkIdType GetMaxEndPoint() const { return this->MaxEndPoint; }
189  inline bool operator==(const EdgeEndpoints& other) const
190  {
191  return ((this->GetMinEndPoint() == other.GetMinEndPoint()) &&
192  (this->GetMaxEndPoint() == other.GetMaxEndPoint()));
193  }
194 
195  protected:
198  };
200 
202 
205  class VTKIONETCDF_EXPORT MidpointCoordinates
206  {
207  public:
208  MidpointCoordinates() = default;
209  MidpointCoordinates(const double coord[3], vtkIdType id)
210  {
211  this->Coordinate[0] = coord[0];
212  this->Coordinate[1] = coord[1];
213  this->Coordinate[2] = coord[2];
214  this->ID = id;
215  }
216  double Coordinate[3];
218  };
220 
221  enum
222  {
223  SURFACE_OUTPUT = 0,
224  VOLUME_OUTPUT = 1,
225  NUM_OUTPUTS = 2
226  };
227 
228 protected:
230  ~vtkSLACReader() override;
231 
232  class vtkInternal;
233  vtkInternal* Internal;
234 
235  // Friend so vtkInternal can access MidpointIdMap
236  // (so Sun CC compiler doesn't complain).
237  friend class vtkInternal;
238 
240 
244 
249 
254 
259 
261  vtkInformationVector* outputVector) override;
262 
263  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
264  vtkInformationVector* outputVector) override;
265 
270  vtkObject* caller, unsigned long eid, void* clientdata, void* calldata);
271 
279  virtual vtkIdType GetNumTuplesInVariable(int ncFD, int varId, int expectedNumComponents);
280 
285  virtual int CheckTetrahedraWinding(int meshFD);
286 
291  virtual int ReadConnectivity(
292  int meshFD, vtkMultiBlockDataSet* surfaceOutput, vtkMultiBlockDataSet* volumeOutput);
293 
295 
298  virtual int ReadTetrahedronInteriorArray(int meshFD, vtkIdTypeArray* connectivity);
299  virtual int ReadTetrahedronExteriorArray(int meshFD, vtkIdTypeArray* connectivity);
301 
305  virtual vtkSmartPointer<vtkDataArray> ReadPointDataArray(int ncFD, int varId);
306 
310  enum
311  {
312  NumPerTetInt = 5,
313  NumPerTetExt = 9
314  };
315 
317 
320  class VTKIONETCDF_EXPORT MidpointCoordinateMap
321  {
322  public:
326 
327  void AddMidpoint(const EdgeEndpoints& edge, const MidpointCoordinates& midpoint);
328  void RemoveMidpoint(const EdgeEndpoints& edge);
331 
337 
338  protected:
339  class vtkInternal;
340  vtkInternal* Internal;
341 
342  private:
343  // Too lazy to implement these.
345  void operator=(const MidpointCoordinateMap&) = delete;
346  };
347 
349 
352  class VTKIONETCDF_EXPORT MidpointIdMap
353  {
354  public:
358 
359  void AddMidpoint(const EdgeEndpoints& edge, vtkIdType midpoint);
360  void RemoveMidpoint(const EdgeEndpoints& edge);
363 
368 
376  bool GetNextMidpoint(EdgeEndpoints& edge, vtkIdType& midpoint);
377 
378  protected:
379  class vtkInternal;
380  vtkInternal* Internal;
381 
382  private:
383  // Too lazy to implement these.
384  MidpointIdMap(const MidpointIdMap&) = delete;
385  void operator=(const MidpointIdMap&) = delete;
386  };
387 
392  virtual int ReadCoordinates(int meshFD, vtkMultiBlockDataSet* output);
393 
400  int meshFD, vtkMultiBlockDataSet* output, MidpointCoordinateMap& map);
401 
407  virtual int ReadMidpointData(
408  int meshFD, vtkMultiBlockDataSet* output, MidpointIdMap& midpointIds);
409 
414  virtual int RestoreMeshCache(vtkMultiBlockDataSet* surfaceOutput,
415  vtkMultiBlockDataSet* volumeOutput, vtkMultiBlockDataSet* compositeOutput);
416 
421  virtual int ReadFieldData(const int* modeFDArray, int numModeFDs, vtkMultiBlockDataSet* output);
422 
428 
435 
440  virtual int MeshUpToDate();
441 
442 private:
443  vtkSLACReader(const vtkSLACReader&) = delete;
444  void operator=(const vtkSLACReader&) = delete;
445 };
446 
447 #endif // vtkSLACReader_h
Store on/off settings for data arrays for a vtkSource.
dynamic, self-adjusting array of double
dynamic, self-adjusting array of vtkIdType
a simple class to control print indentation
Definition: vtkIndent.h:113
Key for integer values in vtkInformation.
Key for vtkObjectBase values.
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
Composite dataset that organizes datasets into blocks.
abstract base class for most VTK objects
Definition: vtkObject.h:82
Simple class used internally to define an edge based on the endpoints.
vtkIdType GetMinEndPoint() const
vtkIdType GetMaxEndPoint() const
bool operator==(const EdgeEndpoints &other) const
EdgeEndpoints(vtkIdType endpointA, vtkIdType endpointB)
Manages a map from edges to midpoint coordinates.
MidpointCoordinates * FindMidpoint(const EdgeEndpoints &edge)
Finds the coordinates for the given edge or returns nullptr if it does not exist.
void RemoveMidpoint(const EdgeEndpoints &edge)
void AddMidpoint(const EdgeEndpoints &edge, const MidpointCoordinates &midpoint)
Simple class used internally for holding midpoint information.
MidpointCoordinates(const double coord[3], vtkIdType id)
Manages a map from edges to the point id of the midpoint.
vtkIdType * FindMidpoint(const EdgeEndpoints &edge)
Finds the id for the given edge or returns nullptr if it does not exist.
vtkIdType GetNumberOfMidpoints() const
void AddMidpoint(const EdgeEndpoints &edge, vtkIdType midpoint)
void InitTraversal()
Initialize iteration.
bool GetNextMidpoint(EdgeEndpoints &edge, vtkIdType &midpoint)
Get the next midpoint in the iteration.
void RemoveMidpoint(const EdgeEndpoints &edge)
A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Line...
Definition: vtkSLACReader.h:50
virtual void ResetFrequencyScales()
Sets the scale factor for each mode.
int RequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
This is called by the superclass.
bool TimeStepModes
True if "mode" files are a sequence of time steps.
virtual vtkDoubleArray * GetPhaseShifts()
NOTE: This is not thread-safe.
static vtkInformationIntegerKey * IS_EXTERNAL_SURFACE()
This key is attached to the metadata information of all data sets in the output that are part of the ...
vtkInternal * Internal
virtual void SetPhaseShift(int index, double shift)
Sets the phase offset for each mode.
virtual void SetFrequencyScale(int index, double scale)
Sets the scale factor for each mode.
virtual int ReadMidpointCoordinates(int meshFD, vtkMultiBlockDataSet *output, MidpointCoordinateMap &map)
Reads in the midpoint coordinate data from the mesh file and returns a map from edges to midpoints.
static void SelectionModifiedCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata)
Callback registered with the VariableArraySelection.
static int CanReadFile(VTK_FILEPATH const char *filename)
Returns true if the given file can be read by this reader.
vtkTypeBool ReadMidpoints
virtual vtkDoubleArray * GetFrequencyScales()
NOTE: This is not thread-safe.
~vtkSLACReader() override
vtkGetFilePathMacro(MeshFileName)
static vtkInformationObjectBaseKey * POINTS()
All the data sets stored in the multiblock output share the same point data.
virtual int RestoreMeshCache(vtkMultiBlockDataSet *surfaceOutput, vtkMultiBlockDataSet *volumeOutput, vtkMultiBlockDataSet *compositeOutput)
Instead of reading data from the mesh file, restore the data from the previous mesh file read.
virtual int ReadTetrahedronExteriorArray(int meshFD, vtkIdTypeArray *connectivity)
Reads tetrahedron connectivity arrays.
virtual int ReadFieldData(const int *modeFDArray, int numModeFDs, vtkMultiBlockDataSet *output)
Read in the field data from the mode file.
virtual void ResetPhaseShifts()
Sets the phase offset for each mode.
static vtkInformationIntegerKey * IS_INTERNAL_VOLUME()
This key is attached to the metadata information of all data sets in the output that are part of the ...
virtual int MeshUpToDate()
Returns 1 if the mesh is up to date, 0 if the mesh needs to be read from disk.
char * MeshFileName
virtual int ReadMidpointData(int meshFD, vtkMultiBlockDataSet *output, MidpointIdMap &midpointIds)
Read in the midpoint data from the mesh file.
virtual unsigned int GetNumberOfModeFileNames()
There may be one mode file (usually for actual modes) or multiple mode files (which usually actually ...
bool FrequencyModes
True if mode files describe vibrating fields.
virtual VTK_FILEPATH const char * GetModeFileName(unsigned int idx)
There may be one mode file (usually for actual modes) or multiple mode files (which usually actually ...
static vtkInformationObjectBaseKey * POINT_DATA()
All the data sets stored in the multiblock output share the same point data.
virtual int ReadCoordinates(int meshFD, vtkMultiBlockDataSet *output)
Read in the point coordinate data from the mesh file.
virtual vtkSmartPointer< vtkDataArray > ReadPointDataArray(int ncFD, int varId)
Reads point data arrays.
virtual int ReadTetrahedronInteriorArray(int meshFD, vtkIdTypeArray *connectivity)
Reads tetrahedron connectivity arrays.
static vtkSLACReader * New()
vtkTimeStamp MeshReadTime
A time stamp for the last time the mesh file was read.
virtual int ReadConnectivity(int meshFD, vtkMultiBlockDataSet *surfaceOutput, vtkMultiBlockDataSet *volumeOutput)
Read the connectivity information from the mesh file.
bool ReadModeData
True if reading from a proper mode file.
virtual int GetVariableArrayStatus(const char *name)
Variable array selection.
int RequestInformation(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
This is called by the superclass.
virtual vtkIdType GetNumTuplesInVariable(int ncFD, int varId, int expectedNumComponents)
Convenience function that checks the dimensions of a 2D netCDF array that is supposed to be a set of ...
vtkTypeBool ReadInternalVolume
virtual const char * GetVariableArrayName(int index)
Variable array selection.
vtkTypeBool ReadExternalSurface
virtual int InterpolateMidpointData(vtkMultiBlockDataSet *output, MidpointIdMap &map)
Takes the data read on the fields and interpolates data for the midpoints.
virtual void AddModeFileName(VTK_FILEPATH const char *fname)
There may be one mode file (usually for actual modes) or multiple mode files (which usually actually ...
virtual int GetNumberOfVariableArrays()
Variable array selection.
virtual void RemoveAllModeFileNames()
There may be one mode file (usually for actual modes) or multiple mode files (which usually actually ...
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkSetFilePathMacro(MeshFileName)
virtual int CheckTetrahedraWinding(int meshFD)
Checks the winding of the tetrahedra in the mesh file.
virtual void SetVariableArrayStatus(const char *name, int status)
Variable array selection.
record modification and/or execution time
Definition: vtkTimeStamp.h:52
@ Coordinate
Definition: vtkX3D.h:50
@ scale
Definition: vtkX3D.h:235
@ name
Definition: vtkX3D.h:225
@ index
Definition: vtkX3D.h:252
int vtkTypeBool
Definition: vtkABI.h:69
int vtkIdType
Definition: vtkType.h:332
#define VTK_FILEPATH