7.1/html/vtkExodusIIReader_8h_source.html

 /*=========================================================================


   Program:   Visualization Toolkit

   Module:    vtkExodusIIReader.h


   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen

   All rights reserved.

   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.


      This software is distributed WITHOUT ANY WARRANTY; without even

      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

      PURPOSE.  See the above copyright notice for more information.


 =========================================================================*/

 /*----------------------------------------------------------------------------

  Copyright (c) Sandia Corporation

  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.

 ----------------------------------------------------------------------------*/


 #ifndef vtkExodusIIReader_h

 #define vtkExodusIIReader_h


 #include "vtkIOExodusModule.h" // For export macro

 #include "vtkMultiBlockDataSetAlgorithm.h"


 class vtkDataArray;

 class vtkDataSet;

 class vtkExodusIICache;

 class vtkExodusIIReaderPrivate;

 class vtkFloatArray;

 class vtkGraph;

 class vtkIntArray;

 class vtkPoints;

 class vtkUnstructuredGrid;


 class VTKIOEXODUS_EXPORT vtkExodusIIReader : public vtkMultiBlockDataSetAlgorithm

 {

 public:

   static vtkExodusIIReader *New();

   vtkTypeMacro(vtkExodusIIReader,vtkMultiBlockDataSetAlgorithm);

   void PrintSelf(ostream& os, vtkIndent indent);


   int CanReadFile(const char* fname);


   //virtual void Modified();


   virtual vtkMTimeType GetMTime();


   virtual vtkMTimeType GetMetadataMTime();


   virtual void SetFileName( const char* fname );

   vtkGetStringMacro(FileName);


   virtual void SetXMLFileName( const char* fname );

   vtkGetStringMacro(XMLFileName);


   vtkSetMacro(TimeStep, int);

   vtkGetMacro(TimeStep, int);


   void SetModeShape(int val)

   {

     this->SetTimeStep(val-1);

   }


   vtkGetVector2Macro(ModeShapesRange, int);


   vtkGetVector2Macro(TimeStepRange,int);


   virtual void SetGenerateObjectIdCellArray( int g );

   int GetGenerateObjectIdCellArray();

   vtkBooleanMacro(GenerateObjectIdCellArray, int);

   static const char *GetObjectIdArrayName() { return "ObjectId"; }


   virtual void SetGenerateGlobalElementIdArray( int g );

   int GetGenerateGlobalElementIdArray();

   vtkBooleanMacro(GenerateGlobalElementIdArray, int);


   virtual void SetGenerateGlobalNodeIdArray( int g );

   int GetGenerateGlobalNodeIdArray();

   vtkBooleanMacro(GenerateGlobalNodeIdArray, int);


   virtual void SetGenerateImplicitElementIdArray( int g );

   int GetGenerateImplicitElementIdArray();

   vtkBooleanMacro(GenerateImplicitElementIdArray, int);


   virtual void SetGenerateImplicitNodeIdArray( int g );

   int GetGenerateImplicitNodeIdArray();

   vtkBooleanMacro(GenerateImplicitNodeIdArray, int);


   virtual void SetGenerateFileIdArray( int f );

   int GetGenerateFileIdArray();

   vtkBooleanMacro(GenerateFileIdArray, int);

   virtual void SetFileId( int f );

   int GetFileId();


   enum {

     SEARCH_TYPE_ELEMENT=0,

     SEARCH_TYPE_NODE,

     SEARCH_TYPE_ELEMENT_THEN_NODE,

     SEARCH_TYPE_NODE_THEN_ELEMENT,

     ID_NOT_FOUND=-234121312

   };

   // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}

   enum ObjectType {

     // match Exodus macros from exodusII.h and exodusII_ext.h

     EDGE_BLOCK = 6,

     FACE_BLOCK = 8,

     ELEM_BLOCK = 1,

     NODE_SET = 2,

     EDGE_SET = 7,

     FACE_SET = 9,

     SIDE_SET = 3,

     ELEM_SET = 10,

     NODE_MAP = 5,

     EDGE_MAP = 11,

     FACE_MAP = 12,

     ELEM_MAP = 4,

     GLOBAL = 13,

     NODAL = 14,

     // extended values (not in Exodus headers) for use with SetAllArrayStatus:

     ASSEMBLY = 60,

     PART = 61,

     MATERIAL = 62,

     HIERARCHY = 63,

     // extended values (not in Exodus headers) for use in cache keys:

     QA_RECORDS = 103,

     INFO_RECORDS = 104,

     GLOBAL_TEMPORAL = 102,

     NODAL_TEMPORAL = 101,

     ELEM_BLOCK_TEMPORAL = 100,

     GLOBAL_CONN = 99,

     ELEM_BLOCK_ELEM_CONN = 98,

     ELEM_BLOCK_FACE_CONN = 97,

     ELEM_BLOCK_EDGE_CONN = 96,

     FACE_BLOCK_CONN = 95,

     EDGE_BLOCK_CONN = 94,

     ELEM_SET_CONN = 93,

     SIDE_SET_CONN = 92,

     FACE_SET_CONN = 91,

     EDGE_SET_CONN = 90,

     NODE_SET_CONN = 89,

     NODAL_COORDS = 88,

     OBJECT_ID = 87,

     IMPLICIT_ELEMENT_ID = 108,

     IMPLICIT_NODE_ID = 107,

     GLOBAL_ELEMENT_ID = 86,

     GLOBAL_NODE_ID = 85,

     ELEMENT_ID = 84,

     NODE_ID = 83,

     NODAL_SQUEEZEMAP = 82,

     ELEM_BLOCK_ATTRIB = 81,

     FACE_BLOCK_ATTRIB = 80,

     EDGE_BLOCK_ATTRIB = 79,

     FACE_ID = 105,

     EDGE_ID = 106,

     ENTITY_COUNTS = 109

   };


   static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }

   static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }

   static int GetGlobalElementID( vtkDataSet *data, int localID );

   static int GetGlobalElementID ( vtkDataSet *data, int localID,

       int searchType );

   static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }


   static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }

   static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }

   static int GetGlobalFaceID( vtkDataSet *data, int localID );

   static int GetGlobalFaceID ( vtkDataSet *data, int localID,

       int searchType );

   static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }


   static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }

   static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }

   static int GetGlobalEdgeID( vtkDataSet *data, int localID );

   static int GetGlobalEdgeID ( vtkDataSet *data, int localID,

       int searchType );

   static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }


   static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }

   static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }

   static int GetGlobalNodeID( vtkDataSet *data, int localID );

   static int GetGlobalNodeID( vtkDataSet *data, int localID,

       int searchType );

   static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }


   static const char* GetSideSetSourceElementIdArrayName() { return "SourceElementId"; }


   static const char* GetSideSetSourceElementSideArrayName() { return "SourceElementSide"; }


   virtual void SetApplyDisplacements( int d );

   int GetApplyDisplacements();

   vtkBooleanMacro(ApplyDisplacements, int);

   virtual void SetDisplacementMagnitude( float s );

   float GetDisplacementMagnitude();


   virtual void SetHasModeShapes( int ms );

   int GetHasModeShapes();

   vtkBooleanMacro(HasModeShapes,int);


   virtual void SetModeShapeTime( double phase );

   double GetModeShapeTime();


   virtual void SetAnimateModeShapes(int flag);

   int GetAnimateModeShapes();

   vtkBooleanMacro(AnimateModeShapes, int);


   const char* GetTitle();

   int GetDimensionality();

   int GetNumberOfTimeSteps();


   int GetNumberOfNodesInFile();

   int GetNumberOfEdgesInFile();

   int GetNumberOfFacesInFile();

   int GetNumberOfElementsInFile();


   int GetObjectTypeFromName( const char* name );

   const char* GetObjectTypeName( int );


   int GetNumberOfNodes();

   int GetNumberOfObjects( int objectType );

   int GetNumberOfEntriesInObject( int objectType, int objectIndex );

   int GetObjectId( int objectType, int objectIndex );

   const char* GetObjectName( int objectType, int objectIndex );

   int GetObjectIndex( int objectType, const char* objectName );

   int GetObjectIndex( int objectType, int id );

   int GetObjectStatus( int objectType, int objectIndex );

   int GetObjectStatus( int objectType, const char* objectName )

     { return this->GetObjectStatus( objectType, this->GetObjectIndex( objectType, objectName ) ); }

   void SetObjectStatus( int objectType, int objectIndex, int status );

   void SetObjectStatus( int objectType, const char* objectName, int status );


   int GetNumberOfObjectArrays( int objectType );

   const char* GetObjectArrayName( int objectType, int arrayIndex );

   int GetObjectArrayIndex( int objectType, const char* arrayName );

   int GetNumberOfObjectArrayComponents( int objectType, int arrayIndex );

   int GetObjectArrayStatus( int objectType, int arrayIndex );

   int GetObjectArrayStatus( int objectType, const char* arrayName )

     { return this->GetObjectArrayStatus( objectType, this->GetObjectArrayIndex( objectType, arrayName ) ); }

   void SetObjectArrayStatus( int objectType, int arrayIndex, int status );

   void SetObjectArrayStatus( int objectType, const char* arrayName, int status );


   int GetNumberOfObjectAttributes( int objectType, int objectIndex );

   const char* GetObjectAttributeName( int objectType, int objectIndex, int attribIndex );

   int GetObjectAttributeIndex( int objectType, int objectIndex, const char* attribName );

   int GetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex );

   int GetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName )

     { return this->GetObjectAttributeStatus( objectType, objectIndex,

       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ) ); }

   void SetObjectAttributeStatus( int objectType, int objectIndex, int attribIndex, int status );

   void SetObjectAttributeStatus( int objectType, int objectIndex, const char* attribName, int status )

     { this->SetObjectAttributeStatus( objectType, objectIndex,

       this->GetObjectAttributeIndex( objectType, objectIndex, attribName ), status ); }


   virtual vtkIdType GetTotalNumberOfNodes();

   virtual vtkIdType GetTotalNumberOfEdges();

   virtual vtkIdType GetTotalNumberOfFaces();

   virtual vtkIdType GetTotalNumberOfElements();


   int GetNumberOfPartArrays();

   const char* GetPartArrayName(int arrayIdx);

   int GetPartArrayID( const char *name );

   const char* GetPartBlockInfo(int arrayIdx);

   void SetPartArrayStatus(int index, int flag);

   void SetPartArrayStatus(const char*, int flag);

   int GetPartArrayStatus(int index);

   int GetPartArrayStatus(const char*);


   int GetNumberOfMaterialArrays();

   const char* GetMaterialArrayName(int arrayIdx);

   int GetMaterialArrayID( const char *name );

   void SetMaterialArrayStatus(int index, int flag);

   void SetMaterialArrayStatus(const char*, int flag);

   int GetMaterialArrayStatus(int index);

   int GetMaterialArrayStatus(const char*);


   int GetNumberOfAssemblyArrays();

   const char* GetAssemblyArrayName(int arrayIdx);

   int GetAssemblyArrayID( const char *name );

   void SetAssemblyArrayStatus(int index, int flag);

   void SetAssemblyArrayStatus(const char*, int flag);

   int GetAssemblyArrayStatus(int index);

   int GetAssemblyArrayStatus(const char*);


   int GetNumberOfHierarchyArrays();

   const char* GetHierarchyArrayName(int arrayIdx);

   void SetHierarchyArrayStatus(int index, int flag);

   void SetHierarchyArrayStatus(const char*, int flag);

   int GetHierarchyArrayStatus(int index);

   int GetHierarchyArrayStatus(const char*);


   vtkGetMacro(DisplayType,int);

   virtual void SetDisplayType(int type);


   int IsValidVariable( const char *type, const char *name );


   int GetVariableID ( const char *type, const char *name );


   void SetAllArrayStatus( int otype, int status );

   // Helper functions

   //static int StringsEqual(const char* s1, char* s2);

   //static void StringUppercase(const char* str, char* upperstr);

   //static char *StrDupWithNew(const char *s);


   // time series query functions

   int GetTimeSeriesData( int ID, const char *vName, const char *vType,

                          vtkFloatArray *result );


   int GetNumberOfEdgeBlockArrays()

     { return this->GetNumberOfObjects(EDGE_BLOCK); }

   const char* GetEdgeBlockArrayName(int index)

     { return this->GetObjectName(EDGE_BLOCK, index); }

   int GetEdgeBlockArrayStatus(const char* name)

     { return this->GetObjectStatus(EDGE_BLOCK, name); }

   void SetEdgeBlockArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(EDGE_BLOCK, name, flag); }


   int GetNumberOfFaceBlockArrays()

     { return this->GetNumberOfObjects(FACE_BLOCK); }

   const char* GetFaceBlockArrayName(int index)

     { return this->GetObjectName(FACE_BLOCK, index); }

   int GetFaceBlockArrayStatus(const char* name)

     { return this->GetObjectStatus(FACE_BLOCK, name); }

   void SetFaceBlockArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(FACE_BLOCK, name, flag); }


   int GetNumberOfElementBlockArrays()

     { return this->GetNumberOfObjects(ELEM_BLOCK); }

   const char* GetElementBlockArrayName(int index)

     { return this->GetObjectName(ELEM_BLOCK, index); }

   int GetElementBlockArrayStatus(const char* name)

     { return this->GetObjectStatus(ELEM_BLOCK, name); }

   void SetElementBlockArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(ELEM_BLOCK, name, flag); }


   int GetNumberOfGlobalResultArrays()

     { return this->GetNumberOfObjectArrays(GLOBAL); }

   const char* GetGlobalResultArrayName(int index)

     { return this->GetObjectArrayName(GLOBAL, index); }

   int GetGlobalResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(GLOBAL, name); }

   void SetGlobalResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(GLOBAL, name, flag); }


   int GetNumberOfPointResultArrays()

     { return this->GetNumberOfObjectArrays(NODAL); }

   const char* GetPointResultArrayName(int index)

     { return this->GetObjectArrayName(NODAL, index); }

   int GetPointResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(NODAL, name); }

   void SetPointResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(NODAL, name, flag); }


   int GetNumberOfEdgeResultArrays()

     { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }

   const char* GetEdgeResultArrayName(int index)

     { return this->GetObjectArrayName(EDGE_BLOCK, index); }

   int GetEdgeResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(EDGE_BLOCK, name); }

   void SetEdgeResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(EDGE_BLOCK, name, flag); }


   int GetNumberOfFaceResultArrays()

     { return this->GetNumberOfObjectArrays(FACE_BLOCK); }

   const char* GetFaceResultArrayName(int index)

     { return this->GetObjectArrayName(FACE_BLOCK, index); }

   int GetFaceResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(FACE_BLOCK, name); }

   void SetFaceResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(FACE_BLOCK, name, flag); }


   int GetNumberOfElementResultArrays()

     { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }

   const char* GetElementResultArrayName(int index)

     { return this->GetObjectArrayName(ELEM_BLOCK, index); }

   int GetElementResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(ELEM_BLOCK, name); }

   void SetElementResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(ELEM_BLOCK, name, flag); }


   int GetNumberOfNodeMapArrays()

     { return this->GetNumberOfObjects(NODE_MAP); }

   const char* GetNodeMapArrayName(int index)

     { return this->GetObjectName(NODE_MAP, index); }

   int GetNodeMapArrayStatus(const char* name)

     { return this->GetObjectStatus(NODE_MAP, name); }

   void SetNodeMapArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(NODE_MAP, name, flag); }


   int GetNumberOfEdgeMapArrays()

     { return this->GetNumberOfObjects(EDGE_MAP); }

   const char* GetEdgeMapArrayName(int index)

     { return this->GetObjectName(EDGE_MAP, index); }

   int GetEdgeMapArrayStatus(const char* name)

     { return this->GetObjectStatus(EDGE_MAP, name); }

   void SetEdgeMapArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(EDGE_MAP, name, flag); }


   int GetNumberOfFaceMapArrays()

     { return this->GetNumberOfObjects(FACE_MAP); }

   const char* GetFaceMapArrayName(int index)

     { return this->GetObjectName(FACE_MAP, index); }

   int GetFaceMapArrayStatus(const char* name)

     { return this->GetObjectStatus(FACE_MAP, name); }

   void SetFaceMapArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(FACE_MAP, name, flag); }


   int GetNumberOfElementMapArrays()

     { return this->GetNumberOfObjects(ELEM_MAP); }

   const char* GetElementMapArrayName(int index)

     { return this->GetObjectName(ELEM_MAP, index); }

   int GetElementMapArrayStatus(const char* name)

     { return this->GetObjectStatus(ELEM_MAP, name); }

   void SetElementMapArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(ELEM_MAP, name, flag); }


   int GetNumberOfNodeSetArrays()

     { return this->GetNumberOfObjects(NODE_SET); }

   const char* GetNodeSetArrayName(int index)

     { return this->GetObjectName(NODE_SET, index); }

   int GetNodeSetArrayStatus(const char* name)

     { return this->GetObjectStatus(NODE_SET, name); }

   void SetNodeSetArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(NODE_SET, name, flag); }


   int GetNumberOfSideSetArrays()

     { return this->GetNumberOfObjects(SIDE_SET); }

   const char* GetSideSetArrayName(int index)

     { return this->GetObjectName(SIDE_SET, index); }

   int GetSideSetArrayStatus(const char* name)

     { return this->GetObjectStatus(SIDE_SET, name); }

   void SetSideSetArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(SIDE_SET, name, flag); }


   int GetNumberOfEdgeSetArrays()

     { return this->GetNumberOfObjects(EDGE_SET); }

   const char* GetEdgeSetArrayName(int index)

     { return this->GetObjectName(EDGE_SET, index); }

   int GetEdgeSetArrayStatus(const char* name)

     { return this->GetObjectStatus(EDGE_SET, name); }

   void SetEdgeSetArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(EDGE_SET, name, flag); }


   int GetNumberOfFaceSetArrays()

     { return this->GetNumberOfObjects(FACE_SET); }

   const char* GetFaceSetArrayName(int index)

     { return this->GetObjectName(FACE_SET, index); }

   int GetFaceSetArrayStatus(const char* name)

     { return this->GetObjectStatus(FACE_SET, name); }

   void SetFaceSetArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(FACE_SET, name, flag); }


   int GetNumberOfElementSetArrays()

     { return this->GetNumberOfObjects(ELEM_SET); }

   const char* GetElementSetArrayName(int index)

     { return this->GetObjectName(ELEM_SET, index); }

   int GetElementSetArrayStatus(const char* name)

     { return this->GetObjectStatus(ELEM_SET, name); }

   void SetElementSetArrayStatus(const char* name, int flag)

     { this->SetObjectStatus(ELEM_SET, name, flag); }


   int GetNumberOfNodeSetResultArrays()

     { return this->GetNumberOfObjectArrays(NODE_SET); }

   const char* GetNodeSetResultArrayName(int index)

     { return this->GetObjectArrayName(NODE_SET, index); }

   int GetNodeSetResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(NODE_SET, name); }

   void SetNodeSetResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(NODE_SET, name, flag); }


   int GetNumberOfSideSetResultArrays()

     { return this->GetNumberOfObjectArrays(SIDE_SET); }

   const char* GetSideSetResultArrayName(int index)

     { return this->GetObjectArrayName(SIDE_SET, index); }

   int GetSideSetResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(SIDE_SET, name); }

   void SetSideSetResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(SIDE_SET, name, flag); }


   int GetNumberOfEdgeSetResultArrays()

     { return this->GetNumberOfObjectArrays(EDGE_SET); }

   const char* GetEdgeSetResultArrayName(int index)

     { return this->GetObjectArrayName(EDGE_SET, index); }

   int GetEdgeSetResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(EDGE_SET, name); }

   void SetEdgeSetResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(EDGE_SET, name, flag); }


   int GetNumberOfFaceSetResultArrays()

     { return this->GetNumberOfObjectArrays(FACE_SET); }

   const char* GetFaceSetResultArrayName(int index)

     { return this->GetObjectArrayName(FACE_SET, index); }

   int GetFaceSetResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(FACE_SET, name); }

   void SetFaceSetResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(FACE_SET, name, flag); }


   int GetNumberOfElementSetResultArrays()

     { return this->GetNumberOfObjectArrays(ELEM_SET); }

   const char* GetElementSetResultArrayName(int index)

     { return this->GetObjectArrayName(ELEM_SET, index); }

   int GetElementSetResultArrayStatus(const char* name)

     { return this->GetObjectArrayStatus(ELEM_SET, name); }

   void SetElementSetResultArrayStatus(const char* name, int flag)

     { this->SetObjectArrayStatus(ELEM_SET, name, flag); }


   void Reset();


   void ResetSettings();


   void ResetCache();


   void SetCacheSize(double CacheSize);


   double GetCacheSize();


   void SetSqueezePoints(bool sp);

   bool GetSqueezePoints();


   virtual void Dump();


   vtkGraph* GetSIL();


   vtkGetMacro(SILUpdateStamp, int);


 protected:

   vtkExodusIIReader();

   ~vtkExodusIIReader();


   // helper for finding IDs

   static int GetIDHelper ( const char *arrayName, vtkDataSet *data, int localID, int searchType );

   static int GetGlobalID( const char *arrayName, vtkDataSet *data, int localID, int searchType );


   virtual void SetMetadata( vtkExodusIIReaderPrivate* );

   vtkGetObjectMacro(Metadata,vtkExodusIIReaderPrivate);


   bool FindXMLFile();


   // Time query function. Called by ExecuteInformation().

   // Fills the TimestepValues array.

   void GetAllTimes(vtkInformationVector*);


   void AdvertiseTimeSteps( vtkInformation* outputInfo );


   int ProcessRequest( vtkInformation *, vtkInformationVector **, vtkInformationVector *);

   int RequestInformation( vtkInformation *, vtkInformationVector **, vtkInformationVector *);

   int RequestData( vtkInformation *, vtkInformationVector **, vtkInformationVector *);

   //int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);


   // Parameters for controlling what is read in.

   char* FileName;

   char* XMLFileName;

   int TimeStep;

   int TimeStepRange[2];

   vtkTimeStamp FileNameMTime;

   vtkTimeStamp XMLFileNameMTime;


   // Information specific for exodus files.


   //1=display Block names

   //2=display Part names

   //3=display Material names

   int DisplayType;


   // Metadata containing a description of the currently open file.

   vtkExodusIIReaderPrivate* Metadata;


   int SILUpdateStamp;


   friend class vtkPExodusIIReader;

 private:

   vtkExodusIIReader(const vtkExodusIIReader&) VTK_DELETE_FUNCTION;

   void operator=(const vtkExodusIIReader&) VTK_DELETE_FUNCTION;


   void AddDisplacements(vtkUnstructuredGrid* output);

   int ModeShapesRange[2];

 };


 #endif

vtkExodusIIReader::GetEdgeResultArrayName
const char * GetEdgeResultArrayName(int index)
Definition: vtkExodusIIReader.h:555

vtkX3D::data
Definition: vtkX3D.h:315

vtkExodusIIReader::GetGlobalNodeIdArrayName
static const char * GetGlobalNodeIdArrayName()
Extra point data array that can be generated.
Definition: vtkExodusIIReader.h:273

vtkExodusIIReader::vtkExodusIIReader
vtkExodusIIReader()

vtkExodusIIReader::GetSideSetResultArrayName
const char * GetSideSetResultArrayName(int index)
Definition: vtkExodusIIReader.h:674

vtkExodusIIReader::GetNumberOfElementSetArrays
int GetNumberOfElementSetArrays()
Definition: vtkExodusIIReader.h:653

vtkExodusIIReader::GetImplicitElementIdArrayName
static const char * GetImplicitElementIdArrayName()
Definition: vtkExodusIIReader.h:250

vtkExodusIIReader::GetEdgeSetArrayName
const char * GetEdgeSetArrayName(int index)
Definition: vtkExodusIIReader.h:637

vtkExodusIIReader::SetElementSetResultArrayStatus
void SetElementSetResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:705

vtkExodusIIReader::GetNumberOfGlobalResultArrays
int GetNumberOfGlobalResultArrays()
Definition: vtkExodusIIReader.h:535

vtkExodusIIReader::GetFaceMapArrayStatus
int GetFaceMapArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:603

vtkExodusIIReader::GetEdgeSetResultArrayName
const char * GetEdgeSetResultArrayName(int index)
Definition: vtkExodusIIReader.h:683

vtkExodusIIReader::SetEdgeResultArrayStatus
void SetEdgeResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:559

vtkX3D::type
Definition: vtkX3D.h:516

vtkExodusIIReader::SetNodeSetArrayStatus
void SetNodeSetArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:623

vtkExodusIIReader::GetNumberOfElementMapArrays
int GetNumberOfElementMapArrays()
Definition: vtkExodusIIReader.h:608

vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:86

vtkExodusIIReader::GetEdgeBlockArrayName
const char * GetEdgeBlockArrayName(int index)
Definition: vtkExodusIIReader.h:510

vtkExodusIIReader::SetNodeMapArrayStatus
void SetNodeMapArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:587

vtkExodusIIReader::GetNumberOfEdgeMapArrays
int GetNumberOfEdgeMapArrays()
Definition: vtkExodusIIReader.h:590

vtkExodusIIReader::SetEdgeSetResultArrayStatus
void SetEdgeSetResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:687

vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62

vtkExodusIIReader::GetGlobalResultArrayStatus
int GetGlobalResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:539

vtkExodusIIReader::GetImplicitFaceIdArrayName
static const char * GetImplicitFaceIdArrayName()
Definition: vtkExodusIIReader.h:257

vtkExodusIIReader::GetEdgeSetResultArrayStatus
int GetEdgeSetResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:685

vtkExodusIIReader::GetNodeSetArrayName
const char * GetNodeSetArrayName(int index)
Definition: vtkExodusIIReader.h:619

vtkExodusIIReader::SetEdgeBlockArrayStatus
void SetEdgeBlockArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:514

vtkExodusIIReader::SetNodeSetResultArrayStatus
void SetNodeSetResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:669

vtkExodusIIReader::SetSideSetArrayStatus
void SetSideSetArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:632

vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:35

vtkExodusIIReader::GetElementSetResultArrayStatus
int GetElementSetResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:703

vtkExodusIIReader::GetElementBlockArrayStatus
int GetElementBlockArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:530

vtkExodusIIReader::GetElementSetArrayName
const char * GetElementSetArrayName(int index)
Definition: vtkExodusIIReader.h:655

vtkExodusIIReader::GetNumberOfFaceSetArrays
int GetNumberOfFaceSetArrays()
Definition: vtkExodusIIReader.h:644

vtkFloatArray
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:41

vtkExodusIIReader::GetNumberOfFaceSetResultArrays
int GetNumberOfFaceSetResultArrays()
Definition: vtkExodusIIReader.h:690

vtkExodusIIReader::GetFaceSetResultArrayName
const char * GetFaceSetResultArrayName(int index)
Definition: vtkExodusIIReader.h:692

vtkExodusIIReader::GetFaceSetArrayName
const char * GetFaceSetArrayName(int index)
Definition: vtkExodusIIReader.h:646

vtkExodusIIReader::GetNumberOfEdgeSetResultArrays
int GetNumberOfEdgeSetResultArrays()
Definition: vtkExodusIIReader.h:681

vtkExodusIIReader::GetNumberOfElementResultArrays
int GetNumberOfElementResultArrays()
Definition: vtkExodusIIReader.h:571

vtkExodusIIReader::GetElementResultArrayStatus
int GetElementResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:575

vtkMultiBlockDataSetAlgorithm::ProcessRequest
int ProcessRequest(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
see vtkAlgorithm for details

vtkExodusIIReader::SetElementResultArrayStatus
void SetElementResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:577

vtkExodusIIReader::GetEdgeResultArrayStatus
int GetEdgeResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:557

vtkExodusIIReader::ObjectType
ObjectType
Extra cell data array that can be generated.
Definition: vtkExodusIIReader.h:189

vtkIdType
int vtkIdType
Definition: vtkType.h:287

vtkExodusIIReaderPrivate
This class holds metadata for an Exodus file.
Definition: vtkExodusIIReaderPrivate.h:22

vtkExodusIIReader::GetNumberOfEdgeResultArrays
int GetNumberOfEdgeResultArrays()
Definition: vtkExodusIIReader.h:553

vtkMultiBlockDataSetAlgorithm
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
Definition: vtkMultiBlockDataSetAlgorithm.h:32

vtkExodusIIReader::SetPointResultArrayStatus
void SetPointResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:550

vtkExodusIIReader::GetNumberOfEdgeSetArrays
int GetNumberOfEdgeSetArrays()
Definition: vtkExodusIIReader.h:635

vtkExodusIIReader::SILUpdateStamp
int SILUpdateStamp
Definition: vtkExodusIIReader.h:829

vtkMultiBlockDataSetAlgorithm::RequestData
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
Definition: vtkMultiBlockDataSetAlgorithm.h:88

vtkExodusIIReader::GetEdgeMapArrayName
const char * GetEdgeMapArrayName(int index)
Definition: vtkExodusIIReader.h:592

vtkExodusIIReader::GetNodeSetResultArrayStatus
int GetNodeSetResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:667

vtkExodusIIReader::SetFaceBlockArrayStatus
void SetFaceBlockArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:523

vtkMTimeType
vtkTypeUInt64 vtkMTimeType
Definition: vtkType.h:248

vtkExodusIIReader::GetGlobalResultArrayName
const char * GetGlobalResultArrayName(int index)
Definition: vtkExodusIIReader.h:537

vtkExodusIIReader::GetNumberOfSideSetResultArrays
int GetNumberOfSideSetResultArrays()
Definition: vtkExodusIIReader.h:672

vtkExodusIIReader::GetElementSetArrayStatus
int GetElementSetArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:657

vtkMultiBlockDataSetAlgorithm::New
static vtkMultiBlockDataSetAlgorithm * New()

vtkExodusIIReader::GetImplicitNodeIdArrayName
static const char * GetImplicitNodeIdArrayName()
Extra point data array that can be generated.
Definition: vtkExodusIIReader.h:278

vtkExodusIIReader::FileName
char * FileName
Definition: vtkExodusIIReader.h:812

vtkExodusIIReader::GetNumberOfPointResultArrays
int GetNumberOfPointResultArrays()
Definition: vtkExodusIIReader.h:544

vtkGraph
Base class for graph data types.
Definition: vtkGraph.h:287

vtkX3D::name
Definition: vtkX3D.h:219

vtkExodusIIReader::GetNodeSetArrayStatus
int GetNodeSetArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:621

vtkMultiBlockDataSetAlgorithm.h

vtkIntArray
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:45

vtkExodusIIReader::SetEdgeMapArrayStatus
void SetEdgeMapArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:596

vtkExodusIIReader::GetNumberOfNodeSetResultArrays
int GetNumberOfNodeSetResultArrays()
Definition: vtkExodusIIReader.h:663

vtkExodusIIReader::GetSideSetArrayStatus
int GetSideSetArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:630

vtkExodusIIReader::DisplayType
int DisplayType
Definition: vtkExodusIIReader.h:824

vtkExodusIIReader::GetNodeSetResultArrayName
const char * GetNodeSetResultArrayName(int index)
Definition: vtkExodusIIReader.h:665

vtkExodusIIReader::GetElementMapArrayName
const char * GetElementMapArrayName(int index)
Definition: vtkExodusIIReader.h:610

vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:39

vtkExodusIIReader::SetElementSetArrayStatus
void SetElementSetArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:659

vtkExodusIIReader::GetNumberOfFaceBlockArrays
int GetNumberOfFaceBlockArrays()
Definition: vtkExodusIIReader.h:517

vtkExodusIIReader::GetObjectIdArrayName
static const char * GetObjectIdArrayName()
Extra cell data array that can be generated.
Definition: vtkExodusIIReader.h:149

vtkExodusIIReader::XMLFileName
char * XMLFileName
Definition: vtkExodusIIReader.h:813

vtkPExodusIIReader
Read Exodus II files (.exii)
Definition: vtkPExodusIIReader.h:50

vtkExodusIICache
Definition: vtkExodusIICache.h:127

vtkExodusIIReader::GetElementMapArrayStatus
int GetElementMapArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:612

vtkExodusIIReader::GetSideSetSourceElementIdArrayName
static const char * GetSideSetSourceElementIdArrayName()
Get the name of the array that stores the mapping from side set cells back to the global id of the el...
Definition: vtkExodusIIReader.h:285

vtkExodusIIReader::GetNodeMapArrayName
const char * GetNodeMapArrayName(int index)
Definition: vtkExodusIIReader.h:583

vtkUnstructuredGrid
dataset represents arbitrary combinations of all possible cell types
Definition: vtkUnstructuredGrid.h:81

vtkExodusIIReader::SetFaceSetArrayStatus
void SetFaceSetArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:650

vtkExodusIIReader::GetNumberOfFaceMapArrays
int GetNumberOfFaceMapArrays()
Definition: vtkExodusIIReader.h:599

vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54

vtkObject::GetMTime
virtual vtkMTimeType GetMTime()
Return this object's modified time.

vtkExodusIIReader::SetFaceMapArrayStatus
void SetFaceMapArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:605

vtkExodusIIReader::XMLFileNameMTime
vtkTimeStamp XMLFileNameMTime
Definition: vtkExodusIIReader.h:817

vtkExodusIIReader::GetGlobalEdgeIdArrayName
static const char * GetGlobalEdgeIdArrayName()
Definition: vtkExodusIIReader.h:259

vtkExodusIIReader::GetGlobalFaceIdArrayName
static const char * GetGlobalFaceIdArrayName()
Definition: vtkExodusIIReader.h:252

vtkExodusIIReader::GetNumberOfEdgeBlockArrays
int GetNumberOfEdgeBlockArrays()
Definition: vtkExodusIIReader.h:508

vtkExodusIIReader::GetPedigreeFaceIdArrayName
static const char * GetPedigreeFaceIdArrayName()
Definition: vtkExodusIIReader.h:253

vtkGetStringMacro
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.

vtkExodusIIReader::GetEdgeBlockArrayStatus
int GetEdgeBlockArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:512

vtkExodusIIReader::GetObjectArrayStatus
int GetObjectArrayStatus(int objectType, const char *arrayName)
By default arrays are not loaded.
Definition: vtkExodusIIReader.h:385

vtkExodusIIReader::GetPedigreeElementIdArrayName
static const char * GetPedigreeElementIdArrayName()
Definition: vtkExodusIIReader.h:246

vtkMultiBlockDataSetAlgorithm::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.

vtkExodusIIReader::GetFaceBlockArrayName
const char * GetFaceBlockArrayName(int index)
Definition: vtkExodusIIReader.h:519

vtkExodusIIReader::GetPedigreeNodeIdArrayName
static const char * GetPedigreeNodeIdArrayName()
Extra point data array that can be generated.
Definition: vtkExodusIIReader.h:274

vtkExodusIIReader::GetElementResultArrayName
const char * GetElementResultArrayName(int index)
Definition: vtkExodusIIReader.h:573

vtkSetMacro
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.

vtkExodusIIReader::SetSideSetResultArrayStatus
void SetSideSetResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:678

vtkExodusIIReader::SEARCH_TYPE_NODE_THEN_ELEMENT
Definition: vtkExodusIIReader.h:185

vtkExodusIIReader::GetEdgeSetArrayStatus
int GetEdgeSetArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:639

vtkExodusIIReader::GetFaceResultArrayName
const char * GetFaceResultArrayName(int index)
Definition: vtkExodusIIReader.h:564

vtkExodusIIReader::SEARCH_TYPE_ELEMENT_THEN_NODE
Definition: vtkExodusIIReader.h:184

vtkExodusIIReader::SEARCH_TYPE_NODE
Definition: vtkExodusIIReader.h:183

vtkExodusIIReader::GetNumberOfElementSetResultArrays
int GetNumberOfElementSetResultArrays()
Definition: vtkExodusIIReader.h:699

vtkExodusIIReader::GetSideSetArrayName
const char * GetSideSetArrayName(int index)
Definition: vtkExodusIIReader.h:628

vtkExodusIIReader::GetNodeMapArrayStatus
int GetNodeMapArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:585

vtkExodusIIReader::GetPedigreeEdgeIdArrayName
static const char * GetPedigreeEdgeIdArrayName()
Definition: vtkExodusIIReader.h:260

vtkExodusIIReader
Read exodus 2 files .ex2.
Definition: vtkExodusIIReader.h:56

vtkExodusIIReader::GetFaceSetResultArrayStatus
int GetFaceSetResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:694

vtkExodusIIReader::GetImplicitEdgeIdArrayName
static const char * GetImplicitEdgeIdArrayName()
Definition: vtkExodusIIReader.h:264

vtkExodusIIReader::SetGlobalResultArrayStatus
void SetGlobalResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:541

vtkExodusIIReader::GetEdgeMapArrayStatus
int GetEdgeMapArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:594

vtkExodusIIReader::GetObjectStatus
int GetObjectStatus(int objectType, const char *objectName)
Definition: vtkExodusIIReader.h:368

vtkExodusIIReader::SetElementBlockArrayStatus
void SetElementBlockArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:532

vtkExodusIIReader::GetObjectAttributeStatus
int GetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName)
By default attributes are not loaded.
Definition: vtkExodusIIReader.h:402

vtkExodusIIReader::SetObjectAttributeStatus
void SetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName, int status)
By default attributes are not loaded.
Definition: vtkExodusIIReader.h:406

vtkExodusIIReader::GetPointResultArrayStatus
int GetPointResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:548

vtkExodusIIReader::GetFaceMapArrayName
const char * GetFaceMapArrayName(int index)
Definition: vtkExodusIIReader.h:601

vtkExodusIIReader::SetModeShape
void SetModeShape(int val)
Convenience method to set the mode-shape which is same as this->SetTimeStep(val-1);.
Definition: vtkExodusIIReader.h:110

vtkExodusIIReader::SetFaceResultArrayStatus
void SetFaceResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:568

vtkExodusIIReader::GetFaceBlockArrayStatus
int GetFaceBlockArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:521

vtkExodusIIReader::GetPointResultArrayName
const char * GetPointResultArrayName(int index)
Definition: vtkExodusIIReader.h:546

vtkExodusIIReader::GetSideSetResultArrayStatus
int GetSideSetResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:676

vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:41

vtkBooleanMacro
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.

vtkExodusIIReader::GetNumberOfSideSetArrays
int GetNumberOfSideSetArrays()
Definition: vtkExodusIIReader.h:626

vtkExodusIIReader::GetElementBlockArrayName
const char * GetElementBlockArrayName(int index)
Definition: vtkExodusIIReader.h:528

vtkX3D::index
Definition: vtkX3D.h:246

vtkExodusIIReader::GetFaceSetArrayStatus
int GetFaceSetArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:648

vtkExodusIIReader::SetElementMapArrayStatus
void SetElementMapArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:614

vtkExodusIIReader::GetGlobalElementIdArrayName
static const char * GetGlobalElementIdArrayName()
Definition: vtkExodusIIReader.h:245

vtkExodusIIReader::SetFaceSetResultArrayStatus
void SetFaceSetResultArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:696

vtkExodusIIReader::GetNumberOfElementBlockArrays
int GetNumberOfElementBlockArrays()
Definition: vtkExodusIIReader.h:526

vtkExodusIIReader::GetSideSetSourceElementSideArrayName
static const char * GetSideSetSourceElementSideArrayName()
Get the name of the array that stores the mapping from side set cells back to the canonical side of t...
Definition: vtkExodusIIReader.h:291

vtkExodusIIReader::GetNumberOfFaceResultArrays
int GetNumberOfFaceResultArrays()
Definition: vtkExodusIIReader.h:562

vtkExodusIIReader::TimeStep
int TimeStep
Definition: vtkExodusIIReader.h:814

vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:39

vtkExodusIIReader::GetElementSetResultArrayName
const char * GetElementSetResultArrayName(int index)
Definition: vtkExodusIIReader.h:701

vtkExodusIIReader::GetNumberOfNodeMapArrays
int GetNumberOfNodeMapArrays()
Definition: vtkExodusIIReader.h:581

vtkExodusIIReader::GetNumberOfNodeSetArrays
int GetNumberOfNodeSetArrays()
Definition: vtkExodusIIReader.h:617

vtkExodusIIReader::SetEdgeSetArrayStatus
void SetEdgeSetArrayStatus(const char *name, int flag)
Definition: vtkExodusIIReader.h:641

vtkExodusIIReader::Metadata
vtkExodusIIReaderPrivate * Metadata
Definition: vtkExodusIIReader.h:827

vtkMultiBlockDataSetAlgorithm::RequestInformation
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
Definition: vtkMultiBlockDataSetAlgorithm.h:80

vtkExodusIIReader::GetFaceResultArrayStatus
int GetFaceResultArrayStatus(const char *name)
Definition: vtkExodusIIReader.h:566

vtkExodusIIReader::FileNameMTime
vtkTimeStamp FileNameMTime
Definition: vtkExodusIIReader.h:816