vtkExodusIIReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright (c) Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause

#ifndef vtkExodusIIReader_h
#define vtkExodusIIReader_h

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

VTK_ABI_NAMESPACE_BEGIN
class vtkDataArray;
class vtkDataSet;
class vtkExodusIICache;
class vtkExodusIIReaderPrivate;
class vtkFloatArray;
class vtkGraph;
class vtkInformationIntegerKey;
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) override;

  virtual int CanReadFile(VTK_FILEPATH const char* fname);

  // virtual void Modified();

  vtkMTimeType GetMTime() override;

  virtual vtkMTimeType GetMetadataMTime();


  virtual void SetFileName(VTK_FILEPATH const char* fname);
  vtkGetFilePathMacro(FileName);


  virtual void SetXMLFileName(VTK_FILEPATH const char* fname);
  vtkGetFilePathMacro(XMLFileName);


  vtkSetMacro(TimeStep, int);
  vtkGetMacro(TimeStep, int);

  void SetModeShape(int val) { this->SetTimeStep(val - 1); }


  vtkGetVector2Macro(ModeShapesRange, int);


  vtkGetVector2Macro(TimeStepRange, int);


  virtual void SetGenerateObjectIdCellArray(vtkTypeBool g);
  vtkTypeBool GetGenerateObjectIdCellArray();
  vtkBooleanMacro(GenerateObjectIdCellArray, vtkTypeBool);
  static const char* GetObjectIdArrayName() { return "ObjectId"; }

  virtual void SetGenerateGlobalElementIdArray(vtkTypeBool g);
  vtkTypeBool GetGenerateGlobalElementIdArray();
  vtkBooleanMacro(GenerateGlobalElementIdArray, vtkTypeBool);

  virtual void SetGenerateGlobalNodeIdArray(vtkTypeBool g);
  vtkTypeBool GetGenerateGlobalNodeIdArray();
  vtkBooleanMacro(GenerateGlobalNodeIdArray, vtkTypeBool);

  virtual void SetGenerateImplicitElementIdArray(vtkTypeBool g);
  vtkTypeBool GetGenerateImplicitElementIdArray();
  vtkBooleanMacro(GenerateImplicitElementIdArray, vtkTypeBool);

  virtual void SetGenerateImplicitNodeIdArray(vtkTypeBool g);
  vtkTypeBool GetGenerateImplicitNodeIdArray();
  vtkBooleanMacro(GenerateImplicitNodeIdArray, vtkTypeBool);

  virtual void SetGenerateFileIdArray(vtkTypeBool f);
  vtkTypeBool GetGenerateFileIdArray();
  vtkBooleanMacro(GenerateFileIdArray, vtkTypeBool);

  virtual void SetFileId(int f);
  int GetFileId();


  // NOLINTNEXTLINE(readability-enum-initial-value)
  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(vtkTypeBool d);
  vtkTypeBool GetApplyDisplacements();
  vtkBooleanMacro(ApplyDisplacements, vtkTypeBool);
  virtual void SetDisplacementMagnitude(float s);
  float GetDisplacementMagnitude();


  virtual void SetHasModeShapes(vtkTypeBool ms);
  vtkTypeBool GetHasModeShapes();
  vtkBooleanMacro(HasModeShapes, vtkTypeBool);


  virtual void SetModeShapeTime(double phase);
  double GetModeShapeTime();


  virtual void SetAnimateModeShapes(vtkTypeBool flag);
  vtkTypeBool GetAnimateModeShapes();
  vtkBooleanMacro(AnimateModeShapes, vtkTypeBool);


  virtual void SetIgnoreFileTime(bool flag);
  bool GetIgnoreFileTime();
  vtkBooleanMacro(IgnoreFileTime, bool);


  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);
  using Superclass::GetObjectName;
  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);


  int GetMaxNameLength();


  static vtkInformationIntegerKey* GLOBAL_VARIABLE();
  static vtkInformationIntegerKey* GLOBAL_TEMPORAL_VARIABLE();


  vtkSetMacro(UseLegacyBlockNames, bool);
  vtkGetMacro(UseLegacyBlockNames, bool);
  vtkBooleanMacro(UseLegacyBlockNames, bool);
protected:
  vtkExodusIIReader();
  ~vtkExodusIIReader() override;

  // 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);

  vtkTypeBool ProcessRequest(
    vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  // 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&) = delete;
  void operator=(const vtkExodusIIReader&) = delete;

  void AddDisplacements(vtkUnstructuredGrid* output);
  int ModeShapesRange[2];

  bool UseLegacyBlockNames;
};

VTK_ABI_NAMESPACE_END
#endif