VTK: dox/Hybrid/vtkExodusIIReader.h Source File

00001 /*=========================================================================
00002 
00003   Program:   Visualization Toolkit
00004   Module:    $RCSfile: vtkExodusIIReader.h,v $
00005 
00006   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
00007   All rights reserved.
00008   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
00009 
00010      This software is distributed WITHOUT ANY WARRANTY; without even
00011      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00012      PURPOSE.  See the above copyright notice for more information.
00013 
00014 =========================================================================*/
00015 /*----------------------------------------------------------------------------
00016  Copyright (c) Sandia Corporation
00017  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
00018 ----------------------------------------------------------------------------*/
00019 
00036 #ifndef __vtkExodusIIReader_h
00037 #define __vtkExodusIIReader_h
00038 
00039 #include "vtkMultiBlockDataSetAlgorithm.h"
00040 
00041 class vtkIntArray;
00042 class vtkFloatArray;
00043 class vtkDataArray;
00044 class vtkDataSet;
00045 class vtkExodusIIReaderPrivate;
00046 class vtkExodusModel;
00047 class vtkExodusIICache;
00048 class vtkPoints;
00049 class vtkUnstructuredGrid;
00050 
00051 class VTK_HYBRID_EXPORT vtkExodusIIReader : public vtkMultiBlockDataSetAlgorithm 
00052 {
00053 public:
00054   static vtkExodusIIReader *New();
00055   vtkTypeRevisionMacro(vtkExodusIIReader,vtkMultiBlockDataSetAlgorithm);
00056   void PrintSelf(ostream& os, vtkIndent indent);
00057 
00059   int CanReadFile(const char* fname);
00060 
00061   //virtual void Modified();
00062 
00065   virtual unsigned long GetMTime();
00066   
00070   virtual unsigned long GetMetadataMTime();
00071 
00073 
00074   virtual void SetFileName( const char* fname );
00075   vtkGetStringMacro(FileName);
00077 
00079 
00080   virtual void SetXMLFileName( const char* fname );
00081   vtkGetStringMacro(XMLFileName);
00083 
00085 
00086   vtkSetMacro(TimeStep, int);
00087   vtkGetMacro(TimeStep, int);
00089 
00091 
00092   vtkGetVector2Macro(TimeStepRange,int);
00093   vtkSetVector2Macro(TimeStepRange,int);
00095 
00097 
00106   virtual void SetGenerateObjectIdCellArray( int g );
00107   int GetGenerateObjectIdCellArray();
00108   vtkBooleanMacro(GenerateObjectIdCellArray, int);
00109   static const char *GetObjectIdArrayName() { return "ObjectId"; }  
00111 
00112   virtual void SetGenerateGlobalElementIdArray( int g );
00113   int GetGenerateGlobalElementIdArray();
00114   vtkBooleanMacro(GenerateGlobalElementIdArray, int);
00115 
00116   virtual void SetGenerateGlobalNodeIdArray( int g );
00117   int GetGenerateGlobalNodeIdArray();
00118   vtkBooleanMacro(GenerateGlobalNodeIdArray, int);
00119 
00120   virtual void SetGenerateFileIdArray( int f );
00121   int GetGenerateFileIdArray();
00122   vtkBooleanMacro(GenerateFileIdArray, int);
00123   virtual void SetFileId( int f );
00124   int GetFileId();
00125 
00127 
00132   enum {
00133     SEARCH_TYPE_ELEMENT=0,
00134     SEARCH_TYPE_NODE,
00135     SEARCH_TYPE_ELEMENT_THEN_NODE,
00136     SEARCH_TYPE_NODE_THEN_ELEMENT,
00137     ID_NOT_FOUND=-234121312
00138   };
00139   // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
00140   enum ObjectType {
00141     // match Exodus macros from exodusII.h and exodusII_ext.h
00142     EDGE_BLOCK = 6,
00143     FACE_BLOCK = 8,
00144     ELEM_BLOCK = 1,
00145     NODE_SET = 2,
00146     EDGE_SET = 7,
00147     FACE_SET = 9,
00148     SIDE_SET = 3,
00149     ELEM_SET = 10,
00150     NODE_MAP = 5,
00151     EDGE_MAP = 11,
00152     FACE_MAP = 12,
00153     ELEM_MAP = 4,
00154     GLOBAL = 13,
00155     NODAL = 14,
00156     // extended values (not in Exodus headers) for use with SetAllArrayStatus:
00157     ASSEMBLY = 60,
00158     PART = 61,
00159     MATERIAL = 62,
00160     HIERARCHY = 63,
00161     // extended values (not in Exodus headers) for use in cache keys:
00162     QA_RECORDS = 103,          
00163     INFO_RECORDS = 104,        
00164     GLOBAL_TEMPORAL = 102,  
00165     NODAL_TEMPORAL = 101,      
00166     ELEM_BLOCK_TEMPORAL = 100,  
00167     GLOBAL_CONN = 99,          
00168     ELEM_BLOCK_ELEM_CONN = 98, 
00169     ELEM_BLOCK_FACE_CONN = 97, 
00170     ELEM_BLOCK_EDGE_CONN = 96, 
00171     FACE_BLOCK_CONN = 95,      
00172     EDGE_BLOCK_CONN = 94,      
00173     ELEM_SET_CONN = 93,        
00174     SIDE_SET_CONN = 92,        
00175     FACE_SET_CONN = 91,        
00176     EDGE_SET_CONN = 90,        
00177     NODE_SET_CONN = 89,        
00178     NODAL_COORDS = 88,         
00179     OBJECT_ID = 87,            
00180     GLOBAL_ELEMENT_ID = 86,    
00181     GLOBAL_NODE_ID = 85,       
00182     ELEMENT_ID = 84,           
00183     NODE_ID = 83,              
00184     NODAL_SQUEEZEMAP = 82,     
00185     ELEM_BLOCK_ATTRIB = 81,    
00186     FACE_BLOCK_ATTRIB = 80,    
00187     EDGE_BLOCK_ATTRIB = 79     
00188   };
00190   enum DecorationType {
00191     NONE = 0,         
00192     GLYPHS,           
00193     CORNER_AVERAGED   
00194   };
00196 //ETX
00197   static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
00198   static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
00199   static int GetGlobalElementID( vtkDataSet *data, int localID );
00200   static int GetGlobalElementID ( vtkDataSet *data, int localID, 
00201       int searchType );
00202 
00203   static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
00204   static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
00205   static int GetGlobalFaceID( vtkDataSet *data, int localID );
00206   static int GetGlobalFaceID ( vtkDataSet *data, int localID, 
00207       int searchType );
00208 
00209   static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
00210   static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
00211   static int GetGlobalEdgeID( vtkDataSet *data, int localID );
00212   static int GetGlobalEdgeID ( vtkDataSet *data, int localID, 
00213       int searchType );
00214 
00216 
00220   static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }  
00221   static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }  
00222   static int GetGlobalNodeID( vtkDataSet *data, int localID );
00223   static int GetGlobalNodeID( vtkDataSet *data, int localID, 
00224       int searchType );
00226 
00228 
00232   virtual void SetApplyDisplacements( int d );
00233   int GetApplyDisplacements();
00234   vtkBooleanMacro(ApplyDisplacements, int);
00235   virtual void SetDisplacementMagnitude( float s );
00236   float GetDisplacementMagnitude();
00238 
00240 
00243   virtual void SetHasModeShapes( int ms );
00244   int GetHasModeShapes();
00245   vtkBooleanMacro(HasModeShapes,int);
00247 
00249 
00255   virtual void SetModeShapeTime( double phase );
00256   double GetModeShapeTime();
00258 
00260 
00261   virtual void SetEdgeFieldDecorations( int d );
00262   int GetEdgeFieldDecorations();
00263   void EdgeFieldDecorationsNone() { this->SetEdgeFieldDecorations( NONE ); }
00264   void EdgeFieldDecorationsGlyphs() { this->SetEdgeFieldDecorations( GLYPHS ); }
00265   void EdgeFieldDecorationsCornerAveraged() { this->SetEdgeFieldDecorations( CORNER_AVERAGED ); }
00267 
00269 
00270   virtual void SetFaceFieldDecorations( int d );
00271   int GetFaceFieldDecorations();
00272   void FaceFieldDecorationsNone() { this->SetFaceFieldDecorations( NONE ); }
00273   void FaceFieldDecorationsGlyphs() { this->SetFaceFieldDecorations( GLYPHS ); }
00274   void FaceFieldDecorationsCornerAveraged() { this->SetFaceFieldDecorations( CORNER_AVERAGED ); }
00276 
00278 
00279   const char* GetTitle();
00280   int GetDimensionality();
00281   int GetNumberOfTimeSteps();
00283 
00284   int GetNumberOfNodesInFile();
00285   int GetNumberOfEdgesInFile();
00286   int GetNumberOfFacesInFile();
00287   int GetNumberOfElementsInFile();
00288 
00289   int GetObjectTypeFromName( const char* name );
00290   const char* GetObjectTypeName( int );
00291 
00292   int GetNumberOfNodes();
00293   int GetNumberOfObjects( int objectType );
00294   int GetNumberOfEntriesInObject( int objectType, int objectIndex );
00295   int GetObjectId( int objectType, int objectIndex );
00296   const char* GetObjectName( int objectType, int objectIndex );
00297   int GetObjectIndex( int objectType, const char* objectName );
00298   int GetObjectIndex( int objectType, int id );
00299   int GetObjectStatus( int objectType, int objectIndex );
00300   int GetObjectStatus( int objectType, const char* objectName )
00301     { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }
00302   void SetObjectStatus( int objectType, int objectIndex, int status );
00303   void SetObjectStatus( int objectType, const char* objectName, int status );
00304 
00306 
00311   int GetNumberOfObjectArrays( int objectType );
00312   const char* GetObjectArrayName( int objectType, int arrayIndex );
00313   int GetObjectArrayIndex( int objectType, const char* arrayName );
00314   int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );
00315   int GetObjectArrayStatus( int objectType, int arrayIndex );
00316   int GetObjectArrayStatus( int objectType, const char* arrayName )
00317     { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }
00318   void SetObjectArrayStatus( int objectType, int arrayIndex, int status );
00319   void SetObjectArrayStatus( int objectType, const char* arrayName, int status ); 
00321 
00323 
00328   int GetNumberOfObjectAttributes( int objectType, int objectIndex );
00329   const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );
00330   int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );
00331   int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );
00332   int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )
00333     { return this->GetObjectAttributeStatus( objectType, objectIndex,
00334       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }
00335   void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );
00336   void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )
00337     { this->SetObjectAttributeStatus( objectType, objectIndex,
00338       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }
00340 
00341   virtual vtkIdType GetTotalNumberOfNodes();
00342   virtual vtkIdType GetTotalNumberOfEdges();
00343   virtual vtkIdType GetTotalNumberOfFaces();
00344   virtual vtkIdType GetTotalNumberOfElements();
00345 
00347 
00351   int GetNumberOfPartArrays();
00352   const char* GetPartArrayName(int arrayIdx);
00353   int GetPartArrayID( const char *name );
00354   const char* GetPartBlockInfo(int arrayIdx);
00355   void SetPartArrayStatus(int index, int flag);
00356   void SetPartArrayStatus(const char*, int flag);
00357   int GetPartArrayStatus(int index);
00358   int GetPartArrayStatus(const char*);
00360   
00361 
00363 
00367   int GetNumberOfMaterialArrays();
00368   const char* GetMaterialArrayName(int arrayIdx);
00369   int GetMaterialArrayID( const char *name );
00370   void SetMaterialArrayStatus(int index, int flag);
00371   void SetMaterialArrayStatus(const char*, int flag);
00372   int GetMaterialArrayStatus(int index);
00373   int GetMaterialArrayStatus(const char*);
00375 
00377 
00381   int GetNumberOfAssemblyArrays();
00382   const char* GetAssemblyArrayName(int arrayIdx);
00383   int GetAssemblyArrayID( const char *name );
00384   void SetAssemblyArrayStatus(int index, int flag);
00385   void SetAssemblyArrayStatus(const char*, int flag);
00386   int GetAssemblyArrayStatus(int index);
00387   int GetAssemblyArrayStatus(const char*);
00389 
00391 
00398   int GetNumberOfHierarchyArrays();
00399   const char* GetHierarchyArrayName(int arrayIdx);
00400   void SetHierarchyArrayStatus(int index, int flag);
00401   void SetHierarchyArrayStatus(const char*, int flag);
00402   int GetHierarchyArrayStatus(int index);
00403   int GetHierarchyArrayStatus(const char*);
00405 
00406   vtkGetMacro(DisplayType,int);
00407   virtual void SetDisplayType(int type);
00408 
00414   vtkBooleanMacro(ExodusModelMetadata, int);
00415   vtkSetMacro(ExodusModelMetadata, int);
00416   vtkGetMacro(ExodusModelMetadata, int);
00417 
00419 
00420   vtkGetObjectMacro(ExodusModel,vtkExodusModel);
00422 
00430   vtkSetMacro(PackExodusModelOntoOutput, int);
00431   vtkGetMacro(PackExodusModelOntoOutput, int);
00432   vtkBooleanMacro(PackExodusModelOntoOutput, int);
00433 
00435   int IsValidVariable( const char *type, const char *name );
00436 
00438   int GetVariableID ( const char *type, const char *name );
00439 
00440   void SetAllArrayStatus( int otype, int status );
00441   // Helper functions
00442   //static int StringsEqual(const char* s1, char* s2);
00443   //static void StringUppercase(const char* str, char* upperstr);
00444   //static char *StrDupWithNew(const char *s);
00445 
00446   // time series query functions
00447   int GetTimeSeriesData( int ID, const char *vName, const char *vType, 
00448                          vtkFloatArray *result );
00449 
00450 
00451 
00452   int GetNumberOfEdgeBlockArrays()
00453     { return this->GetNumberOfObjects(EDGE_BLOCK); }
00454   const char* GetEdgeBlockArrayName(int index)
00455     { return this->GetObjectName(EDGE_BLOCK, index); }
00456   int GetEdgeBlockArrayStatus(const char* name)
00457     { return this->GetObjectStatus(EDGE_BLOCK, name); }
00458   void SetEdgeBlockArrayStatus(const char* name, int flag)
00459     { this->SetObjectStatus(EDGE_BLOCK, name, flag); }
00460   
00461   int GetNumberOfFaceBlockArrays()
00462     { return this->GetNumberOfObjects(FACE_BLOCK); }
00463   const char* GetFaceBlockArrayName(int index)
00464     { return this->GetObjectName(FACE_BLOCK, index); }
00465   int GetFaceBlockArrayStatus(const char* name)
00466     { return this->GetObjectStatus(FACE_BLOCK, name); }
00467   void SetFaceBlockArrayStatus(const char* name, int flag)
00468     { this->SetObjectStatus(FACE_BLOCK, name, flag); }
00469  
00470   int GetNumberOfElementBlockArrays()
00471     { return this->GetNumberOfObjects(ELEM_BLOCK); }
00472   const char* GetElementBlockArrayName(int index)
00473     { return this->GetObjectName(ELEM_BLOCK, index); }
00474   int GetElementBlockArrayStatus(const char* name)
00475     { return this->GetObjectStatus(ELEM_BLOCK, name); }
00476   void SetElementBlockArrayStatus(const char* name, int flag)
00477     { this->SetObjectStatus(ELEM_BLOCK, name, flag); }
00478 
00479   int GetNumberOfGlobalResultArrays()
00480     { return this->GetNumberOfObjectArrays(GLOBAL); }
00481   const char* GetGlobalResultArrayName(int index)
00482     { return this->GetObjectArrayName(GLOBAL, index); }
00483   int GetGlobalResultArrayStatus(const char* name)
00484     { return this->GetObjectArrayStatus(GLOBAL, name); }
00485   void SetGlobalResultArrayStatus(const char* name, int flag)
00486     { this->SetObjectArrayStatus(GLOBAL, name, flag); }
00487   
00488   int GetNumberOfPointResultArrays()
00489     { return this->GetNumberOfObjectArrays(NODAL); }
00490   const char* GetPointResultArrayName(int index)
00491     { return this->GetObjectArrayName(NODAL, index); }
00492   int GetPointResultArrayStatus(const char* name)
00493     { return this->GetObjectArrayStatus(NODAL, name); }
00494   void SetPointResultArrayStatus(const char* name, int flag)
00495     { this->SetObjectArrayStatus(NODAL, name, flag); }
00496   
00497   int GetNumberOfEdgeResultArrays()
00498     { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
00499   const char* GetEdgeResultArrayName(int index)
00500     { return this->GetObjectArrayName(EDGE_BLOCK, index); }
00501   int GetEdgeResultArrayStatus(const char* name)
00502     { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }
00503   void SetEdgeResultArrayStatus(const char* name, int flag)
00504     { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }
00505 
00506   int GetNumberOfFaceResultArrays()
00507     { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
00508   const char* GetFaceResultArrayName(int index)
00509     { return this->GetObjectArrayName(FACE_BLOCK, index); }
00510   int GetFaceResultArrayStatus(const char* name)
00511     { return this->GetObjectArrayStatus(FACE_BLOCK, name); }
00512   void SetFaceResultArrayStatus(const char* name, int flag)
00513     { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }
00514 
00515   int GetNumberOfElementResultArrays()
00516     { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
00517   const char* GetElementResultArrayName(int index)
00518     { return this->GetObjectArrayName(ELEM_BLOCK, index); }
00519   int GetElementResultArrayStatus(const char* name)
00520     { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }
00521   void SetElementResultArrayStatus(const char* name, int flag)
00522     { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }
00523   
00524   
00525   int GetNumberOfNodeMapArrays()
00526     { return this->GetNumberOfObjects(NODE_MAP); }
00527   const char* GetNodeMapArrayName(int index)
00528     { return this->GetObjectName(NODE_MAP, index); }
00529   int GetNodeMapArrayStatus(const char* name)
00530     { return this->GetObjectStatus(NODE_MAP, name); }
00531   void SetNodeMapArrayStatus(const char* name, int flag)
00532     { this->SetObjectStatus(NODE_MAP, name, flag); }
00533   
00534   int GetNumberOfEdgeMapArrays()
00535     { return this->GetNumberOfObjects(EDGE_MAP); }
00536   const char* GetEdgeMapArrayName(int index)
00537     { return this->GetObjectName(EDGE_MAP, index); }
00538   int GetEdgeMapArrayStatus(const char* name)
00539     { return this->GetObjectStatus(EDGE_MAP, name); }
00540   void SetEdgeMapArrayStatus(const char* name, int flag)
00541     { this->SetObjectStatus(EDGE_MAP, name, flag); }
00542 
00543   int GetNumberOfFaceMapArrays()
00544     { return this->GetNumberOfObjects(FACE_MAP); }
00545   const char* GetFaceMapArrayName(int index)
00546     { return this->GetObjectName(FACE_MAP, index); }
00547   int GetFaceMapArrayStatus(const char* name)
00548     { return this->GetObjectStatus(FACE_MAP, name); }
00549   void SetFaceMapArrayStatus(const char* name, int flag)
00550     { this->SetObjectStatus(FACE_MAP, name, flag); }
00551 
00552   int GetNumberOfElementMapArrays()
00553     { return this->GetNumberOfObjects(ELEM_MAP); }
00554   const char* GetElementMapArrayName(int index)
00555     { return this->GetObjectName(ELEM_MAP, index); }
00556   int GetElementMapArrayStatus(const char* name)
00557     { return this->GetObjectStatus(ELEM_MAP, name); }
00558   void SetElementMapArrayStatus(const char* name, int flag)
00559     { this->SetObjectStatus(ELEM_MAP, name, flag); }
00560   
00561   int GetNumberOfNodeSetArrays()
00562     { return this->GetNumberOfObjects(NODE_SET); }
00563   const char* GetNodeSetArrayName(int index)
00564     { return this->GetObjectName(NODE_SET, index); }
00565   int GetNodeSetArrayStatus(const char* name)
00566     { return this->GetObjectStatus(NODE_SET, name); }
00567   void SetNodeSetArrayStatus(const char* name, int flag)
00568     { this->SetObjectStatus(NODE_SET, name, flag); }
00569   
00570   int GetNumberOfSideSetArrays()
00571     { return this->GetNumberOfObjects(SIDE_SET); }
00572   const char* GetSideSetArrayName(int index)
00573     { return this->GetObjectName(SIDE_SET, index); }
00574   int GetSideSetArrayStatus(const char* name)
00575     { return this->GetObjectStatus(SIDE_SET, name); }
00576   void SetSideSetArrayStatus(const char* name, int flag)
00577     { this->SetObjectStatus(SIDE_SET, name, flag); }
00578   
00579   int GetNumberOfEdgeSetArrays()
00580     { return this->GetNumberOfObjects(EDGE_SET); }
00581   const char* GetEdgeSetArrayName(int index)
00582     { return this->GetObjectName(EDGE_SET, index); }
00583   int GetEdgeSetArrayStatus(const char* name)
00584     { return this->GetObjectStatus(EDGE_SET, name); }
00585   void SetEdgeSetArrayStatus(const char* name, int flag)
00586     { this->SetObjectStatus(EDGE_SET, name, flag); }
00587 
00588   int GetNumberOfFaceSetArrays()
00589     { return this->GetNumberOfObjects(FACE_SET); }
00590   const char* GetFaceSetArrayName(int index)
00591     { return this->GetObjectName(FACE_SET, index); }
00592   int GetFaceSetArrayStatus(const char* name)
00593     { return this->GetObjectStatus(FACE_SET, name); }
00594   void SetFaceSetArrayStatus(const char* name, int flag)
00595     { this->SetObjectStatus(FACE_SET, name, flag); }
00596   
00597   int GetNumberOfElementSetArrays()
00598     { return this->GetNumberOfObjects(ELEM_SET); }
00599   const char* GetElementSetArrayName(int index)
00600     { return this->GetObjectName(ELEM_SET, index); }
00601   int GetElementSetArrayStatus(const char* name)
00602     { return this->GetObjectStatus(ELEM_SET, name); }
00603   void SetElementSetArrayStatus(const char* name, int flag)
00604     { this->SetObjectStatus(ELEM_SET, name, flag); }
00605   
00606   
00607   int GetNumberOfNodeSetResultArrays()
00608     { return this->GetNumberOfObjectArrays(NODE_SET); }
00609   const char* GetNodeSetResultArrayName(int index)
00610     { return this->GetObjectArrayName(NODE_SET, index); }
00611   int GetNodeSetResultArrayStatus(const char* name)
00612     { return this->GetObjectArrayStatus(NODE_SET, name); }
00613   void SetNodeSetResultArrayStatus(const char* name, int flag)
00614     { this->SetObjectArrayStatus(NODE_SET, name, flag); }
00615   
00616   int GetNumberOfSideSetResultArrays()
00617     { return this->GetNumberOfObjectArrays(SIDE_SET); }
00618   const char* GetSideSetResultArrayName(int index)
00619     { return this->GetObjectArrayName(SIDE_SET, index); }
00620   int GetSideSetResultArrayStatus(const char* name)
00621     { return this->GetObjectArrayStatus(SIDE_SET, name); }
00622   void SetSideSetResultArrayStatus(const char* name, int flag)
00623     { this->SetObjectArrayStatus(SIDE_SET, name, flag); }
00624   
00625   int GetNumberOfEdgeSetResultArrays()
00626     { return this->GetNumberOfObjectArrays(EDGE_SET); }
00627   const char* GetEdgeSetResultArrayName(int index)
00628     { return this->GetObjectArrayName(EDGE_SET, index); }
00629   int GetEdgeSetResultArrayStatus(const char* name)
00630     { return this->GetObjectArrayStatus(EDGE_SET, name); }
00631   void SetEdgeSetResultArrayStatus(const char* name, int flag)
00632     { this->SetObjectArrayStatus(EDGE_SET, name, flag); }
00633 
00634   int GetNumberOfFaceSetResultArrays()
00635     { return this->GetNumberOfObjectArrays(FACE_SET); }
00636   const char* GetFaceSetResultArrayName(int index)
00637     { return this->GetObjectArrayName(FACE_SET, index); }
00638   int GetFaceSetResultArrayStatus(const char* name)
00639     { return this->GetObjectArrayStatus(FACE_SET, name); }
00640   void SetFaceSetResultArrayStatus(const char* name, int flag)
00641     { this->SetObjectArrayStatus(FACE_SET, name, flag); }
00642   
00643   int GetNumberOfElementSetResultArrays()
00644     { return this->GetNumberOfObjectArrays(ELEM_SET); }
00645   const char* GetElementSetResultArrayName(int index)
00646     { return this->GetObjectArrayName(ELEM_SET, index); }
00647   int GetElementSetResultArrayStatus(const char* name)
00648     { return this->GetObjectArrayStatus(ELEM_SET, name); }
00649   void SetElementSetResultArrayStatus(const char* name, int flag)
00650     { this->SetObjectArrayStatus(ELEM_SET, name, flag); }
00651 
00664 
00665 
00668   void SetFastPathObjectType(const char *type);
00669   // Description:
00670   // Possible argument values: "INDEX","GLOBAL"
00671   // "GLOBAL" means the id refers to a global id
00672   // "INDEX" means the id refers to an index into the VTK array
00673   void SetFastPathIdType(const char *type);
00674   void SetFastPathObjectId(vtkIdType id);
00676 
00677 
00682   void Reset();
00683 
00689   void ResetSettings();
00690 
00692   void ResetCache();
00693 
00696   virtual void UpdateTimeInformation();
00697 
00698   virtual void Dump();
00699 
00700 protected:
00701   vtkExodusIIReader();
00702   ~vtkExodusIIReader();
00703 
00706   virtual void NewExodusModel();
00707 
00708   // helper for finding IDs
00709   static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );
00710   static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );
00711 
00712   virtual void SetMetadata( vtkExodusIIReaderPrivate* );
00713   vtkGetObjectMacro(Metadata,vtkExodusIIReaderPrivate);
00714 
00720   bool FindXMLFile();
00721 
00722   // Time query function. Called by ExecuteInformation().
00723   // Fills the TimestepValues array.
00724   void GetAllTimes(vtkInformationVector*); 
00725 
00727   void AdvertiseTimeSteps( vtkInformation* outputInfo );
00728 
00729   virtual void SetExodusModel( vtkExodusModel* em );
00730 
00731   int ProcessRequest( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00732   int RequestInformation( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00733   int RequestData( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00734   //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00735 
00736   // Parameters for controlling what is read in.
00737   char* FileName;
00738   char* XMLFileName;
00739   int TimeStep;
00740   int TimeStepRange[2];
00741   vtkTimeStamp FileNameMTime;
00742   vtkTimeStamp XMLFileNameMTime;
00743   
00744   // Information specific for exodus files.
00745 
00746   //1=display Block names
00747   //2=display Part names
00748   //3=display Material names
00749   int DisplayType;
00750  
00751   // Metadata containing a description of the currently open file.
00752   vtkExodusIIReaderPrivate* Metadata;
00753 
00754   vtkExodusModel *ExodusModel;
00755   int PackExodusModelOntoOutput;
00756   int ExodusModelMetadata;
00757 
00758 private:
00759   vtkExodusIIReader(const vtkExodusIIReader&); // Not implemented
00760   void operator=(const vtkExodusIIReader&); // Not implemented
00761 
00762   void AddDisplacements(vtkUnstructuredGrid* output);
00763 };
00764 
00765 #endif