VTK
vtkExodusIIReader.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkExodusIIReader.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 =========================================================================*/
15 /*----------------------------------------------------------------------------
16  Copyright (c) Sandia Corporation
17  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
18 ----------------------------------------------------------------------------*/
19 
37 #ifndef vtkExodusIIReader_h
38 #define vtkExodusIIReader_h
39 
40 #include "vtkIOExodusModule.h" // For export macro
42 
43 class vtkDataArray;
44 class vtkDataSet;
45 class vtkExodusIICache;
47 class vtkFloatArray;
48 class vtkGraph;
49 class vtkIntArray;
50 class vtkPoints;
52 
53 class VTKIOEXODUS_EXPORT vtkExodusIIReader : public vtkMultiBlockDataSetAlgorithm
54 {
55 public:
56  static vtkExodusIIReader *New();
58  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
59 
63  int CanReadFile(const char* fname);
64 
65  //virtual void Modified();
66 
70  vtkMTimeType GetMTime() VTK_OVERRIDE;
71 
77  virtual vtkMTimeType GetMetadataMTime();
78 
80 
83  virtual void SetFileName( const char* fname );
84  vtkGetStringMacro(FileName);
86 
88 
91  virtual void SetXMLFileName( const char* fname );
92  vtkGetStringMacro(XMLFileName);
94 
96 
99  vtkSetMacro(TimeStep, int);
100  vtkGetMacro(TimeStep, int);
102 
107  void SetModeShape(int val)
108  {
109  this->SetTimeStep(val-1);
110  }
111 
113 
119  vtkGetVector2Macro(ModeShapesRange, int);
121 
123 
128  vtkGetVector2Macro(TimeStepRange,int);
130 
132 
143  virtual void SetGenerateObjectIdCellArray( int g );
144  int GetGenerateObjectIdCellArray();
145  vtkBooleanMacro(GenerateObjectIdCellArray, int);
146  static const char *GetObjectIdArrayName() { return "ObjectId"; }
148 
149  virtual void SetGenerateGlobalElementIdArray( int g );
150  int GetGenerateGlobalElementIdArray();
151  vtkBooleanMacro(GenerateGlobalElementIdArray, int);
152 
153  virtual void SetGenerateGlobalNodeIdArray( int g );
154  int GetGenerateGlobalNodeIdArray();
155  vtkBooleanMacro(GenerateGlobalNodeIdArray, int);
156 
157  virtual void SetGenerateImplicitElementIdArray( int g );
158  int GetGenerateImplicitElementIdArray();
159  vtkBooleanMacro(GenerateImplicitElementIdArray, int);
160 
161  virtual void SetGenerateImplicitNodeIdArray( int g );
162  int GetGenerateImplicitNodeIdArray();
163  vtkBooleanMacro(GenerateImplicitNodeIdArray, int);
164 
165  virtual void SetGenerateFileIdArray( int f );
166  int GetGenerateFileIdArray();
167  vtkBooleanMacro(GenerateFileIdArray, int);
168  virtual void SetFileId( int f );
169  int GetFileId();
170 
172 
178  enum {
179  SEARCH_TYPE_ELEMENT=0,
183  ID_NOT_FOUND=-234121312
184  };
185  // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
186  enum ObjectType {
187  // match Exodus macros from exodusII.h and exodusII_ext.h
188  EDGE_BLOCK = 6,
189  FACE_BLOCK = 8,
190  ELEM_BLOCK = 1,
191  NODE_SET = 2,
192  EDGE_SET = 7,
193  FACE_SET = 9,
194  SIDE_SET = 3,
195  ELEM_SET = 10,
196  NODE_MAP = 5,
197  EDGE_MAP = 11,
198  FACE_MAP = 12,
199  ELEM_MAP = 4,
200  GLOBAL = 13,
201  NODAL = 14,
202  // extended values (not in Exodus headers) for use with SetAllArrayStatus:
203  ASSEMBLY = 60,
204  PART = 61,
205  MATERIAL = 62,
206  HIERARCHY = 63,
207  // extended values (not in Exodus headers) for use in cache keys:
208  QA_RECORDS = 103,
209  INFO_RECORDS = 104,
210  GLOBAL_TEMPORAL = 102,
211  NODAL_TEMPORAL = 101,
212  ELEM_BLOCK_TEMPORAL = 100,
213  GLOBAL_CONN = 99,
214  ELEM_BLOCK_ELEM_CONN = 98,
215  ELEM_BLOCK_FACE_CONN = 97,
216  ELEM_BLOCK_EDGE_CONN = 96,
217  FACE_BLOCK_CONN = 95,
218  EDGE_BLOCK_CONN = 94,
219  ELEM_SET_CONN = 93,
220  SIDE_SET_CONN = 92,
221  FACE_SET_CONN = 91,
222  EDGE_SET_CONN = 90,
223  NODE_SET_CONN = 89,
224  NODAL_COORDS = 88,
225  OBJECT_ID = 87,
226  IMPLICIT_ELEMENT_ID = 108,
227  IMPLICIT_NODE_ID = 107,
228  GLOBAL_ELEMENT_ID = 86,
229  GLOBAL_NODE_ID = 85,
230  ELEMENT_ID = 84,
231  NODE_ID = 83,
232  NODAL_SQUEEZEMAP = 82,
233  ELEM_BLOCK_ATTRIB = 81,
234  FACE_BLOCK_ATTRIB = 80,
235  EDGE_BLOCK_ATTRIB = 79,
236  FACE_ID = 105,
237  EDGE_ID = 106,
238  ENTITY_COUNTS = 109
239  };
241 
242  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
243  static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
244  static int GetGlobalElementID( vtkDataSet *data, int localID );
245  static int GetGlobalElementID ( vtkDataSet *data, int localID,
246  int searchType );
247  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
248 
249  static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
250  static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
251  static int GetGlobalFaceID( vtkDataSet *data, int localID );
252  static int GetGlobalFaceID ( vtkDataSet *data, int localID,
253  int searchType );
254  static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }
255 
256  static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
257  static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
258  static int GetGlobalEdgeID( vtkDataSet *data, int localID );
259  static int GetGlobalEdgeID ( vtkDataSet *data, int localID,
260  int searchType );
261  static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }
262 
264 
270  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
271  static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }
272  static int GetGlobalNodeID( vtkDataSet *data, int localID );
273  static int GetGlobalNodeID( vtkDataSet *data, int localID,
274  int searchType );
275  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }
277 
282  static const char* GetSideSetSourceElementIdArrayName() { return "SourceElementId"; }
283 
288  static const char* GetSideSetSourceElementSideArrayName() { return "SourceElementSide"; }
290 
297  virtual void SetApplyDisplacements( int d );
298  int GetApplyDisplacements();
299  vtkBooleanMacro(ApplyDisplacements, int);
300  virtual void SetDisplacementMagnitude( float s );
301  float GetDisplacementMagnitude();
303 
305 
310  virtual void SetHasModeShapes( int ms );
311  int GetHasModeShapes();
312  vtkBooleanMacro(HasModeShapes,int);
314 
316 
323  virtual void SetModeShapeTime( double phase );
324  double GetModeShapeTime();
326 
328 
335  virtual void SetAnimateModeShapes(int flag);
336  int GetAnimateModeShapes();
337  vtkBooleanMacro(AnimateModeShapes, int);
339 
341 
344  const char* GetTitle();
345  int GetDimensionality();
346  int GetNumberOfTimeSteps();
348 
349  int GetNumberOfNodesInFile();
350  int GetNumberOfEdgesInFile();
351  int GetNumberOfFacesInFile();
352  int GetNumberOfElementsInFile();
353 
354  int GetObjectTypeFromName( const char* name );
355  const char* GetObjectTypeName( int );
356 
357  int GetNumberOfNodes();
358  int GetNumberOfObjects( int objectType );
359  int GetNumberOfEntriesInObject( int objectType, int objectIndex );
360  int GetObjectId( int objectType, int objectIndex );
361  const char* GetObjectName( int objectType, int objectIndex );
362  int GetObjectIndex( int objectType, const char* objectName );
363  int GetObjectIndex( int objectType, int id );
364  int GetObjectStatus( int objectType, int objectIndex );
365  int GetObjectStatus( int objectType, const char* objectName )
366  { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }
367  void SetObjectStatus( int objectType, int objectIndex, int status );
368  void SetObjectStatus( int objectType, const char* objectName, int status );
369 
371 
377  int GetNumberOfObjectArrays( int objectType );
378  const char* GetObjectArrayName( int objectType, int arrayIndex );
379  int GetObjectArrayIndex( int objectType, const char* arrayName );
380  int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );
381  int GetObjectArrayStatus( int objectType, int arrayIndex );
382  int GetObjectArrayStatus( int objectType, const char* arrayName )
383  { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }
384  void SetObjectArrayStatus( int objectType, int arrayIndex, int status );
385  void SetObjectArrayStatus( int objectType, const char* arrayName, int status );
387 
389 
395  int GetNumberOfObjectAttributes( int objectType, int objectIndex );
396  const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );
397  int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );
398  int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );
399  int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )
400  { return this->GetObjectAttributeStatus( objectType, objectIndex,
401  this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }
402  void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );
403  void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )
404  { this->SetObjectAttributeStatus( objectType, objectIndex,
405  this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }
407 
408  virtual vtkIdType GetTotalNumberOfNodes();
409  virtual vtkIdType GetTotalNumberOfEdges();
410  virtual vtkIdType GetTotalNumberOfFaces();
411  virtual vtkIdType GetTotalNumberOfElements();
412 
414 
419  int GetNumberOfPartArrays();
420  const char* GetPartArrayName(int arrayIdx);
421  int GetPartArrayID( const char *name );
422  const char* GetPartBlockInfo(int arrayIdx);
423  void SetPartArrayStatus(int index, int flag);
424  void SetPartArrayStatus(const char*, int flag);
425  int GetPartArrayStatus(int index);
426  int GetPartArrayStatus(const char*);
428 
429 
431 
437  int GetNumberOfMaterialArrays();
438  const char* GetMaterialArrayName(int arrayIdx);
439  int GetMaterialArrayID( const char *name );
440  void SetMaterialArrayStatus(int index, int flag);
441  void SetMaterialArrayStatus(const char*, int flag);
442  int GetMaterialArrayStatus(int index);
443  int GetMaterialArrayStatus(const char*);
445 
447 
453  int GetNumberOfAssemblyArrays();
454  const char* GetAssemblyArrayName(int arrayIdx);
455  int GetAssemblyArrayID( const char *name );
456  void SetAssemblyArrayStatus(int index, int flag);
457  void SetAssemblyArrayStatus(const char*, int flag);
458  int GetAssemblyArrayStatus(int index);
459  int GetAssemblyArrayStatus(const char*);
461 
463 
472  int GetNumberOfHierarchyArrays();
473  const char* GetHierarchyArrayName(int arrayIdx);
474  void SetHierarchyArrayStatus(int index, int flag);
475  void SetHierarchyArrayStatus(const char*, int flag);
476  int GetHierarchyArrayStatus(int index);
477  int GetHierarchyArrayStatus(const char*);
479 
480  vtkGetMacro(DisplayType,int);
481  virtual void SetDisplayType(int type);
482 
486  int IsValidVariable( const char *type, const char *name );
487 
491  int GetVariableID ( const char *type, const char *name );
492 
493  void SetAllArrayStatus( int otype, int status );
494  // Helper functions
495  //static int StringsEqual(const char* s1, char* s2);
496  //static void StringUppercase(const char* str, char* upperstr);
497  //static char *StrDupWithNew(const char *s);
498 
499  // time series query functions
500  int GetTimeSeriesData( int ID, const char *vName, const char *vType,
501  vtkFloatArray *result );
502 
503 
504 
506  { return this->GetNumberOfObjects(EDGE_BLOCK); }
507  const char* GetEdgeBlockArrayName(int index)
508  { return this->GetObjectName(EDGE_BLOCK, index); }
509  int GetEdgeBlockArrayStatus(const char* name)
510  { return this->GetObjectStatus(EDGE_BLOCK, name); }
511  void SetEdgeBlockArrayStatus(const char* name, int flag)
512  { this->SetObjectStatus(EDGE_BLOCK, name, flag); }
513 
515  { return this->GetNumberOfObjects(FACE_BLOCK); }
516  const char* GetFaceBlockArrayName(int index)
517  { return this->GetObjectName(FACE_BLOCK, index); }
518  int GetFaceBlockArrayStatus(const char* name)
519  { return this->GetObjectStatus(FACE_BLOCK, name); }
520  void SetFaceBlockArrayStatus(const char* name, int flag)
521  { this->SetObjectStatus(FACE_BLOCK, name, flag); }
522 
524  { return this->GetNumberOfObjects(ELEM_BLOCK); }
525  const char* GetElementBlockArrayName(int index)
526  { return this->GetObjectName(ELEM_BLOCK, index); }
527  int GetElementBlockArrayStatus(const char* name)
528  { return this->GetObjectStatus(ELEM_BLOCK, name); }
529  void SetElementBlockArrayStatus(const char* name, int flag)
530  { this->SetObjectStatus(ELEM_BLOCK, name, flag); }
531 
533  { return this->GetNumberOfObjectArrays(GLOBAL); }
534  const char* GetGlobalResultArrayName(int index)
535  { return this->GetObjectArrayName(GLOBAL, index); }
536  int GetGlobalResultArrayStatus(const char* name)
537  { return this->GetObjectArrayStatus(GLOBAL, name); }
538  void SetGlobalResultArrayStatus(const char* name, int flag)
539  { this->SetObjectArrayStatus(GLOBAL, name, flag); }
540 
542  { return this->GetNumberOfObjectArrays(NODAL); }
543  const char* GetPointResultArrayName(int index)
544  { return this->GetObjectArrayName(NODAL, index); }
545  int GetPointResultArrayStatus(const char* name)
546  { return this->GetObjectArrayStatus(NODAL, name); }
547  void SetPointResultArrayStatus(const char* name, int flag)
548  { this->SetObjectArrayStatus(NODAL, name, flag); }
549 
551  { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
552  const char* GetEdgeResultArrayName(int index)
553  { return this->GetObjectArrayName(EDGE_BLOCK, index); }
554  int GetEdgeResultArrayStatus(const char* name)
555  { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }
556  void SetEdgeResultArrayStatus(const char* name, int flag)
557  { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }
558 
560  { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
561  const char* GetFaceResultArrayName(int index)
562  { return this->GetObjectArrayName(FACE_BLOCK, index); }
563  int GetFaceResultArrayStatus(const char* name)
564  { return this->GetObjectArrayStatus(FACE_BLOCK, name); }
565  void SetFaceResultArrayStatus(const char* name, int flag)
566  { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }
567 
569  { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
570  const char* GetElementResultArrayName(int index)
571  { return this->GetObjectArrayName(ELEM_BLOCK, index); }
572  int GetElementResultArrayStatus(const char* name)
573  { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }
574  void SetElementResultArrayStatus(const char* name, int flag)
575  { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }
576 
577 
579  { return this->GetNumberOfObjects(NODE_MAP); }
580  const char* GetNodeMapArrayName(int index)
581  { return this->GetObjectName(NODE_MAP, index); }
582  int GetNodeMapArrayStatus(const char* name)
583  { return this->GetObjectStatus(NODE_MAP, name); }
584  void SetNodeMapArrayStatus(const char* name, int flag)
585  { this->SetObjectStatus(NODE_MAP, name, flag); }
586 
588  { return this->GetNumberOfObjects(EDGE_MAP); }
589  const char* GetEdgeMapArrayName(int index)
590  { return this->GetObjectName(EDGE_MAP, index); }
591  int GetEdgeMapArrayStatus(const char* name)
592  { return this->GetObjectStatus(EDGE_MAP, name); }
593  void SetEdgeMapArrayStatus(const char* name, int flag)
594  { this->SetObjectStatus(EDGE_MAP, name, flag); }
595 
597  { return this->GetNumberOfObjects(FACE_MAP); }
598  const char* GetFaceMapArrayName(int index)
599  { return this->GetObjectName(FACE_MAP, index); }
600  int GetFaceMapArrayStatus(const char* name)
601  { return this->GetObjectStatus(FACE_MAP, name); }
602  void SetFaceMapArrayStatus(const char* name, int flag)
603  { this->SetObjectStatus(FACE_MAP, name, flag); }
604 
606  { return this->GetNumberOfObjects(ELEM_MAP); }
607  const char* GetElementMapArrayName(int index)
608  { return this->GetObjectName(ELEM_MAP, index); }
609  int GetElementMapArrayStatus(const char* name)
610  { return this->GetObjectStatus(ELEM_MAP, name); }
611  void SetElementMapArrayStatus(const char* name, int flag)
612  { this->SetObjectStatus(ELEM_MAP, name, flag); }
613 
615  { return this->GetNumberOfObjects(NODE_SET); }
616  const char* GetNodeSetArrayName(int index)
617  { return this->GetObjectName(NODE_SET, index); }
618  int GetNodeSetArrayStatus(const char* name)
619  { return this->GetObjectStatus(NODE_SET, name); }
620  void SetNodeSetArrayStatus(const char* name, int flag)
621  { this->SetObjectStatus(NODE_SET, name, flag); }
622 
624  { return this->GetNumberOfObjects(SIDE_SET); }
625  const char* GetSideSetArrayName(int index)
626  { return this->GetObjectName(SIDE_SET, index); }
627  int GetSideSetArrayStatus(const char* name)
628  { return this->GetObjectStatus(SIDE_SET, name); }
629  void SetSideSetArrayStatus(const char* name, int flag)
630  { this->SetObjectStatus(SIDE_SET, name, flag); }
631 
633  { return this->GetNumberOfObjects(EDGE_SET); }
634  const char* GetEdgeSetArrayName(int index)
635  { return this->GetObjectName(EDGE_SET, index); }
636  int GetEdgeSetArrayStatus(const char* name)
637  { return this->GetObjectStatus(EDGE_SET, name); }
638  void SetEdgeSetArrayStatus(const char* name, int flag)
639  { this->SetObjectStatus(EDGE_SET, name, flag); }
640 
642  { return this->GetNumberOfObjects(FACE_SET); }
643  const char* GetFaceSetArrayName(int index)
644  { return this->GetObjectName(FACE_SET, index); }
645  int GetFaceSetArrayStatus(const char* name)
646  { return this->GetObjectStatus(FACE_SET, name); }
647  void SetFaceSetArrayStatus(const char* name, int flag)
648  { this->SetObjectStatus(FACE_SET, name, flag); }
649 
651  { return this->GetNumberOfObjects(ELEM_SET); }
652  const char* GetElementSetArrayName(int index)
653  { return this->GetObjectName(ELEM_SET, index); }
654  int GetElementSetArrayStatus(const char* name)
655  { return this->GetObjectStatus(ELEM_SET, name); }
656  void SetElementSetArrayStatus(const char* name, int flag)
657  { this->SetObjectStatus(ELEM_SET, name, flag); }
658 
659 
661  { return this->GetNumberOfObjectArrays(NODE_SET); }
662  const char* GetNodeSetResultArrayName(int index)
663  { return this->GetObjectArrayName(NODE_SET, index); }
664  int GetNodeSetResultArrayStatus(const char* name)
665  { return this->GetObjectArrayStatus(NODE_SET, name); }
666  void SetNodeSetResultArrayStatus(const char* name, int flag)
667  { this->SetObjectArrayStatus(NODE_SET, name, flag); }
668 
670  { return this->GetNumberOfObjectArrays(SIDE_SET); }
671  const char* GetSideSetResultArrayName(int index)
672  { return this->GetObjectArrayName(SIDE_SET, index); }
673  int GetSideSetResultArrayStatus(const char* name)
674  { return this->GetObjectArrayStatus(SIDE_SET, name); }
675  void SetSideSetResultArrayStatus(const char* name, int flag)
676  { this->SetObjectArrayStatus(SIDE_SET, name, flag); }
677 
679  { return this->GetNumberOfObjectArrays(EDGE_SET); }
680  const char* GetEdgeSetResultArrayName(int index)
681  { return this->GetObjectArrayName(EDGE_SET, index); }
682  int GetEdgeSetResultArrayStatus(const char* name)
683  { return this->GetObjectArrayStatus(EDGE_SET, name); }
684  void SetEdgeSetResultArrayStatus(const char* name, int flag)
685  { this->SetObjectArrayStatus(EDGE_SET, name, flag); }
686 
688  { return this->GetNumberOfObjectArrays(FACE_SET); }
689  const char* GetFaceSetResultArrayName(int index)
690  { return this->GetObjectArrayName(FACE_SET, index); }
691  int GetFaceSetResultArrayStatus(const char* name)
692  { return this->GetObjectArrayStatus(FACE_SET, name); }
693  void SetFaceSetResultArrayStatus(const char* name, int flag)
694  { this->SetObjectArrayStatus(FACE_SET, name, flag); }
695 
697  { return this->GetNumberOfObjectArrays(ELEM_SET); }
698  const char* GetElementSetResultArrayName(int index)
699  { return this->GetObjectArrayName(ELEM_SET, index); }
700  int GetElementSetResultArrayStatus(const char* name)
701  { return this->GetObjectArrayStatus(ELEM_SET, name); }
702  void SetElementSetResultArrayStatus(const char* name, int flag)
703  { this->SetObjectArrayStatus(ELEM_SET, name, flag); }
704 
713  void Reset();
714 
723  void ResetSettings();
724 
728  void ResetCache();
729 
733  void SetCacheSize(double CacheSize);
734 
738  double GetCacheSize();
739 
741 
753  void SetSqueezePoints(bool sp);
754  bool GetSqueezePoints();
756 
757  virtual void Dump();
758 
763  vtkGraph* GetSIL();
764 
766 
769  vtkGetMacro(SILUpdateStamp, int);
771 
772 protected:
774  ~vtkExodusIIReader() VTK_OVERRIDE;
775 
776  // helper for finding IDs
777  static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );
778  static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );
779 
780  virtual void SetMetadata( vtkExodusIIReaderPrivate* );
781  vtkGetObjectMacro(Metadata,vtkExodusIIReaderPrivate);
782 
792  bool FindXMLFile();
793 
794  // Time query function. Called by ExecuteInformation().
795  // Fills the TimestepValues array.
796  void GetAllTimes(vtkInformationVector*);
797 
801  void AdvertiseTimeSteps( vtkInformation* outputInfo );
802 
806  //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
807 
808  // Parameters for controlling what is read in.
809  char* FileName;
810  char* XMLFileName;
811  int TimeStep;
812  int TimeStepRange[2];
815 
816  // Information specific for exodus files.
817 
818  //1=display Block names
819  //2=display Part names
820  //3=display Material names
822 
823  // Metadata containing a description of the currently open file.
825 
827 
828  friend class vtkPExodusIIReader;
829 private:
830  vtkExodusIIReader(const vtkExodusIIReader&) VTK_DELETE_FUNCTION;
831  void operator=(const vtkExodusIIReader&) VTK_DELETE_FUNCTION;
832 
833  void AddDisplacements(vtkUnstructuredGrid* output);
834  int ModeShapesRange[2];
835 };
836 
837 #endif
const char * GetEdgeResultArrayName(int index)
static const char * GetGlobalNodeIdArrayName()
Extra point data array that can be generated.
const char * GetSideSetResultArrayName(int index)
static const char * GetImplicitElementIdArrayName()
const char * GetEdgeSetArrayName(int index)
void SetElementSetResultArrayStatus(const char *name, int flag)
int GetFaceMapArrayStatus(const char *name)
const char * GetEdgeSetResultArrayName(int index)
void SetEdgeResultArrayStatus(const char *name, int flag)
void SetNodeSetArrayStatus(const char *name, int flag)
Store vtkAlgorithm input/output information.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:300
const char * GetEdgeBlockArrayName(int index)
void SetNodeMapArrayStatus(const char *name, int flag)
void SetEdgeSetResultArrayStatus(const char *name, int flag)
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
int GetGlobalResultArrayStatus(const char *name)
static const char * GetImplicitFaceIdArrayName()
int GetEdgeSetResultArrayStatus(const char *name)
const char * GetNodeSetArrayName(int index)
void SetEdgeBlockArrayStatus(const char *name, int flag)
void SetNodeSetResultArrayStatus(const char *name, int flag)
void SetSideSetArrayStatus(const char *name, int flag)
record modification and/or execution time
Definition: vtkTimeStamp.h:32
int GetElementSetResultArrayStatus(const char *name)
int GetElementBlockArrayStatus(const char *name)
const char * GetElementSetArrayName(int index)
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:35
int GetNumberOfFaceSetResultArrays()
const char * GetFaceSetResultArrayName(int index)
const char * GetFaceSetArrayName(int index)
int GetNumberOfEdgeSetResultArrays()
int GetNumberOfElementResultArrays()
int GetElementResultArrayStatus(const char *name)
int ProcessRequest(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
see vtkAlgorithm for details
void SetElementResultArrayStatus(const char *name, int flag)
int GetEdgeResultArrayStatus(const char *name)
ObjectType
Extra cell data array that can be generated.
int vtkIdType
Definition: vtkType.h:345
This class holds metadata for an Exodus file.
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
void SetPointResultArrayStatus(const char *name, int flag)
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
const char * GetEdgeMapArrayName(int index)
int GetNodeSetResultArrayStatus(const char *name)
void SetFaceBlockArrayStatus(const char *name, int flag)
const char * GetGlobalResultArrayName(int index)
int GetNumberOfSideSetResultArrays()
int GetElementSetArrayStatus(const char *name)
static vtkMultiBlockDataSetAlgorithm * New()
static const char * GetImplicitNodeIdArrayName()
Extra point data array that can be generated.
Base class for graph data types.
Definition: vtkGraph.h:281
int GetNodeSetArrayStatus(const char *name)
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:39
void SetEdgeMapArrayStatus(const char *name, int flag)
int GetNumberOfNodeSetResultArrays()
int GetSideSetArrayStatus(const char *name)
const char * GetNodeSetResultArrayName(int index)
const char * GetElementMapArrayName(int index)
a simple class to control print indentation
Definition: vtkIndent.h:33
void SetElementSetArrayStatus(const char *name, int flag)
static const char * GetObjectIdArrayName()
Extra cell data array that can be generated.
Read Exodus II files (.exii)
int GetElementMapArrayStatus(const char *name)
static const char * GetSideSetSourceElementIdArrayName()
Get the name of the array that stores the mapping from side set cells back to the global id of the el...
const char * GetNodeMapArrayName(int index)
dataset represents arbitrary combinations of all possible cell types
void SetFaceSetArrayStatus(const char *name, int flag)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:48
virtual vtkMTimeType GetMTime()
Return this object's modified time.
void SetFaceMapArrayStatus(const char *name, int flag)
vtkTimeStamp XMLFileNameMTime
static const char * GetGlobalEdgeIdArrayName()
static const char * GetGlobalFaceIdArrayName()
static const char * GetPedigreeFaceIdArrayName()
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
int GetEdgeBlockArrayStatus(const char *name)
int GetObjectArrayStatus(int objectType, const char *arrayName)
By default arrays are not loaded.
static const char * GetPedigreeElementIdArrayName()
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
const char * GetFaceBlockArrayName(int index)
static const char * GetPedigreeNodeIdArrayName()
Extra point data array that can be generated.
const char * GetElementResultArrayName(int index)
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
void SetSideSetResultArrayStatus(const char *name, int flag)
int GetEdgeSetArrayStatus(const char *name)
const char * GetFaceResultArrayName(int index)
int GetNumberOfElementSetResultArrays()
const char * GetSideSetArrayName(int index)
int GetNodeMapArrayStatus(const char *name)
static const char * GetPedigreeEdgeIdArrayName()
Read exodus 2 files .ex2.
int GetFaceSetResultArrayStatus(const char *name)
static const char * GetImplicitEdgeIdArrayName()
void SetGlobalResultArrayStatus(const char *name, int flag)
int GetEdgeMapArrayStatus(const char *name)
int GetObjectStatus(int objectType, const char *objectName)
void SetElementBlockArrayStatus(const char *name, int flag)
int GetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName)
By default attributes are not loaded.
void SetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName, int status)
By default attributes are not loaded.
int GetPointResultArrayStatus(const char *name)
const char * GetFaceMapArrayName(int index)
void SetFaceResultArrayStatus(const char *name, int flag)
int GetFaceBlockArrayStatus(const char *name)
const char * GetPointResultArrayName(int index)
int GetSideSetResultArrayStatus(const char *name)
Store zero or more vtkInformation instances.
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
const char * GetElementBlockArrayName(int index)
int GetFaceSetArrayStatus(const char *name)
void SetElementMapArrayStatus(const char *name, int flag)
static const char * GetGlobalElementIdArrayName()
void SetFaceSetResultArrayStatus(const char *name, int flag)
static const char * GetSideSetSourceElementSideArrayName()
Get the name of the array that stores the mapping from side set cells back to the canonical side of t...
represent and manipulate 3D points
Definition: vtkPoints.h:33
const char * GetElementSetResultArrayName(int index)
void SetEdgeSetArrayStatus(const char *name, int flag)
vtkExodusIIReaderPrivate * Metadata
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
int GetFaceResultArrayStatus(const char *name)
vtkTimeStamp FileNameMTime