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 
39 #ifndef __vtkExodusIIReader_h
40 #define __vtkExodusIIReader_h
41 
43 
44 class vtkDataArray;
45 class vtkDataSet;
46 class vtkExodusIICache;
48 class vtkExodusModel;
49 class vtkFloatArray;
50 class vtkGraph;
51 class vtkIntArray;
52 class vtkPoints;
54 
56 {
57 public:
58  static vtkExodusIIReader *New();
60  void PrintSelf(ostream& os, vtkIndent indent);
61 
63  int CanReadFile(const char* fname);
64 
65  //virtual void Modified();
66 
69  virtual unsigned long GetMTime();
70 
74  virtual unsigned long GetMetadataMTime();
75 
77 
78  virtual void SetFileName( const char* fname );
79  vtkGetStringMacro(FileName);
81 
83 
84  virtual void SetXMLFileName( const char* fname );
85  vtkGetStringMacro(XMLFileName);
87 
89 
90  vtkSetMacro(TimeStep, int);
91  vtkGetMacro(TimeStep, int);
93 
95 
97  void SetModeShape(int val)
98  {
99  this->SetTimeStep(val-1);
100  }
102 
104 
105  vtkGetVector2Macro(TimeStepRange,int);
106  vtkSetVector2Macro(TimeStepRange,int);
108 
110 
119  virtual void SetGenerateObjectIdCellArray( int g );
120  int GetGenerateObjectIdCellArray();
121  vtkBooleanMacro(GenerateObjectIdCellArray, int);
122  static const char *GetObjectIdArrayName() { return "ObjectId"; }
124 
125  virtual void SetGenerateGlobalElementIdArray( int g );
126  int GetGenerateGlobalElementIdArray();
127  vtkBooleanMacro(GenerateGlobalElementIdArray, int);
128 
129  virtual void SetGenerateGlobalNodeIdArray( int g );
130  int GetGenerateGlobalNodeIdArray();
131  vtkBooleanMacro(GenerateGlobalNodeIdArray, int);
132 
133  virtual void SetGenerateImplicitElementIdArray( int g );
134  int GetGenerateImplicitElementIdArray();
135  vtkBooleanMacro(GenerateImplicitElementIdArray, int);
136 
137  virtual void SetGenerateImplicitNodeIdArray( int g );
138  int GetGenerateImplicitNodeIdArray();
139  vtkBooleanMacro(GenerateImplicitNodeIdArray, int);
140 
141  virtual void SetGenerateFileIdArray( int f );
142  int GetGenerateFileIdArray();
143  vtkBooleanMacro(GenerateFileIdArray, int);
144  virtual void SetFileId( int f );
145  int GetFileId();
146 
147 //BTX
149 
154  enum {
155  SEARCH_TYPE_ELEMENT=0,
159  ID_NOT_FOUND=-234121312
160  };
161  // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
162  enum ObjectType {
163  // match Exodus macros from exodusII.h and exodusII_ext.h
164  EDGE_BLOCK = 6,
165  FACE_BLOCK = 8,
166  ELEM_BLOCK = 1,
167  NODE_SET = 2,
168  EDGE_SET = 7,
169  FACE_SET = 9,
170  SIDE_SET = 3,
171  ELEM_SET = 10,
172  NODE_MAP = 5,
173  EDGE_MAP = 11,
174  FACE_MAP = 12,
175  ELEM_MAP = 4,
176  GLOBAL = 13,
177  NODAL = 14,
178  // extended values (not in Exodus headers) for use with SetAllArrayStatus:
179  ASSEMBLY = 60,
180  PART = 61,
181  MATERIAL = 62,
182  HIERARCHY = 63,
183  // extended values (not in Exodus headers) for use in cache keys:
184  QA_RECORDS = 103,
185  INFO_RECORDS = 104,
186  GLOBAL_TEMPORAL = 102,
187  NODAL_TEMPORAL = 101,
188  ELEM_BLOCK_TEMPORAL = 100,
189  GLOBAL_CONN = 99,
190  ELEM_BLOCK_ELEM_CONN = 98,
191  ELEM_BLOCK_FACE_CONN = 97,
192  ELEM_BLOCK_EDGE_CONN = 96,
193  FACE_BLOCK_CONN = 95,
194  EDGE_BLOCK_CONN = 94,
195  ELEM_SET_CONN = 93,
196  SIDE_SET_CONN = 92,
197  FACE_SET_CONN = 91,
198  EDGE_SET_CONN = 90,
199  NODE_SET_CONN = 89,
200  NODAL_COORDS = 88,
201  OBJECT_ID = 87,
202  IMPLICIT_ELEMENT_ID = 108,
203  IMPLICIT_NODE_ID = 107,
204  GLOBAL_ELEMENT_ID = 86,
205  GLOBAL_NODE_ID = 85,
206  ELEMENT_ID = 84,
207  NODE_ID = 83,
208  NODAL_SQUEEZEMAP = 82,
209  ELEM_BLOCK_ATTRIB = 81,
210  FACE_BLOCK_ATTRIB = 80,
211  EDGE_BLOCK_ATTRIB = 79,
212  FACE_ID = 105,
213  EDGE_ID = 106,
214  ENTITY_COUNTS = 109
215  };
218  NONE = 0,
220  CORNER_AVERAGED
221  };
222 //ETX
223  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
224  static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
225  static int GetGlobalElementID( vtkDataSet *data, int localID );
226  static int GetGlobalElementID ( vtkDataSet *data, int localID,
227  int searchType );
228  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
230 
231  static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
232  static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
233  static int GetGlobalFaceID( vtkDataSet *data, int localID );
234  static int GetGlobalFaceID ( vtkDataSet *data, int localID,
235  int searchType );
236  static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }
237 
238  static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
239  static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
240  static int GetGlobalEdgeID( vtkDataSet *data, int localID );
241  static int GetGlobalEdgeID ( vtkDataSet *data, int localID,
242  int searchType );
243  static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }
244 
246 
250  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
251  static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }
252  static int GetGlobalNodeID( vtkDataSet *data, int localID );
253  static int GetGlobalNodeID( vtkDataSet *data, int localID,
254  int searchType );
255  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }
257 
259 
263  virtual void SetApplyDisplacements( int d );
264  int GetApplyDisplacements();
265  vtkBooleanMacro(ApplyDisplacements, int);
266  virtual void SetDisplacementMagnitude( float s );
267  float GetDisplacementMagnitude();
269 
271 
274  virtual void SetHasModeShapes( int ms );
275  int GetHasModeShapes();
276  vtkBooleanMacro(HasModeShapes,int);
278 
280 
286  virtual void SetModeShapeTime( double phase );
287  double GetModeShapeTime();
289 
291 
296  virtual void SetAnimateModeShapes(int flag);
297  int GetAnimateModeShapes();
298  vtkBooleanMacro(AnimateModeShapes, int);
300 
302 
303  virtual void SetEdgeFieldDecorations( int d );
304  int GetEdgeFieldDecorations();
305  void EdgeFieldDecorationsNone() { this->SetEdgeFieldDecorations( NONE ); }
306  void EdgeFieldDecorationsGlyphs() { this->SetEdgeFieldDecorations( GLYPHS ); }
307  void EdgeFieldDecorationsCornerAveraged() { this->SetEdgeFieldDecorations( CORNER_AVERAGED ); }
309 
311 
312  virtual void SetFaceFieldDecorations( int d );
313  int GetFaceFieldDecorations();
314  void FaceFieldDecorationsNone() { this->SetFaceFieldDecorations( NONE ); }
315  void FaceFieldDecorationsGlyphs() { this->SetFaceFieldDecorations( GLYPHS ); }
316  void FaceFieldDecorationsCornerAveraged() { this->SetFaceFieldDecorations( CORNER_AVERAGED ); }
318 
320 
321  const char* GetTitle();
322  int GetDimensionality();
323  int GetNumberOfTimeSteps();
325 
326  int GetNumberOfNodesInFile();
327  int GetNumberOfEdgesInFile();
328  int GetNumberOfFacesInFile();
329  int GetNumberOfElementsInFile();
330 
331  int GetObjectTypeFromName( const char* name );
332  const char* GetObjectTypeName( int );
333 
334  int GetNumberOfNodes();
335  int GetNumberOfObjects( int objectType );
336  int GetNumberOfEntriesInObject( int objectType, int objectIndex );
337  int GetObjectId( int objectType, int objectIndex );
338  const char* GetObjectName( int objectType, int objectIndex );
339  int GetObjectIndex( int objectType, const char* objectName );
340  int GetObjectIndex( int objectType, int id );
341  int GetObjectStatus( int objectType, int objectIndex );
342  int GetObjectStatus( int objectType, const char* objectName )
343  { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }
344  void SetObjectStatus( int objectType, int objectIndex, int status );
345  void SetObjectStatus( int objectType, const char* objectName, int status );
346 
348 
353  int GetNumberOfObjectArrays( int objectType );
354  const char* GetObjectArrayName( int objectType, int arrayIndex );
355  int GetObjectArrayIndex( int objectType, const char* arrayName );
356  int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );
357  int GetObjectArrayStatus( int objectType, int arrayIndex );
358  int GetObjectArrayStatus( int objectType, const char* arrayName )
359  { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }
360  void SetObjectArrayStatus( int objectType, int arrayIndex, int status );
361  void SetObjectArrayStatus( int objectType, const char* arrayName, int status );
363 
365 
370  int GetNumberOfObjectAttributes( int objectType, int objectIndex );
371  const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );
372  int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );
373  int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );
374  int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )
375  { return this->GetObjectAttributeStatus( objectType, objectIndex,
376  this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }
377  void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );
378  void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )
379  { this->SetObjectAttributeStatus( objectType, objectIndex,
380  this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }
382 
383  virtual vtkIdType GetTotalNumberOfNodes();
384  virtual vtkIdType GetTotalNumberOfEdges();
385  virtual vtkIdType GetTotalNumberOfFaces();
386  virtual vtkIdType GetTotalNumberOfElements();
387 
389 
393  int GetNumberOfPartArrays();
394  const char* GetPartArrayName(int arrayIdx);
395  int GetPartArrayID( const char *name );
396  const char* GetPartBlockInfo(int arrayIdx);
397  void SetPartArrayStatus(int index, int flag);
398  void SetPartArrayStatus(const char*, int flag);
399  int GetPartArrayStatus(int index);
400  int GetPartArrayStatus(const char*);
402 
403 
405 
409  int GetNumberOfMaterialArrays();
410  const char* GetMaterialArrayName(int arrayIdx);
411  int GetMaterialArrayID( const char *name );
412  void SetMaterialArrayStatus(int index, int flag);
413  void SetMaterialArrayStatus(const char*, int flag);
414  int GetMaterialArrayStatus(int index);
415  int GetMaterialArrayStatus(const char*);
417 
419 
423  int GetNumberOfAssemblyArrays();
424  const char* GetAssemblyArrayName(int arrayIdx);
425  int GetAssemblyArrayID( const char *name );
426  void SetAssemblyArrayStatus(int index, int flag);
427  void SetAssemblyArrayStatus(const char*, int flag);
428  int GetAssemblyArrayStatus(int index);
429  int GetAssemblyArrayStatus(const char*);
431 
433 
440  int GetNumberOfHierarchyArrays();
441  const char* GetHierarchyArrayName(int arrayIdx);
442  void SetHierarchyArrayStatus(int index, int flag);
443  void SetHierarchyArrayStatus(const char*, int flag);
444  int GetHierarchyArrayStatus(int index);
445  int GetHierarchyArrayStatus(const char*);
447 
448  vtkGetMacro(DisplayType,int);
449  virtual void SetDisplayType(int type);
450 
456  vtkBooleanMacro(ExodusModelMetadata, int);
457  vtkSetMacro(ExodusModelMetadata, int);
458  vtkGetMacro(ExodusModelMetadata, int);
459 
461 
462  vtkGetObjectMacro(ExodusModel,vtkExodusModel);
464 
472  vtkSetMacro(PackExodusModelOntoOutput, int);
473  vtkGetMacro(PackExodusModelOntoOutput, int);
474  vtkBooleanMacro(PackExodusModelOntoOutput, int);
475 
477  int IsValidVariable( const char *type, const char *name );
478 
480  int GetVariableID ( const char *type, const char *name );
481 
482  void SetAllArrayStatus( int otype, int status );
483  // Helper functions
484  //static int StringsEqual(const char* s1, char* s2);
485  //static void StringUppercase(const char* str, char* upperstr);
486  //static char *StrDupWithNew(const char *s);
487 
488  // time series query functions
489  int GetTimeSeriesData( int ID, const char *vName, const char *vType,
490  vtkFloatArray *result );
491 
492 
493 
494  int GetNumberOfEdgeBlockArrays()
495  { return this->GetNumberOfObjects(EDGE_BLOCK); }
496  const char* GetEdgeBlockArrayName(int index)
497  { return this->GetObjectName(EDGE_BLOCK, index); }
498  int GetEdgeBlockArrayStatus(const char* name)
499  { return this->GetObjectStatus(EDGE_BLOCK, name); }
500  void SetEdgeBlockArrayStatus(const char* name, int flag)
501  { this->SetObjectStatus(EDGE_BLOCK, name, flag); }
502 
503  int GetNumberOfFaceBlockArrays()
504  { return this->GetNumberOfObjects(FACE_BLOCK); }
505  const char* GetFaceBlockArrayName(int index)
506  { return this->GetObjectName(FACE_BLOCK, index); }
507  int GetFaceBlockArrayStatus(const char* name)
508  { return this->GetObjectStatus(FACE_BLOCK, name); }
509  void SetFaceBlockArrayStatus(const char* name, int flag)
510  { this->SetObjectStatus(FACE_BLOCK, name, flag); }
511 
512  int GetNumberOfElementBlockArrays()
513  { return this->GetNumberOfObjects(ELEM_BLOCK); }
514  const char* GetElementBlockArrayName(int index)
515  { return this->GetObjectName(ELEM_BLOCK, index); }
516  int GetElementBlockArrayStatus(const char* name)
517  { return this->GetObjectStatus(ELEM_BLOCK, name); }
518  void SetElementBlockArrayStatus(const char* name, int flag)
519  { this->SetObjectStatus(ELEM_BLOCK, name, flag); }
520 
521  int GetNumberOfGlobalResultArrays()
522  { return this->GetNumberOfObjectArrays(GLOBAL); }
523  const char* GetGlobalResultArrayName(int index)
524  { return this->GetObjectArrayName(GLOBAL, index); }
525  int GetGlobalResultArrayStatus(const char* name)
526  { return this->GetObjectArrayStatus(GLOBAL, name); }
527  void SetGlobalResultArrayStatus(const char* name, int flag)
528  { this->SetObjectArrayStatus(GLOBAL, name, flag); }
529 
530  int GetNumberOfPointResultArrays()
531  { return this->GetNumberOfObjectArrays(NODAL); }
532  const char* GetPointResultArrayName(int index)
533  { return this->GetObjectArrayName(NODAL, index); }
534  int GetPointResultArrayStatus(const char* name)
535  { return this->GetObjectArrayStatus(NODAL, name); }
536  void SetPointResultArrayStatus(const char* name, int flag)
537  { this->SetObjectArrayStatus(NODAL, name, flag); }
538 
539  int GetNumberOfEdgeResultArrays()
540  { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
541  const char* GetEdgeResultArrayName(int index)
542  { return this->GetObjectArrayName(EDGE_BLOCK, index); }
543  int GetEdgeResultArrayStatus(const char* name)
544  { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }
545  void SetEdgeResultArrayStatus(const char* name, int flag)
546  { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }
547 
548  int GetNumberOfFaceResultArrays()
549  { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
550  const char* GetFaceResultArrayName(int index)
551  { return this->GetObjectArrayName(FACE_BLOCK, index); }
552  int GetFaceResultArrayStatus(const char* name)
553  { return this->GetObjectArrayStatus(FACE_BLOCK, name); }
554  void SetFaceResultArrayStatus(const char* name, int flag)
555  { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }
556 
557  int GetNumberOfElementResultArrays()
558  { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
559  const char* GetElementResultArrayName(int index)
560  { return this->GetObjectArrayName(ELEM_BLOCK, index); }
561  int GetElementResultArrayStatus(const char* name)
562  { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }
563  void SetElementResultArrayStatus(const char* name, int flag)
564  { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }
565 
566 
567  int GetNumberOfNodeMapArrays()
568  { return this->GetNumberOfObjects(NODE_MAP); }
569  const char* GetNodeMapArrayName(int index)
570  { return this->GetObjectName(NODE_MAP, index); }
571  int GetNodeMapArrayStatus(const char* name)
572  { return this->GetObjectStatus(NODE_MAP, name); }
573  void SetNodeMapArrayStatus(const char* name, int flag)
574  { this->SetObjectStatus(NODE_MAP, name, flag); }
575 
576  int GetNumberOfEdgeMapArrays()
577  { return this->GetNumberOfObjects(EDGE_MAP); }
578  const char* GetEdgeMapArrayName(int index)
579  { return this->GetObjectName(EDGE_MAP, index); }
580  int GetEdgeMapArrayStatus(const char* name)
581  { return this->GetObjectStatus(EDGE_MAP, name); }
582  void SetEdgeMapArrayStatus(const char* name, int flag)
583  { this->SetObjectStatus(EDGE_MAP, name, flag); }
584 
585  int GetNumberOfFaceMapArrays()
586  { return this->GetNumberOfObjects(FACE_MAP); }
587  const char* GetFaceMapArrayName(int index)
588  { return this->GetObjectName(FACE_MAP, index); }
589  int GetFaceMapArrayStatus(const char* name)
590  { return this->GetObjectStatus(FACE_MAP, name); }
591  void SetFaceMapArrayStatus(const char* name, int flag)
592  { this->SetObjectStatus(FACE_MAP, name, flag); }
593 
594  int GetNumberOfElementMapArrays()
595  { return this->GetNumberOfObjects(ELEM_MAP); }
596  const char* GetElementMapArrayName(int index)
597  { return this->GetObjectName(ELEM_MAP, index); }
598  int GetElementMapArrayStatus(const char* name)
599  { return this->GetObjectStatus(ELEM_MAP, name); }
600  void SetElementMapArrayStatus(const char* name, int flag)
601  { this->SetObjectStatus(ELEM_MAP, name, flag); }
602 
603  int GetNumberOfNodeSetArrays()
604  { return this->GetNumberOfObjects(NODE_SET); }
605  const char* GetNodeSetArrayName(int index)
606  { return this->GetObjectName(NODE_SET, index); }
607  int GetNodeSetArrayStatus(const char* name)
608  { return this->GetObjectStatus(NODE_SET, name); }
609  void SetNodeSetArrayStatus(const char* name, int flag)
610  { this->SetObjectStatus(NODE_SET, name, flag); }
611 
612  int GetNumberOfSideSetArrays()
613  { return this->GetNumberOfObjects(SIDE_SET); }
614  const char* GetSideSetArrayName(int index)
615  { return this->GetObjectName(SIDE_SET, index); }
616  int GetSideSetArrayStatus(const char* name)
617  { return this->GetObjectStatus(SIDE_SET, name); }
618  void SetSideSetArrayStatus(const char* name, int flag)
619  { this->SetObjectStatus(SIDE_SET, name, flag); }
620 
621  int GetNumberOfEdgeSetArrays()
622  { return this->GetNumberOfObjects(EDGE_SET); }
623  const char* GetEdgeSetArrayName(int index)
624  { return this->GetObjectName(EDGE_SET, index); }
625  int GetEdgeSetArrayStatus(const char* name)
626  { return this->GetObjectStatus(EDGE_SET, name); }
627  void SetEdgeSetArrayStatus(const char* name, int flag)
628  { this->SetObjectStatus(EDGE_SET, name, flag); }
629 
630  int GetNumberOfFaceSetArrays()
631  { return this->GetNumberOfObjects(FACE_SET); }
632  const char* GetFaceSetArrayName(int index)
633  { return this->GetObjectName(FACE_SET, index); }
634  int GetFaceSetArrayStatus(const char* name)
635  { return this->GetObjectStatus(FACE_SET, name); }
636  void SetFaceSetArrayStatus(const char* name, int flag)
637  { this->SetObjectStatus(FACE_SET, name, flag); }
638 
639  int GetNumberOfElementSetArrays()
640  { return this->GetNumberOfObjects(ELEM_SET); }
641  const char* GetElementSetArrayName(int index)
642  { return this->GetObjectName(ELEM_SET, index); }
643  int GetElementSetArrayStatus(const char* name)
644  { return this->GetObjectStatus(ELEM_SET, name); }
645  void SetElementSetArrayStatus(const char* name, int flag)
646  { this->SetObjectStatus(ELEM_SET, name, flag); }
647 
648 
649  int GetNumberOfNodeSetResultArrays()
650  { return this->GetNumberOfObjectArrays(NODE_SET); }
651  const char* GetNodeSetResultArrayName(int index)
652  { return this->GetObjectArrayName(NODE_SET, index); }
653  int GetNodeSetResultArrayStatus(const char* name)
654  { return this->GetObjectArrayStatus(NODE_SET, name); }
655  void SetNodeSetResultArrayStatus(const char* name, int flag)
656  { this->SetObjectArrayStatus(NODE_SET, name, flag); }
657 
658  int GetNumberOfSideSetResultArrays()
659  { return this->GetNumberOfObjectArrays(SIDE_SET); }
660  const char* GetSideSetResultArrayName(int index)
661  { return this->GetObjectArrayName(SIDE_SET, index); }
662  int GetSideSetResultArrayStatus(const char* name)
663  { return this->GetObjectArrayStatus(SIDE_SET, name); }
664  void SetSideSetResultArrayStatus(const char* name, int flag)
665  { this->SetObjectArrayStatus(SIDE_SET, name, flag); }
666 
667  int GetNumberOfEdgeSetResultArrays()
668  { return this->GetNumberOfObjectArrays(EDGE_SET); }
669  const char* GetEdgeSetResultArrayName(int index)
670  { return this->GetObjectArrayName(EDGE_SET, index); }
671  int GetEdgeSetResultArrayStatus(const char* name)
672  { return this->GetObjectArrayStatus(EDGE_SET, name); }
673  void SetEdgeSetResultArrayStatus(const char* name, int flag)
674  { this->SetObjectArrayStatus(EDGE_SET, name, flag); }
675 
676  int GetNumberOfFaceSetResultArrays()
677  { return this->GetNumberOfObjectArrays(FACE_SET); }
678  const char* GetFaceSetResultArrayName(int index)
679  { return this->GetObjectArrayName(FACE_SET, index); }
680  int GetFaceSetResultArrayStatus(const char* name)
681  { return this->GetObjectArrayStatus(FACE_SET, name); }
682  void SetFaceSetResultArrayStatus(const char* name, int flag)
683  { this->SetObjectArrayStatus(FACE_SET, name, flag); }
684 
685  int GetNumberOfElementSetResultArrays()
686  { return this->GetNumberOfObjectArrays(ELEM_SET); }
687  const char* GetElementSetResultArrayName(int index)
688  { return this->GetObjectArrayName(ELEM_SET, index); }
689  int GetElementSetResultArrayStatus(const char* name)
690  { return this->GetObjectArrayStatus(ELEM_SET, name); }
691  void SetElementSetResultArrayStatus(const char* name, int flag)
692  { this->SetObjectArrayStatus(ELEM_SET, name, flag); }
693 
706 
707 
710  void SetFastPathObjectType(const char *type);
711  // Description:
712  // Possible argument values: "INDEX","GLOBAL"
713  // "GLOBAL" means the id refers to a global id
714  // "INDEX" means the id refers to an index into the VTK array
715  void SetFastPathIdType(const char *type);
716  void SetFastPathObjectId(vtkIdType id);
718 
719 
724  void Reset();
725 
731  void ResetSettings();
732 
734  void ResetCache();
735 
738  virtual void UpdateTimeInformation();
739 
740  virtual void Dump();
741 
744  vtkGraph* GetSIL();
745 
747 
748  vtkGetMacro(SILUpdateStamp, int);
750 
752 
754  vtkGetMacro(ProducedFastPathOutput, bool);
756 
757 protected:
760 
763  virtual void NewExodusModel();
764 
765  // helper for finding IDs
766  static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );
767  static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );
768 
769  virtual void SetMetadata( vtkExodusIIReaderPrivate* );
770  vtkGetObjectMacro(Metadata,vtkExodusIIReaderPrivate);
771 
777  bool FindXMLFile();
778 
779  // Time query function. Called by ExecuteInformation().
780  // Fills the TimestepValues array.
781  void GetAllTimes(vtkInformationVector*);
782 
784  void AdvertiseTimeSteps( vtkInformation* outputInfo );
785 
786  virtual void SetExodusModel( vtkExodusModel* em );
787 
791  //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
792 
793  // Parameters for controlling what is read in.
794  char* FileName;
795  char* XMLFileName;
796  int TimeStep;
797  int TimeStepRange[2];
800 
801  // Information specific for exodus files.
802 
803  //1=display Block names
804  //2=display Part names
805  //3=display Material names
807 
808  // Metadata containing a description of the currently open file.
810 
814 
817 private:
818  vtkExodusIIReader(const vtkExodusIIReader&); // Not implemented
819  void operator=(const vtkExodusIIReader&); // Not implemented
820 
821  void AddDisplacements(vtkUnstructuredGrid* output);
822 };
823 
824 #endif