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