VTK
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 
38 #ifndef vtkSLACReader_h
39 #define vtkSLACReader_h
40 
41 #include "vtkIONetCDFModule.h" // For export macro
43 
44 #include "vtkSmartPointer.h" // For internal method.
45 
47 class vtkDoubleArray;
48 class vtkIdTypeArray;
51 
52 class VTKIONETCDF_EXPORT vtkSLACReader : public vtkMultiBlockDataSetAlgorithm
53 {
54 public:
56  static vtkSLACReader *New();
57  void PrintSelf(ostream &os, vtkIndent indent) override;
58 
59  vtkGetStringMacro(MeshFileName);
60  vtkSetStringMacro(MeshFileName);
61 
63 
68  virtual void AddModeFileName(const char *fname);
69  virtual void RemoveAllModeFileNames();
70  virtual unsigned int GetNumberOfModeFileNames();
71  virtual const char *GetModeFileName(unsigned int idx);
73 
75 
78  vtkGetMacro(ReadInternalVolume, vtkTypeBool);
79  vtkSetMacro(ReadInternalVolume, vtkTypeBool);
80  vtkBooleanMacro(ReadInternalVolume, vtkTypeBool);
82 
84 
87  vtkGetMacro(ReadExternalSurface, vtkTypeBool);
88  vtkSetMacro(ReadExternalSurface, vtkTypeBool);
89  vtkBooleanMacro(ReadExternalSurface, vtkTypeBool);
91 
93 
97  vtkGetMacro(ReadMidpoints, vtkTypeBool);
98  vtkSetMacro(ReadMidpoints, vtkTypeBool);
99  vtkBooleanMacro(ReadMidpoints, vtkTypeBool);
101 
103 
106  virtual int GetNumberOfVariableArrays();
107  virtual const char *GetVariableArrayName(int idx);
108  virtual int GetVariableArrayStatus(const char *name);
109  virtual void SetVariableArrayStatus(const char *name, int status);
111 
113 
116  virtual void ResetFrequencyScales();
117  virtual void SetFrequencyScale(int index, double scale);
119 
121 
124  virtual void ResetPhaseShifts();
125  virtual void SetPhaseShift(int index, double shift);
127 
129 
132  virtual vtkDoubleArray* GetFrequencyScales();
133  virtual vtkDoubleArray* GetPhaseShifts();
135 
139  static int CanReadFile(const char *filename);
140 
145  static vtkInformationIntegerKey *IS_INTERNAL_VOLUME();
146 
151  static vtkInformationIntegerKey *IS_EXTERNAL_SURFACE();
152 
154 
160  static vtkInformationObjectBaseKey *POINTS();
161  static vtkInformationObjectBaseKey *POINT_DATA();
163 
165 
169  class VTKIONETCDF_EXPORT EdgeEndpoints
170  {
171  public:
172  EdgeEndpoints() : MinEndPoint(-1), MaxEndPoint(-1) {}
173  EdgeEndpoints(vtkIdType endpointA, vtkIdType endpointB) {
174  if (endpointA < endpointB)
175  {
176  this->MinEndPoint = endpointA; this->MaxEndPoint = endpointB;
177  }
178  else
179  {
180  this->MinEndPoint = endpointB; this->MaxEndPoint = endpointA;
181  }
182  }
183  inline vtkIdType GetMinEndPoint() const { return this->MinEndPoint; }
184  inline vtkIdType GetMaxEndPoint() const { return this->MaxEndPoint; }
185  inline bool operator==(const EdgeEndpoints &other) const {
186  return ( (this->GetMinEndPoint() == other.GetMinEndPoint())
187  && (this->GetMaxEndPoint() == other.GetMaxEndPoint()) );
188  }
189  protected:
192  };
194 
196 
199  class VTKIONETCDF_EXPORT MidpointCoordinates
200  {
201  public:
203  MidpointCoordinates(const double coord[3], vtkIdType id) {
204  this->Coordinate[0] = coord[0];
205  this->Coordinate[1] = coord[1];
206  this->Coordinate[2] = coord[2];
207  this->ID = id;
208  }
209  double Coordinate[3];
211  };
213 
214  enum {
215  SURFACE_OUTPUT = 0,
216  VOLUME_OUTPUT = 1,
217  NUM_OUTPUTS = 2
218  };
219 
220 protected:
221  vtkSLACReader();
222  ~vtkSLACReader() override;
223 
224  class vtkInternal;
225  vtkInternal *Internal;
226 
227  // Friend so vtkInternal can access MidpointIdMap
228  // (so Sun CC compiler doesn't complain).
229  friend class vtkInternal;
230 
232 
236 
241 
246 
251 
252  int RequestInformation(vtkInformation *request,
253  vtkInformationVector **inputVector,
254  vtkInformationVector *outputVector) override;
255 
256  int RequestData(vtkInformation *request,
257  vtkInformationVector **inputVector,
258  vtkInformationVector *outputVector) override;
259 
263  static void SelectionModifiedCallback(vtkObject *caller, unsigned long eid,
264  void *clientdata, void *calldata);
265 
273  virtual vtkIdType GetNumTuplesInVariable(int ncFD, int varId,
274  int expectedNumComponents);
275 
280  virtual int CheckTetrahedraWinding(int meshFD);
281 
286  virtual int ReadConnectivity(int meshFD, vtkMultiBlockDataSet *surfaceOutput,
287  vtkMultiBlockDataSet *volumeOutput);
288 
290 
293  virtual int ReadTetrahedronInteriorArray(int meshFD,
294  vtkIdTypeArray *connectivity);
295  virtual int ReadTetrahedronExteriorArray(int meshFD,
296  vtkIdTypeArray *connectivity);
298 
302  virtual vtkSmartPointer<vtkDataArray> ReadPointDataArray(int ncFD, int varId);
303 
307  enum {
308  NumPerTetInt = 5,
309  NumPerTetExt = 9
310  };
311 
313 
316  class VTKIONETCDF_EXPORT MidpointCoordinateMap
317  {
318  public:
322 
323  void AddMidpoint(const EdgeEndpoints &edge,
324  const MidpointCoordinates &midpoint);
325  void RemoveMidpoint(const EdgeEndpoints &edge);
326  void RemoveAllMidpoints();
327  vtkIdType GetNumberOfMidpoints() const;
328 
333  MidpointCoordinates *FindMidpoint(const EdgeEndpoints &edge);
334 
335  protected:
336  class vtkInternal;
337  vtkInternal *Internal;
338 
339  private:
340  // Too lazy to implement these.
342  void operator=(const MidpointCoordinateMap &);
343  };
344 
346 
349  class VTKIONETCDF_EXPORT MidpointIdMap
350  {
351  public:
352  MidpointIdMap();
353  ~MidpointIdMap();
355 
356  void AddMidpoint(const EdgeEndpoints &edge, vtkIdType midpoint);
357  void RemoveMidpoint(const EdgeEndpoints &edge);
358  void RemoveAllMidpoints();
359  vtkIdType GetNumberOfMidpoints() const;
360 
364  vtkIdType *FindMidpoint(const EdgeEndpoints &edge);
365 
369  void InitTraversal();
373  bool GetNextMidpoint(EdgeEndpoints &edge, vtkIdType &midpoint);
374 
375  protected:
376  class vtkInternal;
377  vtkInternal *Internal;
378 
379  private:
380  // Too lazy to implement these.
381  MidpointIdMap(const MidpointIdMap &);
382  void operator=(const MidpointIdMap &);
383  };
384 
389  virtual int ReadCoordinates(int meshFD, vtkMultiBlockDataSet *output);
390 
396  virtual int ReadMidpointCoordinates(int meshFD, vtkMultiBlockDataSet *output,
397  MidpointCoordinateMap &map);
398 
404  virtual int ReadMidpointData(int meshFD, vtkMultiBlockDataSet *output,
405  MidpointIdMap &map);
406 
411  virtual int RestoreMeshCache(vtkMultiBlockDataSet *surfaceOutput,
412  vtkMultiBlockDataSet *volumeOutput,
413  vtkMultiBlockDataSet *compositeOutput);
414 
419  virtual int ReadFieldData(const int *modeFDArray,
420  int numModeFDs,
421  vtkMultiBlockDataSet *output);
422 
427  virtual int InterpolateMidpointData(vtkMultiBlockDataSet *output,
428  MidpointIdMap &map);
429 
436 
441  virtual int MeshUpToDate();
442 
443 private:
444  vtkSLACReader(const vtkSLACReader &) = delete;
445  void operator=(const vtkSLACReader &) = delete;
446 };
447 
448 #endif //vtkSLACReader_h
vtkSLACReader::MidpointCoordinateMap
Manages a map from edges to midpoint coordinates.
Definition: vtkSLACReader.h:316
vtkSLACReader::MidpointIdMap
Manages a map from edges to the point id of the midpoint.
Definition: vtkSLACReader.h:349
vtkSLACReader::MidpointCoordinates::MidpointCoordinates
MidpointCoordinates()
Definition: vtkSLACReader.h:202
vtkSLACReader::EdgeEndpoints
Simple class used internally to define an edge based on the endpoints.
Definition: vtkSLACReader.h:169
vtkSLACReader::EdgeEndpoints::MinEndPoint
vtkIdType MinEndPoint
Definition: vtkSLACReader.h:190
vtkX3D::scale
Definition: vtkX3D.h:229
vtkIdType
int vtkIdType
Definition: vtkType.h:347
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:41
vtkSLACReader::FrequencyModes
bool FrequencyModes
True if mode files describe vibrating fields.
Definition: vtkSLACReader.h:250
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:35
vtkSLACReader::ReadInternalVolume
vtkTypeBool ReadInternalVolume
Definition: vtkSLACReader.h:233
vtkSLACReader::MeshFileName
char * MeshFileName
Definition: vtkSLACReader.h:231
vtkSmartPointer< vtkDataArray >
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:59
vtkMultiBlockDataSetAlgorithm::New
static vtkMultiBlockDataSetAlgorithm * New()
vtkSLACReader::EdgeEndpoints::MaxEndPoint
vtkIdType MaxEndPoint
Definition: vtkSLACReader.h:191
vtkSLACReader
Definition: vtkSLACReader.h:52
vtkSLACReader::TimeStepModes
bool TimeStepModes
True if "mode" files are a sequence of time steps.
Definition: vtkSLACReader.h:245
vtkMultiBlockDataSet
Composite dataset that organizes datasets into blocks.
Definition: vtkMultiBlockDataSet.h:51
vtkDataArraySelection
Store on/off settings for data arrays for a vtkSource.
Definition: vtkDataArraySelection.h:37
vtkSLACReader::EdgeEndpoints::operator==
bool operator==(const EdgeEndpoints &other) const
Definition: vtkSLACReader.h:185
vtkSLACReader::MidpointCoordinates::ID
vtkIdType ID
Definition: vtkSLACReader.h:210
vtkInformationObjectBaseKey
Key for vtkObjectBase values.
Definition: vtkInformationObjectBaseKey.h:36
vtkSLACReader::ReadModeData
bool ReadModeData
True if reading from a proper mode file.
Definition: vtkSLACReader.h:240
vtkInformationIntegerKey
Key for integer values in vtkInformation.
Definition: vtkInformationIntegerKey.h:34
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:39
vtkSLACReader::EdgeEndpoints::EdgeEndpoints
EdgeEndpoints()
Definition: vtkSLACReader.h:172
vtkSmartPointer.h
vtkSLACReader::ReadMidpoints
vtkTypeBool ReadMidpoints
Definition: vtkSLACReader.h:235
vtkMultiBlockDataSetAlgorithm.h
vtkSLACReader::EdgeEndpoints::GetMinEndPoint
vtkIdType GetMinEndPoint() const
Definition: vtkSLACReader.h:183
vtkX3D::name
Definition: vtkX3D.h:219
vtkSLACReader::MeshReadTime
vtkTimeStamp MeshReadTime
A time stamp for the last time the mesh file was read.
Definition: vtkSLACReader.h:435
vtkMultiBlockDataSetAlgorithm::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:86
vtkIdTypeArray
dynamic, self-adjusting array of vtkIdType
Definition: vtkIdTypeArray.h:41
vtkSLACReader::MidpointIdMap::Internal
vtkInternal * Internal
Definition: vtkSLACReader.h:376
vtkSLACReader::EdgeEndpoints::GetMaxEndPoint
vtkIdType GetMaxEndPoint() const
Definition: vtkSLACReader.h:184
vtkSLACReader::MidpointCoordinates
Simple class used internally for holding midpoint information.
Definition: vtkSLACReader.h:199
vtkDoubleArray
dynamic, self-adjusting array of double
Definition: vtkDoubleArray.h:41
vtkSLACReader::MidpointCoordinates::MidpointCoordinates
MidpointCoordinates(const double coord[3], vtkIdType id)
Definition: vtkSLACReader.h:203
vtkSLACReader::EdgeEndpoints::EdgeEndpoints
EdgeEndpoints(vtkIdType endpointA, vtkIdType endpointB)
Definition: vtkSLACReader.h:173
vtkSLACReader::Internal
vtkInternal * Internal
Definition: vtkSLACReader.h:224
vtkX3D::index
Definition: vtkX3D.h:246
vtkSLACReader::MidpointCoordinateMap::Internal
vtkInternal * Internal
Definition: vtkSLACReader.h:336
vtkSLACReader::ReadExternalSurface
vtkTypeBool ReadExternalSurface
Definition: vtkSLACReader.h:234
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkX3D::Coordinate
Definition: vtkX3D.h:44
vtkMultiBlockDataSetAlgorithm
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
Definition: vtkMultiBlockDataSetAlgorithm.h:35