VTK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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 
39 #ifndef __vtkExodusIIReader_h
40 #define __vtkExodusIIReader_h
41 
42 #include "vtkIOExodusModule.h" // For export macro
44 
45 class vtkDataArray;
46 class vtkDataSet;
47 class vtkExodusIICache;
49 class vtkExodusModel;
50 class vtkFloatArray;
51 class vtkGraph;
52 class vtkIntArray;
53 class vtkPoints;
55 
57 {
58 public:
59  static vtkExodusIIReader *New();
61  void PrintSelf(ostream& os, vtkIndent indent);
62 
64  int CanReadFile(const char* fname);
65 
66  //virtual void Modified();
67 
70  virtual unsigned long GetMTime();
71 
75  virtual unsigned long GetMetadataMTime();
76 
78 
79  virtual void SetFileName( const char* fname );
80  vtkGetStringMacro(FileName);
82 
84 
85  virtual void SetXMLFileName( const char* fname );
86  vtkGetStringMacro(XMLFileName);
88 
90 
91  vtkSetMacro(TimeStep, int);
92  vtkGetMacro(TimeStep, int);
94 
96 
98  void SetModeShape(int val)
99  {
100  this->SetTimeStep(val-1);
101  }
103 
105 
106  vtkGetVector2Macro(TimeStepRange,int);
107  vtkSetVector2Macro(TimeStepRange,int);
109 
111 
120  virtual void SetGenerateObjectIdCellArray( int g );
121  int GetGenerateObjectIdCellArray();
122  vtkBooleanMacro(GenerateObjectIdCellArray, int);
123  static const char *GetObjectIdArrayName() { return "ObjectId"; }
125 
126  virtual void SetGenerateGlobalElementIdArray( int g );
127  int GetGenerateGlobalElementIdArray();
128  vtkBooleanMacro(GenerateGlobalElementIdArray, int);
129 
130  virtual void SetGenerateGlobalNodeIdArray( int g );
131  int GetGenerateGlobalNodeIdArray();
132  vtkBooleanMacro(GenerateGlobalNodeIdArray, int);
133 
134  virtual void SetGenerateImplicitElementIdArray( int g );
135  int GetGenerateImplicitElementIdArray();
136  vtkBooleanMacro(GenerateImplicitElementIdArray, int);
137 
138  virtual void SetGenerateImplicitNodeIdArray( int g );
139  int GetGenerateImplicitNodeIdArray();
140  vtkBooleanMacro(GenerateImplicitNodeIdArray, int);
141 
142  virtual void SetGenerateFileIdArray( int f );
143  int GetGenerateFileIdArray();
144  vtkBooleanMacro(GenerateFileIdArray, int);
145  virtual void SetFileId( int f );
146  int GetFileId();
147 
148 //BTX
150 
155  enum {
156  SEARCH_TYPE_ELEMENT=0,
160  ID_NOT_FOUND=-234121312
161  };
162  // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
163  enum ObjectType {
164  // match Exodus macros from exodusII.h and exodusII_ext.h
165  EDGE_BLOCK = 6,
166  FACE_BLOCK = 8,
167  ELEM_BLOCK = 1,
168  NODE_SET = 2,
169  EDGE_SET = 7,
170  FACE_SET = 9,
171  SIDE_SET = 3,
172  ELEM_SET = 10,
173  NODE_MAP = 5,
174  EDGE_MAP = 11,
175  FACE_MAP = 12,
176  ELEM_MAP = 4,
177  GLOBAL = 13,
178  NODAL = 14,
179  // extended values (not in Exodus headers) for use with SetAllArrayStatus:
180  ASSEMBLY = 60,
181  PART = 61,
182  MATERIAL = 62,
183  HIERARCHY = 63,
184  // extended values (not in Exodus headers) for use in cache keys:
185  QA_RECORDS = 103,
186  INFO_RECORDS = 104,
187  GLOBAL_TEMPORAL = 102,
188  NODAL_TEMPORAL = 101,
189  ELEM_BLOCK_TEMPORAL = 100,
190  GLOBAL_CONN = 99,
191  ELEM_BLOCK_ELEM_CONN = 98,
192  ELEM_BLOCK_FACE_CONN = 97,
193  ELEM_BLOCK_EDGE_CONN = 96,
194  FACE_BLOCK_CONN = 95,
195  EDGE_BLOCK_CONN = 94,
196  ELEM_SET_CONN = 93,
197  SIDE_SET_CONN = 92,
198  FACE_SET_CONN = 91,
199  EDGE_SET_CONN = 90,
200  NODE_SET_CONN = 89,
201  NODAL_COORDS = 88,
202  OBJECT_ID = 87,
203  IMPLICIT_ELEMENT_ID = 108,
204  IMPLICIT_NODE_ID = 107,
205  GLOBAL_ELEMENT_ID = 86,
206  GLOBAL_NODE_ID = 85,
207  ELEMENT_ID = 84,
208  NODE_ID = 83,
209  NODAL_SQUEEZEMAP = 82,
210  ELEM_BLOCK_ATTRIB = 81,
211  FACE_BLOCK_ATTRIB = 80,
212  EDGE_BLOCK_ATTRIB = 79,
213  FACE_ID = 105,
214  EDGE_ID = 106,
215  ENTITY_COUNTS = 109
216  };
217 //ETX
218  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
219  static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
220  static int GetGlobalElementID( vtkDataSet *data, int localID );
221  static int GetGlobalElementID ( vtkDataSet *data, int localID,
222  int searchType );
223  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
225 
226  static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
227  static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
228  static int GetGlobalFaceID( vtkDataSet *data, int localID );
229  static int GetGlobalFaceID ( vtkDataSet *data, int localID,
230  int searchType );
231  static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }
232 
233  static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
234  static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
235  static int GetGlobalEdgeID( vtkDataSet *data, int localID );
236  static int GetGlobalEdgeID ( vtkDataSet *data, int localID,
237  int searchType );
238  static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }
239 
241 
245  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
246  static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }
247  static int GetGlobalNodeID( vtkDataSet *data, int localID );
248  static int GetGlobalNodeID( vtkDataSet *data, int localID,
249  int searchType );
250  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }
252 
255  static const char* GetSideSetSourceElementIdArrayName() { return "SourceElementId"; }
256 
259  static const char* GetSideSetSourceElementSideArrayName() { return "SourceElementSide"; }
261 
265  virtual void SetApplyDisplacements( int d );
266  int GetApplyDisplacements();
267  vtkBooleanMacro(ApplyDisplacements, int);
268  virtual void SetDisplacementMagnitude( float s );
269  float GetDisplacementMagnitude();
271 
273 
276  virtual void SetHasModeShapes( int ms );
277  int GetHasModeShapes();
278  vtkBooleanMacro(HasModeShapes,int);
280 
282 
288  virtual void SetModeShapeTime( double phase );
289  double GetModeShapeTime();
291 
293 
298  virtual void SetAnimateModeShapes(int flag);
299  int GetAnimateModeShapes();
300  vtkBooleanMacro(AnimateModeShapes, int);
302 
304 
305  const char* GetTitle();
306  int GetDimensionality();
307  int GetNumberOfTimeSteps();
309 
310  int GetNumberOfNodesInFile();
311  int GetNumberOfEdgesInFile();
312  int GetNumberOfFacesInFile();
313  int GetNumberOfElementsInFile();
314 
315  int GetObjectTypeFromName( const char* name );
316  const char* GetObjectTypeName( int );
317 
318  int GetNumberOfNodes();
319  int GetNumberOfObjects( int objectType );
320  int GetNumberOfEntriesInObject( int objectType, int objectIndex );
321  int GetObjectId( int objectType, int objectIndex );
322  const char* GetObjectName( int objectType, int objectIndex );
323  int GetObjectIndex( int objectType, const char* objectName );
324  int GetObjectIndex( int objectType, int id );
325  int GetObjectStatus( int objectType, int objectIndex );
326  int GetObjectStatus( int objectType, const char* objectName )
327  { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }
328  void SetObjectStatus( int objectType, int objectIndex, int status );
329  void SetObjectStatus( int objectType, const char* objectName, int status );
330 
332 
337  int GetNumberOfObjectArrays( int objectType );
338  const char* GetObjectArrayName( int objectType, int arrayIndex );
339  int GetObjectArrayIndex( int objectType, const char* arrayName );
340  int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );
341  int GetObjectArrayStatus( int objectType, int arrayIndex );
342  int GetObjectArrayStatus( int objectType, const char* arrayName )
343  { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }
344  void SetObjectArrayStatus( int objectType, int arrayIndex, int status );
345  void SetObjectArrayStatus( int objectType, const char* arrayName, int status );
347 
349 
354  int GetNumberOfObjectAttributes( int objectType, int objectIndex );
355  const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );
356  int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );
357  int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );
358  int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )
359  { return this->GetObjectAttributeStatus( objectType, objectIndex,
360  this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }
361  void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );
362  void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )
363  { this->SetObjectAttributeStatus( objectType, objectIndex,
364  this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }
366 
367  virtual vtkIdType GetTotalNumberOfNodes();
368  virtual vtkIdType GetTotalNumberOfEdges();
369  virtual vtkIdType GetTotalNumberOfFaces();
370  virtual vtkIdType GetTotalNumberOfElements();
371 
373 
377  int GetNumberOfPartArrays();
378  const char* GetPartArrayName(int arrayIdx);
379  int GetPartArrayID( const char *name );
380  const char* GetPartBlockInfo(int arrayIdx);
381  void SetPartArrayStatus(int index, int flag);
382  void SetPartArrayStatus(const char*, int flag);
383  int GetPartArrayStatus(int index);
384  int GetPartArrayStatus(const char*);
386 
387 
389 
393  int GetNumberOfMaterialArrays();
394  const char* GetMaterialArrayName(int arrayIdx);
395  int GetMaterialArrayID( const char *name );
396  void SetMaterialArrayStatus(int index, int flag);
397  void SetMaterialArrayStatus(const char*, int flag);
398  int GetMaterialArrayStatus(int index);
399  int GetMaterialArrayStatus(const char*);
401 
403 
407  int GetNumberOfAssemblyArrays();
408  const char* GetAssemblyArrayName(int arrayIdx);
409  int GetAssemblyArrayID( const char *name );
410  void SetAssemblyArrayStatus(int index, int flag);
411  void SetAssemblyArrayStatus(const char*, int flag);
412  int GetAssemblyArrayStatus(int index);
413  int GetAssemblyArrayStatus(const char*);
415 
417 
424  int GetNumberOfHierarchyArrays();
425  const char* GetHierarchyArrayName(int arrayIdx);
426  void SetHierarchyArrayStatus(int index, int flag);
427  void SetHierarchyArrayStatus(const char*, int flag);
428  int GetHierarchyArrayStatus(int index);
429  int GetHierarchyArrayStatus(const char*);
431 
432  vtkGetMacro(DisplayType,int);
433  virtual void SetDisplayType(int type);
434 
440  vtkBooleanMacro(ExodusModelMetadata, int);
441  vtkSetMacro(ExodusModelMetadata, int);
442  vtkGetMacro(ExodusModelMetadata, int);
443 
445 
446  vtkGetObjectMacro(ExodusModel,vtkExodusModel);
448 
456  vtkSetMacro(PackExodusModelOntoOutput, int);
457  vtkGetMacro(PackExodusModelOntoOutput, int);
458  vtkBooleanMacro(PackExodusModelOntoOutput, int);
459 
461  int IsValidVariable( const char *type, const char *name );
462 
464  int GetVariableID ( const char *type, const char *name );
465 
466  void SetAllArrayStatus( int otype, int status );
467  // Helper functions
468  //static int StringsEqual(const char* s1, char* s2);
469  //static void StringUppercase(const char* str, char* upperstr);
470  //static char *StrDupWithNew(const char *s);
471 
472  // time series query functions
473  int GetTimeSeriesData( int ID, const char *vName, const char *vType,
475 
476 
477 
479  { return this->GetNumberOfObjects(EDGE_BLOCK); }
480  const char* GetEdgeBlockArrayName(int index)
481  { return this->GetObjectName(EDGE_BLOCK, index); }
482  int GetEdgeBlockArrayStatus(const char* name)
483  { return this->GetObjectStatus(EDGE_BLOCK, name); }
484  void SetEdgeBlockArrayStatus(const char* name, int flag)
485  { this->SetObjectStatus(EDGE_BLOCK, name, flag); }
486 
488  { return this->GetNumberOfObjects(FACE_BLOCK); }
489  const char* GetFaceBlockArrayName(int index)
490  { return this->GetObjectName(FACE_BLOCK, index); }
491  int GetFaceBlockArrayStatus(const char* name)
492  { return this->GetObjectStatus(FACE_BLOCK, name); }
493  void SetFaceBlockArrayStatus(const char* name, int flag)
494  { this->SetObjectStatus(FACE_BLOCK, name, flag); }
495 
497  { return this->GetNumberOfObjects(ELEM_BLOCK); }
499  { return this->GetObjectName(ELEM_BLOCK, index); }
501  { return this->GetObjectStatus(ELEM_BLOCK, name); }
502  void SetElementBlockArrayStatus(const char* name, int flag)
503  { this->SetObjectStatus(ELEM_BLOCK, name, flag); }
504 
506  { return this->GetNumberOfObjectArrays(GLOBAL); }
508  { return this->GetObjectArrayName(GLOBAL, index); }
510  { return this->GetObjectArrayStatus(GLOBAL, name); }
511  void SetGlobalResultArrayStatus(const char* name, int flag)
512  { this->SetObjectArrayStatus(GLOBAL, name, flag); }
513 
515  { return this->GetNumberOfObjectArrays(NODAL); }
517  { return this->GetObjectArrayName(NODAL, index); }
519  { return this->GetObjectArrayStatus(NODAL, name); }
520  void SetPointResultArrayStatus(const char* name, int flag)
521  { this->SetObjectArrayStatus(NODAL, name, flag); }
522 
524  { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
525  const char* GetEdgeResultArrayName(int index)
526  { return this->GetObjectArrayName(EDGE_BLOCK, index); }
528  { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }
529  void SetEdgeResultArrayStatus(const char* name, int flag)
530  { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }
531 
533  { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
534  const char* GetFaceResultArrayName(int index)
535  { return this->GetObjectArrayName(FACE_BLOCK, index); }
537  { return this->GetObjectArrayStatus(FACE_BLOCK, name); }
538  void SetFaceResultArrayStatus(const char* name, int flag)
539  { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }
540 
542  { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
544  { return this->GetObjectArrayName(ELEM_BLOCK, index); }
546  { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }
547  void SetElementResultArrayStatus(const char* name, int flag)
548  { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }
549 
550 
552  { return this->GetNumberOfObjects(NODE_MAP); }
553  const char* GetNodeMapArrayName(int index)
554  { return this->GetObjectName(NODE_MAP, index); }
555  int GetNodeMapArrayStatus(const char* name)
556  { return this->GetObjectStatus(NODE_MAP, name); }
557  void SetNodeMapArrayStatus(const char* name, int flag)
558  { this->SetObjectStatus(NODE_MAP, name, flag); }
559 
561  { return this->GetNumberOfObjects(EDGE_MAP); }
562  const char* GetEdgeMapArrayName(int index)
563  { return this->GetObjectName(EDGE_MAP, index); }
564  int GetEdgeMapArrayStatus(const char* name)
565  { return this->GetObjectStatus(EDGE_MAP, name); }
566  void SetEdgeMapArrayStatus(const char* name, int flag)
567  { this->SetObjectStatus(EDGE_MAP, name, flag); }
568 
570  { return this->GetNumberOfObjects(FACE_MAP); }
571  const char* GetFaceMapArrayName(int index)
572  { return this->GetObjectName(FACE_MAP, index); }
573  int GetFaceMapArrayStatus(const char* name)
574  { return this->GetObjectStatus(FACE_MAP, name); }
575  void SetFaceMapArrayStatus(const char* name, int flag)
576  { this->SetObjectStatus(FACE_MAP, name, flag); }
577 
579  { return this->GetNumberOfObjects(ELEM_MAP); }
580  const char* GetElementMapArrayName(int index)
581  { return this->GetObjectName(ELEM_MAP, index); }
583  { return this->GetObjectStatus(ELEM_MAP, name); }
584  void SetElementMapArrayStatus(const char* name, int flag)
585  { this->SetObjectStatus(ELEM_MAP, name, flag); }
586 
588  { return this->GetNumberOfObjects(NODE_SET); }
589  const char* GetNodeSetArrayName(int index)
590  { return this->GetObjectName(NODE_SET, index); }
591  int GetNodeSetArrayStatus(const char* name)
592  { return this->GetObjectStatus(NODE_SET, name); }
593  void SetNodeSetArrayStatus(const char* name, int flag)
594  { this->SetObjectStatus(NODE_SET, name, flag); }
595 
597  { return this->GetNumberOfObjects(SIDE_SET); }
598  const char* GetSideSetArrayName(int index)
599  { return this->GetObjectName(SIDE_SET, index); }
600  int GetSideSetArrayStatus(const char* name)
601  { return this->GetObjectStatus(SIDE_SET, name); }
602  void SetSideSetArrayStatus(const char* name, int flag)
603  { this->SetObjectStatus(SIDE_SET, name, flag); }
604 
606  { return this->GetNumberOfObjects(EDGE_SET); }
607  const char* GetEdgeSetArrayName(int index)
608  { return this->GetObjectName(EDGE_SET, index); }
609  int GetEdgeSetArrayStatus(const char* name)
610  { return this->GetObjectStatus(EDGE_SET, name); }
611  void SetEdgeSetArrayStatus(const char* name, int flag)
612  { this->SetObjectStatus(EDGE_SET, name, flag); }
613 
615  { return this->GetNumberOfObjects(FACE_SET); }
616  const char* GetFaceSetArrayName(int index)
617  { return this->GetObjectName(FACE_SET, index); }
618  int GetFaceSetArrayStatus(const char* name)
619  { return this->GetObjectStatus(FACE_SET, name); }
620  void SetFaceSetArrayStatus(const char* name, int flag)
621  { this->SetObjectStatus(FACE_SET, name, flag); }
622 
624  { return this->GetNumberOfObjects(ELEM_SET); }
625  const char* GetElementSetArrayName(int index)
626  { return this->GetObjectName(ELEM_SET, index); }
628  { return this->GetObjectStatus(ELEM_SET, name); }
629  void SetElementSetArrayStatus(const char* name, int flag)
630  { this->SetObjectStatus(ELEM_SET, name, flag); }
631 
632 
634  { return this->GetNumberOfObjectArrays(NODE_SET); }
636  { return this->GetObjectArrayName(NODE_SET, index); }
638  { return this->GetObjectArrayStatus(NODE_SET, name); }
639  void SetNodeSetResultArrayStatus(const char* name, int flag)
640  { this->SetObjectArrayStatus(NODE_SET, name, flag); }
641 
643  { return this->GetNumberOfObjectArrays(SIDE_SET); }
645  { return this->GetObjectArrayName(SIDE_SET, index); }
647  { return this->GetObjectArrayStatus(SIDE_SET, name); }
648  void SetSideSetResultArrayStatus(const char* name, int flag)
649  { this->SetObjectArrayStatus(SIDE_SET, name, flag); }
650 
652  { return this->GetNumberOfObjectArrays(EDGE_SET); }
654  { return this->GetObjectArrayName(EDGE_SET, index); }
656  { return this->GetObjectArrayStatus(EDGE_SET, name); }
657  void SetEdgeSetResultArrayStatus(const char* name, int flag)
658  { this->SetObjectArrayStatus(EDGE_SET, name, flag); }
659 
661  { return this->GetNumberOfObjectArrays(FACE_SET); }
663  { return this->GetObjectArrayName(FACE_SET, index); }
665  { return this->GetObjectArrayStatus(FACE_SET, name); }
666  void SetFaceSetResultArrayStatus(const char* name, int flag)
667  { this->SetObjectArrayStatus(FACE_SET, name, flag); }
668 
670  { return this->GetNumberOfObjectArrays(ELEM_SET); }
672  { return this->GetObjectArrayName(ELEM_SET, index); }
674  { return this->GetObjectArrayStatus(ELEM_SET, name); }
675  void SetElementSetResultArrayStatus(const char* name, int flag)
676  { this->SetObjectArrayStatus(ELEM_SET, name, flag); }
677 
693  void SetFastPathObjectType(const char *type);
695 
698  void SetFastPathIdType(const char *type);
699  void SetFastPathObjectId(vtkIdType id);
701 
702 
707  void Reset();
708 
714  void ResetSettings();
715 
717  void ResetCache();
718 
720  void SetCacheSize(double CacheSize);
721 
723  double GetCacheSize();
724 
726 
735  void SetSqueezePoints(bool sp);
736  bool GetSqueezePoints();
738 
739 
742  virtual void UpdateTimeInformation();
743 
744  virtual void Dump();
745 
748  vtkGraph* GetSIL();
749 
751 
752  vtkGetMacro(SILUpdateStamp, int);
754 
756 
758  vtkGetMacro(ProducedFastPathOutput, bool);
760 
761 protected:
764 
767  virtual void NewExodusModel();
768 
769  // helper for finding IDs
770  static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );
771  static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );
772 
773  virtual void SetMetadata( vtkExodusIIReaderPrivate* );
775 
781  bool FindXMLFile();
782 
783  // Time query function. Called by ExecuteInformation().
784  // Fills the TimestepValues array.
785  void GetAllTimes(vtkInformationVector*);
786 
788  void AdvertiseTimeSteps( vtkInformation* outputInfo );
789 
790  virtual void SetExodusModel( vtkExodusModel* em );
791 
795  //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
796 
797  // Parameters for controlling what is read in.
798  char* FileName;
799  char* XMLFileName;
800  int TimeStep;
801  int TimeStepRange[2];
804 
805  // Information specific for exodus files.
806 
807  //1=display Block names
808  //2=display Part names
809  //3=display Material names
811 
812  // Metadata containing a description of the currently open file.
814 
818 
821 private:
822  vtkExodusIIReader(const vtkExodusIIReader&); // Not implemented
823  void operator=(const vtkExodusIIReader&); // Not implemented
824 
825  void AddDisplacements(vtkUnstructuredGrid* output);
826 };
827 
828 #endif
const char * GetEdgeResultArrayName(int index)
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: vtkgl.h:11339
static const char * GetGlobalNodeIdArrayName()
GLclampf f
Definition: vtkgl.h:14181
const char * GetSideSetResultArrayName(int index)
GLuint GLuint GLsizei GLenum type
Definition: vtkgl.h:11315
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)
GLuint index
Definition: vtkgl.h:11983
Store vtkAlgorithm input/output information.
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:60
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)
#define vtkGetMacro(name, type)
Definition: vtkSetGet.h:83
record modification and/or execution time
Definition: vtkTimeStamp.h:34
int GetElementSetResultArrayStatus(const char *name)
int GetElementBlockArrayStatus(const char *name)
const char * GetElementSetArrayName(int index)
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:45
int GetNumberOfFaceSetResultArrays()
const char * GetFaceSetResultArrayName(int index)
const char * GetFaceSetArrayName(int index)
int GetNumberOfEdgeSetResultArrays()
int GetNumberOfElementResultArrays()
int GetElementResultArrayStatus(const char *name)
void SetElementResultArrayStatus(const char *name, int flag)
int GetEdgeResultArrayStatus(const char *name)
int vtkIdType
Definition: vtkType.h:268
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 *)
const char * GetEdgeMapArrayName(int index)
int GetNodeSetResultArrayStatus(const char *name)
void SetFaceBlockArrayStatus(const char *name, int flag)
#define vtkTypeMacro(thisClass, superclass)
Definition: vtkSetGet.h:619
virtual int ProcessRequest(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
const char * GetGlobalResultArrayName(int index)
int GetNumberOfSideSetResultArrays()
int GetElementSetArrayStatus(const char *name)
static vtkMultiBlockDataSetAlgorithm * New()
static const char * GetImplicitNodeIdArrayName()
Exodus Model.
Base class for graph data types.
Definition: vtkGraph.h:288
int GetNodeSetArrayStatus(const char *name)
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:45
void SetEdgeMapArrayStatus(const char *name, int flag)
int GetNumberOfNodeSetResultArrays()
int GetSideSetArrayStatus(const char *name)
GLuint const GLchar * name
Definition: vtkgl.h:11983
const char * GetNodeSetResultArrayName(int index)
const char * GetElementMapArrayName(int index)
virtual unsigned long GetMTime()
a simple class to control print indentation
Definition: vtkIndent.h:38
void SetElementSetArrayStatus(const char *name, int flag)
static const char * GetObjectIdArrayName()
int GetElementMapArrayStatus(const char *name)
static const char * GetSideSetSourceElementIdArrayName()
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:53
void SetFaceMapArrayStatus(const char *name, int flag)
vtkTimeStamp XMLFileNameMTime
static const char * GetGlobalEdgeIdArrayName()
static const char * GetGlobalFaceIdArrayName()
static const char * GetPedigreeFaceIdArrayName()
#define VTKIOEXODUS_EXPORT
int GetEdgeBlockArrayStatus(const char *name)
int GetObjectArrayStatus(int objectType, const char *arrayName)
static const char * GetPedigreeElementIdArrayName()
#define vtkGetStringMacro(name)
Definition: vtkSetGet.h:120
#define vtkGetObjectMacro(name, type)
Definition: vtkSetGet.h:222
const char * GetFaceBlockArrayName(int index)
static const char * GetPedigreeNodeIdArrayName()
const char * GetElementResultArrayName(int index)
void SetSideSetResultArrayStatus(const char *name, int flag)
int GetEdgeSetArrayStatus(const char *name)
const char * GetFaceResultArrayName(int index)
int GetNumberOfElementSetResultArrays()
const char * GetSideSetArrayName(int index)
GLuint64EXT * result
Definition: vtkgl.h:18868
vtkExodusModel * ExodusModel
#define vtkGetVector2Macro(name, type)
Definition: vtkSetGet.h:260
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)
void SetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName, int status)
int GetPointResultArrayStatus(const char *name)
const char * GetFaceMapArrayName(int index)
void SetModeShape(int val)
GLboolean GLboolean g
Definition: vtkgl.h:12312
void SetFaceResultArrayStatus(const char *name, int flag)
int GetFaceBlockArrayStatus(const char *name)
GLdouble s
Definition: vtkgl.h:11594
void PrintSelf(ostream &os, vtkIndent indent)
const char * GetPointResultArrayName(int index)
int GetSideSetResultArrayStatus(const char *name)
Store zero or more vtkInformation instances.
#define vtkBooleanMacro(name, type)
Definition: vtkSetGet.h:234
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)
#define vtkSetVector2Macro(name, type)
Definition: vtkSetGet.h:244
static const char * GetSideSetSourceElementSideArrayName()
represent and manipulate 3D points
Definition: vtkPoints.h:39
const char * GetElementSetResultArrayName(int index)
void SetEdgeSetArrayStatus(const char *name, int flag)
vtkExodusIIReaderPrivate * Metadata
GLuint GLfloat * val
Definition: vtkgl.h:13789
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
#define vtkSetMacro(name, type)
Definition: vtkSetGet.h:69
int GetFaceResultArrayStatus(const char *name)
vtkTimeStamp FileNameMTime