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 
00039 #ifndef __vtkExodusIIReader_h
00040 #define __vtkExodusIIReader_h
00041 
00042 #include "vtkMultiBlockDataSetAlgorithm.h"
00043 
00044 class vtkDataArray;
00045 class vtkDataSet;
00046 class vtkExodusIICache;
00047 class vtkExodusIIReaderPrivate;
00048 class vtkExodusModel;
00049 class vtkFloatArray;
00050 class vtkGraph;
00051 class vtkIntArray;
00052 class vtkPoints;
00053 class vtkUnstructuredGrid;
00054 
00055 class VTK_HYBRID_EXPORT vtkExodusIIReader : public vtkMultiBlockDataSetAlgorithm 
00056 {
00057 public:
00058   static vtkExodusIIReader *New();
00059   vtkTypeRevisionMacro(vtkExodusIIReader,vtkMultiBlockDataSetAlgorithm);
00060   void PrintSelf(ostream& os, vtkIndent indent);
00061 
00063   int CanReadFile(const char* fname);
00064 
00065   //virtual void Modified();
00066 
00069   virtual unsigned long GetMTime();
00070   
00074   virtual unsigned long GetMetadataMTime();
00075 
00077 
00078   virtual void SetFileName( const char* fname );
00079   vtkGetStringMacro(FileName);
00081 
00083 
00084   virtual void SetXMLFileName( const char* fname );
00085   vtkGetStringMacro(XMLFileName);
00087 
00089 
00090   vtkSetMacro(TimeStep, int);
00091   vtkGetMacro(TimeStep, int);
00093 
00095 
00096   vtkGetVector2Macro(TimeStepRange,int);
00097   vtkSetVector2Macro(TimeStepRange,int);
00099 
00101 
00110   virtual void SetGenerateObjectIdCellArray( int g );
00111   int GetGenerateObjectIdCellArray();
00112   vtkBooleanMacro(GenerateObjectIdCellArray, int);
00113   static const char *GetObjectIdArrayName() { return "ObjectId"; }  
00115 
00116   virtual void SetGenerateGlobalElementIdArray( int g );
00117   int GetGenerateGlobalElementIdArray();
00118   vtkBooleanMacro(GenerateGlobalElementIdArray, int);
00119 
00120   virtual void SetGenerateGlobalNodeIdArray( int g );
00121   int GetGenerateGlobalNodeIdArray();
00122   vtkBooleanMacro(GenerateGlobalNodeIdArray, int);
00123 
00124   virtual void SetGenerateFileIdArray( int f );
00125   int GetGenerateFileIdArray();
00126   vtkBooleanMacro(GenerateFileIdArray, int);
00127   virtual void SetFileId( int f );
00128   int GetFileId();
00129 
00131 
00136   enum {
00137     SEARCH_TYPE_ELEMENT=0,
00138     SEARCH_TYPE_NODE,
00139     SEARCH_TYPE_ELEMENT_THEN_NODE,
00140     SEARCH_TYPE_NODE_THEN_ELEMENT,
00141     ID_NOT_FOUND=-234121312
00142   };
00143   // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
00144   enum ObjectType {
00145     // match Exodus macros from exodusII.h and exodusII_ext.h
00146     EDGE_BLOCK = 6,
00147     FACE_BLOCK = 8,
00148     ELEM_BLOCK = 1,
00149     NODE_SET = 2,
00150     EDGE_SET = 7,
00151     FACE_SET = 9,
00152     SIDE_SET = 3,
00153     ELEM_SET = 10,
00154     NODE_MAP = 5,
00155     EDGE_MAP = 11,
00156     FACE_MAP = 12,
00157     ELEM_MAP = 4,
00158     GLOBAL = 13,
00159     NODAL = 14,
00160     // extended values (not in Exodus headers) for use with SetAllArrayStatus:
00161     ASSEMBLY = 60,
00162     PART = 61,
00163     MATERIAL = 62,
00164     HIERARCHY = 63,
00165     // extended values (not in Exodus headers) for use in cache keys:
00166     QA_RECORDS = 103,          
00167     INFO_RECORDS = 104,        
00168     GLOBAL_TEMPORAL = 102,  
00169     NODAL_TEMPORAL = 101,      
00170     ELEM_BLOCK_TEMPORAL = 100,  
00171     GLOBAL_CONN = 99,          
00172     ELEM_BLOCK_ELEM_CONN = 98, 
00173     ELEM_BLOCK_FACE_CONN = 97, 
00174     ELEM_BLOCK_EDGE_CONN = 96, 
00175     FACE_BLOCK_CONN = 95,      
00176     EDGE_BLOCK_CONN = 94,      
00177     ELEM_SET_CONN = 93,        
00178     SIDE_SET_CONN = 92,        
00179     FACE_SET_CONN = 91,        
00180     EDGE_SET_CONN = 90,        
00181     NODE_SET_CONN = 89,        
00182     NODAL_COORDS = 88,         
00183     OBJECT_ID = 87,            
00184     GLOBAL_ELEMENT_ID = 86,    
00185     GLOBAL_NODE_ID = 85,       
00186     ELEMENT_ID = 84,           
00187     NODE_ID = 83,              
00188     NODAL_SQUEEZEMAP = 82,     
00189     ELEM_BLOCK_ATTRIB = 81,    
00190     FACE_BLOCK_ATTRIB = 80,    
00191     EDGE_BLOCK_ATTRIB = 79,    
00192     FACE_ID = 105,             
00193     EDGE_ID = 106              
00194   };
00196   enum DecorationType {
00197     NONE = 0,         
00198     GLYPHS,           
00199     CORNER_AVERAGED   
00200   };
00202 //ETX
00203   static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
00204   static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
00205   static int GetGlobalElementID( vtkDataSet *data, int localID );
00206   static int GetGlobalElementID ( vtkDataSet *data, int localID, 
00207       int searchType );
00208 
00209   static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
00210   static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
00211   static int GetGlobalFaceID( vtkDataSet *data, int localID );
00212   static int GetGlobalFaceID ( vtkDataSet *data, int localID, 
00213       int searchType );
00214 
00215   static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
00216   static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
00217   static int GetGlobalEdgeID( vtkDataSet *data, int localID );
00218   static int GetGlobalEdgeID ( vtkDataSet *data, int localID, 
00219       int searchType );
00220 
00222 
00226   static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }  
00227   static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }  
00228   static int GetGlobalNodeID( vtkDataSet *data, int localID );
00229   static int GetGlobalNodeID( vtkDataSet *data, int localID, 
00230       int searchType );
00232 
00234 
00238   virtual void SetApplyDisplacements( int d );
00239   int GetApplyDisplacements();
00240   vtkBooleanMacro(ApplyDisplacements, int);
00241   virtual void SetDisplacementMagnitude( float s );
00242   float GetDisplacementMagnitude();
00244 
00246 
00249   virtual void SetHasModeShapes( int ms );
00250   int GetHasModeShapes();
00251   vtkBooleanMacro(HasModeShapes,int);
00253 
00255 
00261   virtual void SetModeShapeTime( double phase );
00262   double GetModeShapeTime();
00264 
00266 
00267   virtual void SetEdgeFieldDecorations( int d );
00268   int GetEdgeFieldDecorations();
00269   void EdgeFieldDecorationsNone() { this->SetEdgeFieldDecorations( NONE ); }
00270   void EdgeFieldDecorationsGlyphs() { this->SetEdgeFieldDecorations( GLYPHS ); }
00271   void EdgeFieldDecorationsCornerAveraged() { this->SetEdgeFieldDecorations( CORNER_AVERAGED ); }
00273 
00275 
00276   virtual void SetFaceFieldDecorations( int d );
00277   int GetFaceFieldDecorations();
00278   void FaceFieldDecorationsNone() { this->SetFaceFieldDecorations( NONE ); }
00279   void FaceFieldDecorationsGlyphs() { this->SetFaceFieldDecorations( GLYPHS ); }
00280   void FaceFieldDecorationsCornerAveraged() { this->SetFaceFieldDecorations( CORNER_AVERAGED ); }
00282 
00284 
00285   const char* GetTitle();
00286   int GetDimensionality();
00287   int GetNumberOfTimeSteps();
00289 
00290   int GetNumberOfNodesInFile();
00291   int GetNumberOfEdgesInFile();
00292   int GetNumberOfFacesInFile();
00293   int GetNumberOfElementsInFile();
00294 
00295   int GetObjectTypeFromName( const char* name );
00296   const char* GetObjectTypeName( int );
00297 
00298   int GetNumberOfNodes();
00299   int GetNumberOfObjects( int objectType );
00300   int GetNumberOfEntriesInObject( int objectType, int objectIndex );
00301   int GetObjectId( int objectType, int objectIndex );
00302   const char* GetObjectName( int objectType, int objectIndex );
00303   int GetObjectIndex( int objectType, const char* objectName );
00304   int GetObjectIndex( int objectType, int id );
00305   int GetObjectStatus( int objectType, int objectIndex );
00306   int GetObjectStatus( int objectType, const char* objectName )
00307     { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }
00308   void SetObjectStatus( int objectType, int objectIndex, int status );
00309   void SetObjectStatus( int objectType, const char* objectName, int status );
00310 
00312 
00317   int GetNumberOfObjectArrays( int objectType );
00318   const char* GetObjectArrayName( int objectType, int arrayIndex );
00319   int GetObjectArrayIndex( int objectType, const char* arrayName );
00320   int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );
00321   int GetObjectArrayStatus( int objectType, int arrayIndex );
00322   int GetObjectArrayStatus( int objectType, const char* arrayName )
00323     { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }
00324   void SetObjectArrayStatus( int objectType, int arrayIndex, int status );
00325   void SetObjectArrayStatus( int objectType, const char* arrayName, int status ); 
00327 
00329 
00334   int GetNumberOfObjectAttributes( int objectType, int objectIndex );
00335   const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );
00336   int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );
00337   int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );
00338   int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )
00339     { return this->GetObjectAttributeStatus( objectType, objectIndex,
00340       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }
00341   void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );
00342   void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )
00343     { this->SetObjectAttributeStatus( objectType, objectIndex,
00344       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }
00346 
00347   virtual vtkIdType GetTotalNumberOfNodes();
00348   virtual vtkIdType GetTotalNumberOfEdges();
00349   virtual vtkIdType GetTotalNumberOfFaces();
00350   virtual vtkIdType GetTotalNumberOfElements();
00351 
00353 
00357   int GetNumberOfPartArrays();
00358   const char* GetPartArrayName(int arrayIdx);
00359   int GetPartArrayID( const char *name );
00360   const char* GetPartBlockInfo(int arrayIdx);
00361   void SetPartArrayStatus(int index, int flag);
00362   void SetPartArrayStatus(const char*, int flag);
00363   int GetPartArrayStatus(int index);
00364   int GetPartArrayStatus(const char*);
00366   
00367 
00369 
00373   int GetNumberOfMaterialArrays();
00374   const char* GetMaterialArrayName(int arrayIdx);
00375   int GetMaterialArrayID( const char *name );
00376   void SetMaterialArrayStatus(int index, int flag);
00377   void SetMaterialArrayStatus(const char*, int flag);
00378   int GetMaterialArrayStatus(int index);
00379   int GetMaterialArrayStatus(const char*);
00381 
00383 
00387   int GetNumberOfAssemblyArrays();
00388   const char* GetAssemblyArrayName(int arrayIdx);
00389   int GetAssemblyArrayID( const char *name );
00390   void SetAssemblyArrayStatus(int index, int flag);
00391   void SetAssemblyArrayStatus(const char*, int flag);
00392   int GetAssemblyArrayStatus(int index);
00393   int GetAssemblyArrayStatus(const char*);
00395 
00397 
00404   int GetNumberOfHierarchyArrays();
00405   const char* GetHierarchyArrayName(int arrayIdx);
00406   void SetHierarchyArrayStatus(int index, int flag);
00407   void SetHierarchyArrayStatus(const char*, int flag);
00408   int GetHierarchyArrayStatus(int index);
00409   int GetHierarchyArrayStatus(const char*);
00411 
00412   vtkGetMacro(DisplayType,int);
00413   virtual void SetDisplayType(int type);
00414 
00420   vtkBooleanMacro(ExodusModelMetadata, int);
00421   vtkSetMacro(ExodusModelMetadata, int);
00422   vtkGetMacro(ExodusModelMetadata, int);
00423 
00425 
00426   vtkGetObjectMacro(ExodusModel,vtkExodusModel);
00428 
00436   vtkSetMacro(PackExodusModelOntoOutput, int);
00437   vtkGetMacro(PackExodusModelOntoOutput, int);
00438   vtkBooleanMacro(PackExodusModelOntoOutput, int);
00439 
00441   int IsValidVariable( const char *type, const char *name );
00442 
00444   int GetVariableID ( const char *type, const char *name );
00445 
00446   void SetAllArrayStatus( int otype, int status );
00447   // Helper functions
00448   //static int StringsEqual(const char* s1, char* s2);
00449   //static void StringUppercase(const char* str, char* upperstr);
00450   //static char *StrDupWithNew(const char *s);
00451 
00452   // time series query functions
00453   int GetTimeSeriesData( int ID, const char *vName, const char *vType, 
00454                          vtkFloatArray *result );
00455 
00456 
00457 
00458   int GetNumberOfEdgeBlockArrays()
00459     { return this->GetNumberOfObjects(EDGE_BLOCK); }
00460   const char* GetEdgeBlockArrayName(int index)
00461     { return this->GetObjectName(EDGE_BLOCK, index); }
00462   int GetEdgeBlockArrayStatus(const char* name)
00463     { return this->GetObjectStatus(EDGE_BLOCK, name); }
00464   void SetEdgeBlockArrayStatus(const char* name, int flag)
00465     { this->SetObjectStatus(EDGE_BLOCK, name, flag); }
00466   
00467   int GetNumberOfFaceBlockArrays()
00468     { return this->GetNumberOfObjects(FACE_BLOCK); }
00469   const char* GetFaceBlockArrayName(int index)
00470     { return this->GetObjectName(FACE_BLOCK, index); }
00471   int GetFaceBlockArrayStatus(const char* name)
00472     { return this->GetObjectStatus(FACE_BLOCK, name); }
00473   void SetFaceBlockArrayStatus(const char* name, int flag)
00474     { this->SetObjectStatus(FACE_BLOCK, name, flag); }
00475  
00476   int GetNumberOfElementBlockArrays()
00477     { return this->GetNumberOfObjects(ELEM_BLOCK); }
00478   const char* GetElementBlockArrayName(int index)
00479     { return this->GetObjectName(ELEM_BLOCK, index); }
00480   int GetElementBlockArrayStatus(const char* name)
00481     { return this->GetObjectStatus(ELEM_BLOCK, name); }
00482   void SetElementBlockArrayStatus(const char* name, int flag)
00483     { this->SetObjectStatus(ELEM_BLOCK, name, flag); }
00484 
00485   int GetNumberOfGlobalResultArrays()
00486     { return this->GetNumberOfObjectArrays(GLOBAL); }
00487   const char* GetGlobalResultArrayName(int index)
00488     { return this->GetObjectArrayName(GLOBAL, index); }
00489   int GetGlobalResultArrayStatus(const char* name)
00490     { return this->GetObjectArrayStatus(GLOBAL, name); }
00491   void SetGlobalResultArrayStatus(const char* name, int flag)
00492     { this->SetObjectArrayStatus(GLOBAL, name, flag); }
00493   
00494   int GetNumberOfPointResultArrays()
00495     { return this->GetNumberOfObjectArrays(NODAL); }
00496   const char* GetPointResultArrayName(int index)
00497     { return this->GetObjectArrayName(NODAL, index); }
00498   int GetPointResultArrayStatus(const char* name)
00499     { return this->GetObjectArrayStatus(NODAL, name); }
00500   void SetPointResultArrayStatus(const char* name, int flag)
00501     { this->SetObjectArrayStatus(NODAL, name, flag); }
00502   
00503   int GetNumberOfEdgeResultArrays()
00504     { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
00505   const char* GetEdgeResultArrayName(int index)
00506     { return this->GetObjectArrayName(EDGE_BLOCK, index); }
00507   int GetEdgeResultArrayStatus(const char* name)
00508     { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }
00509   void SetEdgeResultArrayStatus(const char* name, int flag)
00510     { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }
00511 
00512   int GetNumberOfFaceResultArrays()
00513     { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
00514   const char* GetFaceResultArrayName(int index)
00515     { return this->GetObjectArrayName(FACE_BLOCK, index); }
00516   int GetFaceResultArrayStatus(const char* name)
00517     { return this->GetObjectArrayStatus(FACE_BLOCK, name); }
00518   void SetFaceResultArrayStatus(const char* name, int flag)
00519     { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }
00520 
00521   int GetNumberOfElementResultArrays()
00522     { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
00523   const char* GetElementResultArrayName(int index)
00524     { return this->GetObjectArrayName(ELEM_BLOCK, index); }
00525   int GetElementResultArrayStatus(const char* name)
00526     { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }
00527   void SetElementResultArrayStatus(const char* name, int flag)
00528     { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }
00529   
00530   
00531   int GetNumberOfNodeMapArrays()
00532     { return this->GetNumberOfObjects(NODE_MAP); }
00533   const char* GetNodeMapArrayName(int index)
00534     { return this->GetObjectName(NODE_MAP, index); }
00535   int GetNodeMapArrayStatus(const char* name)
00536     { return this->GetObjectStatus(NODE_MAP, name); }
00537   void SetNodeMapArrayStatus(const char* name, int flag)
00538     { this->SetObjectStatus(NODE_MAP, name, flag); }
00539   
00540   int GetNumberOfEdgeMapArrays()
00541     { return this->GetNumberOfObjects(EDGE_MAP); }
00542   const char* GetEdgeMapArrayName(int index)
00543     { return this->GetObjectName(EDGE_MAP, index); }
00544   int GetEdgeMapArrayStatus(const char* name)
00545     { return this->GetObjectStatus(EDGE_MAP, name); }
00546   void SetEdgeMapArrayStatus(const char* name, int flag)
00547     { this->SetObjectStatus(EDGE_MAP, name, flag); }
00548 
00549   int GetNumberOfFaceMapArrays()
00550     { return this->GetNumberOfObjects(FACE_MAP); }
00551   const char* GetFaceMapArrayName(int index)
00552     { return this->GetObjectName(FACE_MAP, index); }
00553   int GetFaceMapArrayStatus(const char* name)
00554     { return this->GetObjectStatus(FACE_MAP, name); }
00555   void SetFaceMapArrayStatus(const char* name, int flag)
00556     { this->SetObjectStatus(FACE_MAP, name, flag); }
00557 
00558   int GetNumberOfElementMapArrays()
00559     { return this->GetNumberOfObjects(ELEM_MAP); }
00560   const char* GetElementMapArrayName(int index)
00561     { return this->GetObjectName(ELEM_MAP, index); }
00562   int GetElementMapArrayStatus(const char* name)
00563     { return this->GetObjectStatus(ELEM_MAP, name); }
00564   void SetElementMapArrayStatus(const char* name, int flag)
00565     { this->SetObjectStatus(ELEM_MAP, name, flag); }
00566   
00567   int GetNumberOfNodeSetArrays()
00568     { return this->GetNumberOfObjects(NODE_SET); }
00569   const char* GetNodeSetArrayName(int index)
00570     { return this->GetObjectName(NODE_SET, index); }
00571   int GetNodeSetArrayStatus(const char* name)
00572     { return this->GetObjectStatus(NODE_SET, name); }
00573   void SetNodeSetArrayStatus(const char* name, int flag)
00574     { this->SetObjectStatus(NODE_SET, name, flag); }
00575   
00576   int GetNumberOfSideSetArrays()
00577     { return this->GetNumberOfObjects(SIDE_SET); }
00578   const char* GetSideSetArrayName(int index)
00579     { return this->GetObjectName(SIDE_SET, index); }
00580   int GetSideSetArrayStatus(const char* name)
00581     { return this->GetObjectStatus(SIDE_SET, name); }
00582   void SetSideSetArrayStatus(const char* name, int flag)
00583     { this->SetObjectStatus(SIDE_SET, name, flag); }
00584   
00585   int GetNumberOfEdgeSetArrays()
00586     { return this->GetNumberOfObjects(EDGE_SET); }
00587   const char* GetEdgeSetArrayName(int index)
00588     { return this->GetObjectName(EDGE_SET, index); }
00589   int GetEdgeSetArrayStatus(const char* name)
00590     { return this->GetObjectStatus(EDGE_SET, name); }
00591   void SetEdgeSetArrayStatus(const char* name, int flag)
00592     { this->SetObjectStatus(EDGE_SET, name, flag); }
00593 
00594   int GetNumberOfFaceSetArrays()
00595     { return this->GetNumberOfObjects(FACE_SET); }
00596   const char* GetFaceSetArrayName(int index)
00597     { return this->GetObjectName(FACE_SET, index); }
00598   int GetFaceSetArrayStatus(const char* name)
00599     { return this->GetObjectStatus(FACE_SET, name); }
00600   void SetFaceSetArrayStatus(const char* name, int flag)
00601     { this->SetObjectStatus(FACE_SET, name, flag); }
00602   
00603   int GetNumberOfElementSetArrays()
00604     { return this->GetNumberOfObjects(ELEM_SET); }
00605   const char* GetElementSetArrayName(int index)
00606     { return this->GetObjectName(ELEM_SET, index); }
00607   int GetElementSetArrayStatus(const char* name)
00608     { return this->GetObjectStatus(ELEM_SET, name); }
00609   void SetElementSetArrayStatus(const char* name, int flag)
00610     { this->SetObjectStatus(ELEM_SET, name, flag); }
00611   
00612   
00613   int GetNumberOfNodeSetResultArrays()
00614     { return this->GetNumberOfObjectArrays(NODE_SET); }
00615   const char* GetNodeSetResultArrayName(int index)
00616     { return this->GetObjectArrayName(NODE_SET, index); }
00617   int GetNodeSetResultArrayStatus(const char* name)
00618     { return this->GetObjectArrayStatus(NODE_SET, name); }
00619   void SetNodeSetResultArrayStatus(const char* name, int flag)
00620     { this->SetObjectArrayStatus(NODE_SET, name, flag); }
00621   
00622   int GetNumberOfSideSetResultArrays()
00623     { return this->GetNumberOfObjectArrays(SIDE_SET); }
00624   const char* GetSideSetResultArrayName(int index)
00625     { return this->GetObjectArrayName(SIDE_SET, index); }
00626   int GetSideSetResultArrayStatus(const char* name)
00627     { return this->GetObjectArrayStatus(SIDE_SET, name); }
00628   void SetSideSetResultArrayStatus(const char* name, int flag)
00629     { this->SetObjectArrayStatus(SIDE_SET, name, flag); }
00630   
00631   int GetNumberOfEdgeSetResultArrays()
00632     { return this->GetNumberOfObjectArrays(EDGE_SET); }
00633   const char* GetEdgeSetResultArrayName(int index)
00634     { return this->GetObjectArrayName(EDGE_SET, index); }
00635   int GetEdgeSetResultArrayStatus(const char* name)
00636     { return this->GetObjectArrayStatus(EDGE_SET, name); }
00637   void SetEdgeSetResultArrayStatus(const char* name, int flag)
00638     { this->SetObjectArrayStatus(EDGE_SET, name, flag); }
00639 
00640   int GetNumberOfFaceSetResultArrays()
00641     { return this->GetNumberOfObjectArrays(FACE_SET); }
00642   const char* GetFaceSetResultArrayName(int index)
00643     { return this->GetObjectArrayName(FACE_SET, index); }
00644   int GetFaceSetResultArrayStatus(const char* name)
00645     { return this->GetObjectArrayStatus(FACE_SET, name); }
00646   void SetFaceSetResultArrayStatus(const char* name, int flag)
00647     { this->SetObjectArrayStatus(FACE_SET, name, flag); }
00648   
00649   int GetNumberOfElementSetResultArrays()
00650     { return this->GetNumberOfObjectArrays(ELEM_SET); }
00651   const char* GetElementSetResultArrayName(int index)
00652     { return this->GetObjectArrayName(ELEM_SET, index); }
00653   int GetElementSetResultArrayStatus(const char* name)
00654     { return this->GetObjectArrayStatus(ELEM_SET, name); }
00655   void SetElementSetResultArrayStatus(const char* name, int flag)
00656     { this->SetObjectArrayStatus(ELEM_SET, name, flag); }
00657 
00670 
00671 
00674   void SetFastPathObjectType(const char *type);
00675   // Description:
00676   // Possible argument values: "INDEX","GLOBAL"
00677   // "GLOBAL" means the id refers to a global id
00678   // "INDEX" means the id refers to an index into the VTK array
00679   void SetFastPathIdType(const char *type);
00680   void SetFastPathObjectId(vtkIdType id);
00682 
00683 
00688   void Reset();
00689 
00695   void ResetSettings();
00696 
00698   void ResetCache();
00699 
00702   virtual void UpdateTimeInformation();
00703 
00704   virtual void Dump();
00705 
00708   vtkGraph* GetSIL();
00709 
00711 
00712   vtkGetMacro(SILUpdateStamp, int);
00714 
00715 protected:
00716   vtkExodusIIReader();
00717   ~vtkExodusIIReader();
00718 
00721   virtual void NewExodusModel();
00722 
00723   // helper for finding IDs
00724   static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );
00725   static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );
00726 
00727   virtual void SetMetadata( vtkExodusIIReaderPrivate* );
00728   vtkGetObjectMacro(Metadata,vtkExodusIIReaderPrivate);
00729 
00735   bool FindXMLFile();
00736 
00737   // Time query function. Called by ExecuteInformation().
00738   // Fills the TimestepValues array.
00739   void GetAllTimes(vtkInformationVector*); 
00740 
00742   void AdvertiseTimeSteps( vtkInformation* outputInfo );
00743 
00744   virtual void SetExodusModel( vtkExodusModel* em );
00745 
00746   int ProcessRequest( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00747   int RequestInformation( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00748   int RequestData( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00749   //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00750 
00751   // Parameters for controlling what is read in.
00752   char* FileName;
00753   char* XMLFileName;
00754   int TimeStep;
00755   int TimeStepRange[2];
00756   vtkTimeStamp FileNameMTime;
00757   vtkTimeStamp XMLFileNameMTime;
00758   
00759   // Information specific for exodus files.
00760 
00761   //1=display Block names
00762   //2=display Part names
00763   //3=display Material names
00764   int DisplayType;
00765  
00766   // Metadata containing a description of the currently open file.
00767   vtkExodusIIReaderPrivate* Metadata;
00768 
00769   vtkExodusModel *ExodusModel;
00770   int PackExodusModelOntoOutput;
00771   int ExodusModelMetadata;
00772 
00773   int SILUpdateStamp;
00774 
00775 private:
00776   vtkExodusIIReader(const vtkExodusIIReader&); // Not implemented
00777   void operator=(const vtkExodusIIReader&); // Not implemented
00778 
00779   void AddDisplacements(vtkUnstructuredGrid* output);
00780 };
00781 
00782 #endif