VTK: dox/Hybrid/vtkExodusIIReader.h Source File

00001 /*=========================================================================
00002 
00003   Program:   Visualization Toolkit
00004   Module:    vtkExodusIIReader.h
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   vtkTypeMacro(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 
00097   void SetModeShape(int val)
00098     {
00099     this->SetTimeStep(val-1);
00100     }
00102 
00104 
00105   vtkGetVector2Macro(TimeStepRange,int);
00106   vtkSetVector2Macro(TimeStepRange,int);
00108 
00110 
00119   virtual void SetGenerateObjectIdCellArray( int g );
00120   int GetGenerateObjectIdCellArray();
00121   vtkBooleanMacro(GenerateObjectIdCellArray, int);
00122   static const char *GetObjectIdArrayName() { return "ObjectId"; }  
00124 
00125   virtual void SetGenerateGlobalElementIdArray( int g );
00126   int GetGenerateGlobalElementIdArray();
00127   vtkBooleanMacro(GenerateGlobalElementIdArray, int);
00128 
00129   virtual void SetGenerateGlobalNodeIdArray( int g );
00130   int GetGenerateGlobalNodeIdArray();
00131   vtkBooleanMacro(GenerateGlobalNodeIdArray, int);
00132 
00133   virtual void SetGenerateImplicitElementIdArray( int g );
00134   int GetGenerateImplicitElementIdArray();
00135   vtkBooleanMacro(GenerateImplicitElementIdArray, int);
00136 
00137   virtual void SetGenerateImplicitNodeIdArray( int g );
00138   int GetGenerateImplicitNodeIdArray();
00139   vtkBooleanMacro(GenerateImplicitNodeIdArray, int);
00140 
00141   virtual void SetGenerateFileIdArray( int f );
00142   int GetGenerateFileIdArray();
00143   vtkBooleanMacro(GenerateFileIdArray, int);
00144   virtual void SetFileId( int f );
00145   int GetFileId();
00146 
00148 
00153   enum {
00154     SEARCH_TYPE_ELEMENT=0,
00155     SEARCH_TYPE_NODE,
00156     SEARCH_TYPE_ELEMENT_THEN_NODE,
00157     SEARCH_TYPE_NODE_THEN_ELEMENT,
00158     ID_NOT_FOUND=-234121312
00159   };
00160   // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
00161   enum ObjectType {
00162     // match Exodus macros from exodusII.h and exodusII_ext.h
00163     EDGE_BLOCK = 6,
00164     FACE_BLOCK = 8,
00165     ELEM_BLOCK = 1,
00166     NODE_SET = 2,
00167     EDGE_SET = 7,
00168     FACE_SET = 9,
00169     SIDE_SET = 3,
00170     ELEM_SET = 10,
00171     NODE_MAP = 5,
00172     EDGE_MAP = 11,
00173     FACE_MAP = 12,
00174     ELEM_MAP = 4,
00175     GLOBAL = 13,
00176     NODAL = 14,
00177     // extended values (not in Exodus headers) for use with SetAllArrayStatus:
00178     ASSEMBLY = 60,
00179     PART = 61,
00180     MATERIAL = 62,
00181     HIERARCHY = 63,
00182     // extended values (not in Exodus headers) for use in cache keys:
00183     QA_RECORDS = 103,          
00184     INFO_RECORDS = 104,        
00185     GLOBAL_TEMPORAL = 102,  
00186     NODAL_TEMPORAL = 101,      
00187     ELEM_BLOCK_TEMPORAL = 100,  
00188     GLOBAL_CONN = 99,          
00189     ELEM_BLOCK_ELEM_CONN = 98, 
00190     ELEM_BLOCK_FACE_CONN = 97, 
00191     ELEM_BLOCK_EDGE_CONN = 96, 
00192     FACE_BLOCK_CONN = 95,      
00193     EDGE_BLOCK_CONN = 94,      
00194     ELEM_SET_CONN = 93,        
00195     SIDE_SET_CONN = 92,        
00196     FACE_SET_CONN = 91,        
00197     EDGE_SET_CONN = 90,        
00198     NODE_SET_CONN = 89,        
00199     NODAL_COORDS = 88,         
00200     OBJECT_ID = 87,            
00201     IMPLICIT_ELEMENT_ID = 108, 
00202     IMPLICIT_NODE_ID = 107,    
00203     GLOBAL_ELEMENT_ID = 86,    
00204     GLOBAL_NODE_ID = 85,       
00205     ELEMENT_ID = 84,           
00206     NODE_ID = 83,              
00207     NODAL_SQUEEZEMAP = 82,     
00208     ELEM_BLOCK_ATTRIB = 81,    
00209     FACE_BLOCK_ATTRIB = 80,    
00210     EDGE_BLOCK_ATTRIB = 79,    
00211     FACE_ID = 105,             
00212     EDGE_ID = 106,             
00213     ENTITY_COUNTS = 109        
00214   };
00216   enum DecorationType {
00217     NONE = 0,         
00218     GLYPHS,           
00219     CORNER_AVERAGED   
00220   };
00222 //ETX
00223   static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
00224   static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
00225   static int GetGlobalElementID( vtkDataSet *data, int localID );
00226   static int GetGlobalElementID ( vtkDataSet *data, int localID, 
00227       int searchType );
00228   static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
00229 
00230   static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
00231   static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
00232   static int GetGlobalFaceID( vtkDataSet *data, int localID );
00233   static int GetGlobalFaceID ( vtkDataSet *data, int localID, 
00234       int searchType );
00235   static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }
00236 
00237   static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
00238   static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
00239   static int GetGlobalEdgeID( vtkDataSet *data, int localID );
00240   static int GetGlobalEdgeID ( vtkDataSet *data, int localID, 
00241       int searchType );
00242   static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }
00243 
00245 
00249   static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }  
00250   static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }  
00251   static int GetGlobalNodeID( vtkDataSet *data, int localID );
00252   static int GetGlobalNodeID( vtkDataSet *data, int localID, 
00253       int searchType );
00254   static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }  
00256 
00258 
00262   virtual void SetApplyDisplacements( int d );
00263   int GetApplyDisplacements();
00264   vtkBooleanMacro(ApplyDisplacements, int);
00265   virtual void SetDisplacementMagnitude( float s );
00266   float GetDisplacementMagnitude();
00268 
00270 
00273   virtual void SetHasModeShapes( int ms );
00274   int GetHasModeShapes();
00275   vtkBooleanMacro(HasModeShapes,int);
00277 
00279 
00285   virtual void SetModeShapeTime( double phase );
00286   double GetModeShapeTime();
00288 
00290 
00295   virtual void SetAnimateModeShapes(int flag);
00296   int GetAnimateModeShapes();
00297   vtkBooleanMacro(AnimateModeShapes, int);
00299 
00301 
00302   virtual void SetEdgeFieldDecorations( int d );
00303   int GetEdgeFieldDecorations();
00304   void EdgeFieldDecorationsNone() { this->SetEdgeFieldDecorations( NONE ); }
00305   void EdgeFieldDecorationsGlyphs() { this->SetEdgeFieldDecorations( GLYPHS ); }
00306   void EdgeFieldDecorationsCornerAveraged() { this->SetEdgeFieldDecorations( CORNER_AVERAGED ); }
00308 
00310 
00311   virtual void SetFaceFieldDecorations( int d );
00312   int GetFaceFieldDecorations();
00313   void FaceFieldDecorationsNone() { this->SetFaceFieldDecorations( NONE ); }
00314   void FaceFieldDecorationsGlyphs() { this->SetFaceFieldDecorations( GLYPHS ); }
00315   void FaceFieldDecorationsCornerAveraged() { this->SetFaceFieldDecorations( CORNER_AVERAGED ); }
00317 
00319 
00320   const char* GetTitle();
00321   int GetDimensionality();
00322   int GetNumberOfTimeSteps();
00324 
00325   int GetNumberOfNodesInFile();
00326   int GetNumberOfEdgesInFile();
00327   int GetNumberOfFacesInFile();
00328   int GetNumberOfElementsInFile();
00329 
00330   int GetObjectTypeFromName( const char* name );
00331   const char* GetObjectTypeName( int );
00332 
00333   int GetNumberOfNodes();
00334   int GetNumberOfObjects( int objectType );
00335   int GetNumberOfEntriesInObject( int objectType, int objectIndex );
00336   int GetObjectId( int objectType, int objectIndex );
00337   const char* GetObjectName( int objectType, int objectIndex );
00338   int GetObjectIndex( int objectType, const char* objectName );
00339   int GetObjectIndex( int objectType, int id );
00340   int GetObjectStatus( int objectType, int objectIndex );
00341   int GetObjectStatus( int objectType, const char* objectName )
00342     { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }
00343   void SetObjectStatus( int objectType, int objectIndex, int status );
00344   void SetObjectStatus( int objectType, const char* objectName, int status );
00345 
00347 
00352   int GetNumberOfObjectArrays( int objectType );
00353   const char* GetObjectArrayName( int objectType, int arrayIndex );
00354   int GetObjectArrayIndex( int objectType, const char* arrayName );
00355   int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );
00356   int GetObjectArrayStatus( int objectType, int arrayIndex );
00357   int GetObjectArrayStatus( int objectType, const char* arrayName )
00358     { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }
00359   void SetObjectArrayStatus( int objectType, int arrayIndex, int status );
00360   void SetObjectArrayStatus( int objectType, const char* arrayName, int status ); 
00362 
00364 
00369   int GetNumberOfObjectAttributes( int objectType, int objectIndex );
00370   const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );
00371   int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );
00372   int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );
00373   int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )
00374     { return this->GetObjectAttributeStatus( objectType, objectIndex,
00375       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }
00376   void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );
00377   void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )
00378     { this->SetObjectAttributeStatus( objectType, objectIndex,
00379       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }
00381 
00382   virtual vtkIdType GetTotalNumberOfNodes();
00383   virtual vtkIdType GetTotalNumberOfEdges();
00384   virtual vtkIdType GetTotalNumberOfFaces();
00385   virtual vtkIdType GetTotalNumberOfElements();
00386 
00388 
00392   int GetNumberOfPartArrays();
00393   const char* GetPartArrayName(int arrayIdx);
00394   int GetPartArrayID( const char *name );
00395   const char* GetPartBlockInfo(int arrayIdx);
00396   void SetPartArrayStatus(int index, int flag);
00397   void SetPartArrayStatus(const char*, int flag);
00398   int GetPartArrayStatus(int index);
00399   int GetPartArrayStatus(const char*);
00401   
00402 
00404 
00408   int GetNumberOfMaterialArrays();
00409   const char* GetMaterialArrayName(int arrayIdx);
00410   int GetMaterialArrayID( const char *name );
00411   void SetMaterialArrayStatus(int index, int flag);
00412   void SetMaterialArrayStatus(const char*, int flag);
00413   int GetMaterialArrayStatus(int index);
00414   int GetMaterialArrayStatus(const char*);
00416 
00418 
00422   int GetNumberOfAssemblyArrays();
00423   const char* GetAssemblyArrayName(int arrayIdx);
00424   int GetAssemblyArrayID( const char *name );
00425   void SetAssemblyArrayStatus(int index, int flag);
00426   void SetAssemblyArrayStatus(const char*, int flag);
00427   int GetAssemblyArrayStatus(int index);
00428   int GetAssemblyArrayStatus(const char*);
00430 
00432 
00439   int GetNumberOfHierarchyArrays();
00440   const char* GetHierarchyArrayName(int arrayIdx);
00441   void SetHierarchyArrayStatus(int index, int flag);
00442   void SetHierarchyArrayStatus(const char*, int flag);
00443   int GetHierarchyArrayStatus(int index);
00444   int GetHierarchyArrayStatus(const char*);
00446 
00447   vtkGetMacro(DisplayType,int);
00448   virtual void SetDisplayType(int type);
00449 
00455   vtkBooleanMacro(ExodusModelMetadata, int);
00456   vtkSetMacro(ExodusModelMetadata, int);
00457   vtkGetMacro(ExodusModelMetadata, int);
00458 
00460 
00461   vtkGetObjectMacro(ExodusModel,vtkExodusModel);
00463 
00471   vtkSetMacro(PackExodusModelOntoOutput, int);
00472   vtkGetMacro(PackExodusModelOntoOutput, int);
00473   vtkBooleanMacro(PackExodusModelOntoOutput, int);
00474 
00476   int IsValidVariable( const char *type, const char *name );
00477 
00479   int GetVariableID ( const char *type, const char *name );
00480 
00481   void SetAllArrayStatus( int otype, int status );
00482   // Helper functions
00483   //static int StringsEqual(const char* s1, char* s2);
00484   //static void StringUppercase(const char* str, char* upperstr);
00485   //static char *StrDupWithNew(const char *s);
00486 
00487   // time series query functions
00488   int GetTimeSeriesData( int ID, const char *vName, const char *vType, 
00489                          vtkFloatArray *result );
00490 
00491 
00492 
00493   int GetNumberOfEdgeBlockArrays()
00494     { return this->GetNumberOfObjects(EDGE_BLOCK); }
00495   const char* GetEdgeBlockArrayName(int index)
00496     { return this->GetObjectName(EDGE_BLOCK, index); }
00497   int GetEdgeBlockArrayStatus(const char* name)
00498     { return this->GetObjectStatus(EDGE_BLOCK, name); }
00499   void SetEdgeBlockArrayStatus(const char* name, int flag)
00500     { this->SetObjectStatus(EDGE_BLOCK, name, flag); }
00501   
00502   int GetNumberOfFaceBlockArrays()
00503     { return this->GetNumberOfObjects(FACE_BLOCK); }
00504   const char* GetFaceBlockArrayName(int index)
00505     { return this->GetObjectName(FACE_BLOCK, index); }
00506   int GetFaceBlockArrayStatus(const char* name)
00507     { return this->GetObjectStatus(FACE_BLOCK, name); }
00508   void SetFaceBlockArrayStatus(const char* name, int flag)
00509     { this->SetObjectStatus(FACE_BLOCK, name, flag); }
00510  
00511   int GetNumberOfElementBlockArrays()
00512     { return this->GetNumberOfObjects(ELEM_BLOCK); }
00513   const char* GetElementBlockArrayName(int index)
00514     { return this->GetObjectName(ELEM_BLOCK, index); }
00515   int GetElementBlockArrayStatus(const char* name)
00516     { return this->GetObjectStatus(ELEM_BLOCK, name); }
00517   void SetElementBlockArrayStatus(const char* name, int flag)
00518     { this->SetObjectStatus(ELEM_BLOCK, name, flag); }
00519 
00520   int GetNumberOfGlobalResultArrays()
00521     { return this->GetNumberOfObjectArrays(GLOBAL); }
00522   const char* GetGlobalResultArrayName(int index)
00523     { return this->GetObjectArrayName(GLOBAL, index); }
00524   int GetGlobalResultArrayStatus(const char* name)
00525     { return this->GetObjectArrayStatus(GLOBAL, name); }
00526   void SetGlobalResultArrayStatus(const char* name, int flag)
00527     { this->SetObjectArrayStatus(GLOBAL, name, flag); }
00528   
00529   int GetNumberOfPointResultArrays()
00530     { return this->GetNumberOfObjectArrays(NODAL); }
00531   const char* GetPointResultArrayName(int index)
00532     { return this->GetObjectArrayName(NODAL, index); }
00533   int GetPointResultArrayStatus(const char* name)
00534     { return this->GetObjectArrayStatus(NODAL, name); }
00535   void SetPointResultArrayStatus(const char* name, int flag)
00536     { this->SetObjectArrayStatus(NODAL, name, flag); }
00537   
00538   int GetNumberOfEdgeResultArrays()
00539     { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
00540   const char* GetEdgeResultArrayName(int index)
00541     { return this->GetObjectArrayName(EDGE_BLOCK, index); }
00542   int GetEdgeResultArrayStatus(const char* name)
00543     { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }
00544   void SetEdgeResultArrayStatus(const char* name, int flag)
00545     { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }
00546 
00547   int GetNumberOfFaceResultArrays()
00548     { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
00549   const char* GetFaceResultArrayName(int index)
00550     { return this->GetObjectArrayName(FACE_BLOCK, index); }
00551   int GetFaceResultArrayStatus(const char* name)
00552     { return this->GetObjectArrayStatus(FACE_BLOCK, name); }
00553   void SetFaceResultArrayStatus(const char* name, int flag)
00554     { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }
00555 
00556   int GetNumberOfElementResultArrays()
00557     { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
00558   const char* GetElementResultArrayName(int index)
00559     { return this->GetObjectArrayName(ELEM_BLOCK, index); }
00560   int GetElementResultArrayStatus(const char* name)
00561     { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }
00562   void SetElementResultArrayStatus(const char* name, int flag)
00563     { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }
00564   
00565   
00566   int GetNumberOfNodeMapArrays()
00567     { return this->GetNumberOfObjects(NODE_MAP); }
00568   const char* GetNodeMapArrayName(int index)
00569     { return this->GetObjectName(NODE_MAP, index); }
00570   int GetNodeMapArrayStatus(const char* name)
00571     { return this->GetObjectStatus(NODE_MAP, name); }
00572   void SetNodeMapArrayStatus(const char* name, int flag)
00573     { this->SetObjectStatus(NODE_MAP, name, flag); }
00574   
00575   int GetNumberOfEdgeMapArrays()
00576     { return this->GetNumberOfObjects(EDGE_MAP); }
00577   const char* GetEdgeMapArrayName(int index)
00578     { return this->GetObjectName(EDGE_MAP, index); }
00579   int GetEdgeMapArrayStatus(const char* name)
00580     { return this->GetObjectStatus(EDGE_MAP, name); }
00581   void SetEdgeMapArrayStatus(const char* name, int flag)
00582     { this->SetObjectStatus(EDGE_MAP, name, flag); }
00583 
00584   int GetNumberOfFaceMapArrays()
00585     { return this->GetNumberOfObjects(FACE_MAP); }
00586   const char* GetFaceMapArrayName(int index)
00587     { return this->GetObjectName(FACE_MAP, index); }
00588   int GetFaceMapArrayStatus(const char* name)
00589     { return this->GetObjectStatus(FACE_MAP, name); }
00590   void SetFaceMapArrayStatus(const char* name, int flag)
00591     { this->SetObjectStatus(FACE_MAP, name, flag); }
00592 
00593   int GetNumberOfElementMapArrays()
00594     { return this->GetNumberOfObjects(ELEM_MAP); }
00595   const char* GetElementMapArrayName(int index)
00596     { return this->GetObjectName(ELEM_MAP, index); }
00597   int GetElementMapArrayStatus(const char* name)
00598     { return this->GetObjectStatus(ELEM_MAP, name); }
00599   void SetElementMapArrayStatus(const char* name, int flag)
00600     { this->SetObjectStatus(ELEM_MAP, name, flag); }
00601   
00602   int GetNumberOfNodeSetArrays()
00603     { return this->GetNumberOfObjects(NODE_SET); }
00604   const char* GetNodeSetArrayName(int index)
00605     { return this->GetObjectName(NODE_SET, index); }
00606   int GetNodeSetArrayStatus(const char* name)
00607     { return this->GetObjectStatus(NODE_SET, name); }
00608   void SetNodeSetArrayStatus(const char* name, int flag)
00609     { this->SetObjectStatus(NODE_SET, name, flag); }
00610   
00611   int GetNumberOfSideSetArrays()
00612     { return this->GetNumberOfObjects(SIDE_SET); }
00613   const char* GetSideSetArrayName(int index)
00614     { return this->GetObjectName(SIDE_SET, index); }
00615   int GetSideSetArrayStatus(const char* name)
00616     { return this->GetObjectStatus(SIDE_SET, name); }
00617   void SetSideSetArrayStatus(const char* name, int flag)
00618     { this->SetObjectStatus(SIDE_SET, name, flag); }
00619   
00620   int GetNumberOfEdgeSetArrays()
00621     { return this->GetNumberOfObjects(EDGE_SET); }
00622   const char* GetEdgeSetArrayName(int index)
00623     { return this->GetObjectName(EDGE_SET, index); }
00624   int GetEdgeSetArrayStatus(const char* name)
00625     { return this->GetObjectStatus(EDGE_SET, name); }
00626   void SetEdgeSetArrayStatus(const char* name, int flag)
00627     { this->SetObjectStatus(EDGE_SET, name, flag); }
00628 
00629   int GetNumberOfFaceSetArrays()
00630     { return this->GetNumberOfObjects(FACE_SET); }
00631   const char* GetFaceSetArrayName(int index)
00632     { return this->GetObjectName(FACE_SET, index); }
00633   int GetFaceSetArrayStatus(const char* name)
00634     { return this->GetObjectStatus(FACE_SET, name); }
00635   void SetFaceSetArrayStatus(const char* name, int flag)
00636     { this->SetObjectStatus(FACE_SET, name, flag); }
00637   
00638   int GetNumberOfElementSetArrays()
00639     { return this->GetNumberOfObjects(ELEM_SET); }
00640   const char* GetElementSetArrayName(int index)
00641     { return this->GetObjectName(ELEM_SET, index); }
00642   int GetElementSetArrayStatus(const char* name)
00643     { return this->GetObjectStatus(ELEM_SET, name); }
00644   void SetElementSetArrayStatus(const char* name, int flag)
00645     { this->SetObjectStatus(ELEM_SET, name, flag); }
00646   
00647   
00648   int GetNumberOfNodeSetResultArrays()
00649     { return this->GetNumberOfObjectArrays(NODE_SET); }
00650   const char* GetNodeSetResultArrayName(int index)
00651     { return this->GetObjectArrayName(NODE_SET, index); }
00652   int GetNodeSetResultArrayStatus(const char* name)
00653     { return this->GetObjectArrayStatus(NODE_SET, name); }
00654   void SetNodeSetResultArrayStatus(const char* name, int flag)
00655     { this->SetObjectArrayStatus(NODE_SET, name, flag); }
00656   
00657   int GetNumberOfSideSetResultArrays()
00658     { return this->GetNumberOfObjectArrays(SIDE_SET); }
00659   const char* GetSideSetResultArrayName(int index)
00660     { return this->GetObjectArrayName(SIDE_SET, index); }
00661   int GetSideSetResultArrayStatus(const char* name)
00662     { return this->GetObjectArrayStatus(SIDE_SET, name); }
00663   void SetSideSetResultArrayStatus(const char* name, int flag)
00664     { this->SetObjectArrayStatus(SIDE_SET, name, flag); }
00665   
00666   int GetNumberOfEdgeSetResultArrays()
00667     { return this->GetNumberOfObjectArrays(EDGE_SET); }
00668   const char* GetEdgeSetResultArrayName(int index)
00669     { return this->GetObjectArrayName(EDGE_SET, index); }
00670   int GetEdgeSetResultArrayStatus(const char* name)
00671     { return this->GetObjectArrayStatus(EDGE_SET, name); }
00672   void SetEdgeSetResultArrayStatus(const char* name, int flag)
00673     { this->SetObjectArrayStatus(EDGE_SET, name, flag); }
00674 
00675   int GetNumberOfFaceSetResultArrays()
00676     { return this->GetNumberOfObjectArrays(FACE_SET); }
00677   const char* GetFaceSetResultArrayName(int index)
00678     { return this->GetObjectArrayName(FACE_SET, index); }
00679   int GetFaceSetResultArrayStatus(const char* name)
00680     { return this->GetObjectArrayStatus(FACE_SET, name); }
00681   void SetFaceSetResultArrayStatus(const char* name, int flag)
00682     { this->SetObjectArrayStatus(FACE_SET, name, flag); }
00683   
00684   int GetNumberOfElementSetResultArrays()
00685     { return this->GetNumberOfObjectArrays(ELEM_SET); }
00686   const char* GetElementSetResultArrayName(int index)
00687     { return this->GetObjectArrayName(ELEM_SET, index); }
00688   int GetElementSetResultArrayStatus(const char* name)
00689     { return this->GetObjectArrayStatus(ELEM_SET, name); }
00690   void SetElementSetResultArrayStatus(const char* name, int flag)
00691     { this->SetObjectArrayStatus(ELEM_SET, name, flag); }
00692 
00705 
00706 
00709   void SetFastPathObjectType(const char *type);
00710   // Description:
00711   // Possible argument values: "INDEX","GLOBAL"
00712   // "GLOBAL" means the id refers to a global id
00713   // "INDEX" means the id refers to an index into the VTK array
00714   void SetFastPathIdType(const char *type);
00715   void SetFastPathObjectId(vtkIdType id);
00717 
00718 
00723   void Reset();
00724 
00730   void ResetSettings();
00731 
00733   void ResetCache();
00734 
00737   virtual void UpdateTimeInformation();
00738 
00739   virtual void Dump();
00740 
00743   vtkGraph* GetSIL();
00744 
00746 
00747   vtkGetMacro(SILUpdateStamp, int);
00749 
00751 
00753   vtkGetMacro(ProducedFastPathOutput, bool);
00755 
00756 protected:
00757   vtkExodusIIReader();
00758   ~vtkExodusIIReader();
00759 
00762   virtual void NewExodusModel();
00763 
00764   // helper for finding IDs
00765   static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );
00766   static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );
00767 
00768   virtual void SetMetadata( vtkExodusIIReaderPrivate* );
00769   vtkGetObjectMacro(Metadata,vtkExodusIIReaderPrivate);
00770 
00776   bool FindXMLFile();
00777 
00778   // Time query function. Called by ExecuteInformation().
00779   // Fills the TimestepValues array.
00780   void GetAllTimes(vtkInformationVector*); 
00781 
00783   void AdvertiseTimeSteps( vtkInformation* outputInfo );
00784 
00785   virtual void SetExodusModel( vtkExodusModel* em );
00786 
00787   int ProcessRequest( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00788   int RequestInformation( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00789   int RequestData( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00790   //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
00791 
00792   // Parameters for controlling what is read in.
00793   char* FileName;
00794   char* XMLFileName;
00795   int TimeStep;
00796   int TimeStepRange[2];
00797   vtkTimeStamp FileNameMTime;
00798   vtkTimeStamp XMLFileNameMTime;
00799   
00800   // Information specific for exodus files.
00801 
00802   //1=display Block names
00803   //2=display Part names
00804   //3=display Material names
00805   int DisplayType;
00806  
00807   // Metadata containing a description of the currently open file.
00808   vtkExodusIIReaderPrivate* Metadata;
00809 
00810   vtkExodusModel *ExodusModel;
00811   int PackExodusModelOntoOutput;
00812   int ExodusModelMetadata;
00813 
00814   int SILUpdateStamp;
00815   bool ProducedFastPathOutput;
00816 private:
00817   vtkExodusIIReader(const vtkExodusIIReader&); // Not implemented
00818   void operator=(const vtkExodusIIReader&); // Not implemented
00819 
00820   void AddDisplacements(vtkUnstructuredGrid* output);
00821 };
00822 
00823 #endif