vtkExodusIIReaderPrivate.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkExodusIIReaderPrivate_h
#define vtkExodusIIReaderPrivate_h
 
// Do not include this file directly. It is only for use
// from inside the ExodusII reader and its descendants.
 
#include "vtkExodusIICache.h"  // for vtkExodusIICacheKey
#include "vtkExodusIIReader.h" // for vtkExodusIIReader
#include "vtkObject.h"
#include "vtkStdString.h"               // for vtkStdString
#include "vtksys/RegularExpression.hxx" // for vtksys::RegularExpression
 
#include <map>    // for std::map
#include <vector> // for std::vector
 
#include "vtkIOExodusModule.h" // For export macro
#include "vtk_exodusII.h"      // for exodus APIs
VTK_ABI_NAMESPACE_BEGIN
class vtkDataArray;
class vtkExodusIIReaderParser;
class vtkIdTypeArray;
class vtkMultiBlockDataSet;
class vtkMutableDirectedGraph;
class vtkTypeInt64Array;
class vtkUnstructuredGrid;
 
class VTKIOEXODUS_EXPORT vtkExodusIIReaderPrivate : public vtkObject
{
public:
  static vtkExodusIIReaderPrivate* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
  vtkTypeMacro(vtkExodusIIReaderPrivate, vtkObject);
  // virtual void Modified();
 
  int OpenFile(const char* filename);
 
  int CloseFile();
 
  int RequestInformation();
 
  vtkMutableDirectedGraph* GetSIL() { return this->SIL; }
 
  int RequestData(vtkIdType timeStep, vtkMultiBlockDataSet* output);
 
  int SetUpEmptyGrid(vtkMultiBlockDataSet* output);
 
  void Reset();
 
  void ResetSettings();
 
  void ResetCache();
 
  void SetCacheSize(double size);
 
  vtkGetMacro(CacheSize, double);
 
  int GetNumberOfTimeSteps() { return (int)this->Times.size(); }
 
  vtkGetMacro(SqueezePoints, int);
 
  void SetSqueezePoints(int sp);
 
  vtkBooleanMacro(SqueezePoints, int);
 
  int GetNumberOfNodes();
 
  int GetNumberOfObjectsOfType(int otype);
 
  int GetNumberOfObjectArraysOfType(int otype);
 
  const char* GetObjectName(int otype, int i);
  using Superclass::GetObjectName;
 
  int GetObjectId(int otype, int i);
 
  int GetObjectSize(int otype, int i);
 
  int GetObjectStatus(int otype, int i);
 
  int GetUnsortedObjectStatus(int otype, int i);
 
  void SetObjectStatus(int otype, int i, int stat);
 
  void SetUnsortedObjectStatus(int otype, int i, int stat);
 
  const char* GetObjectArrayName(int otype, int i);
 
  int GetNumberOfObjectArrayComponents(int otype, int i);
 
  int GetObjectArrayStatus(int otype, int i);
 
  void SetObjectArrayStatus(int otype, int i, int stat);
 
  int GetNumberOfObjectAttributes(int objectType, int objectIndex);
  const char* GetObjectAttributeName(int objectType, int objectIndex, int attributeIndex);
  int GetObjectAttributeIndex(int objectType, int objectIndex, const char* attribName);
  int GetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex);
  void SetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex, int status);
 
  vtkGetMacro(GenerateObjectIdArray, vtkTypeBool);
  vtkSetMacro(GenerateObjectIdArray, vtkTypeBool);
  static const char* GetObjectIdArrayName() { return "ObjectId"; }
 
  vtkSetMacro(GenerateGlobalElementIdArray, vtkTypeBool);
  vtkGetMacro(GenerateGlobalElementIdArray, vtkTypeBool);
  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
 
  vtkSetMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
  vtkGetMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
 
  vtkSetMacro(GenerateImplicitElementIdArray, vtkTypeBool);
  vtkGetMacro(GenerateImplicitElementIdArray, vtkTypeBool);
  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
 
  vtkSetMacro(GenerateImplicitNodeIdArray, vtkTypeBool);
  vtkGetMacro(GenerateImplicitNodeIdArray, vtkTypeBool);
  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }
 
  vtkSetMacro(GenerateFileIdArray, vtkTypeBool);
  vtkGetMacro(GenerateFileIdArray, vtkTypeBool);
  static const char* GetFileIdArrayName() { return "FileId"; }
 
  vtkSetMacro(FileId, int);
  vtkGetMacro(FileId, int);
 
  static const char* GetGlobalVariableValuesArrayName() { return "GlobalVariableValues"; }
  static const char* GetGlobalVariableNamesArrayName() { return "GlobalVariableNames"; }
 
  virtual void SetApplyDisplacements(vtkTypeBool d);
  vtkGetMacro(ApplyDisplacements, vtkTypeBool);
 
  virtual void SetDisplacementMagnitude(double s);
  vtkGetMacro(DisplacementMagnitude, double);
 
  vtkSetMacro(HasModeShapes, int);
  vtkGetMacro(HasModeShapes, int);
 
  vtkSetMacro(ModeShapeTime, double);
  vtkGetMacro(ModeShapeTime, double);
 
  vtkSetMacro(AnimateModeShapes, int);
  vtkGetMacro(AnimateModeShapes, int);
 
  vtkSetMacro(IgnoreFileTime, bool);
  vtkGetMacro(IgnoreFileTime, bool);
 
  vtkDataArray* FindDisplacementVectors(int timeStep);
 
  const struct ex_init_params* GetModelParams() const { return &this->ModelParameters; }
 
  struct VTKIOEXODUS_EXPORT ArrayInfoType
  {
    vtkStdString Name;
    int Components;
    int GlomType;
    int StorageType;
    int Source;
    int Status;
    std::vector<vtkStdString> OriginalNames;
    std::vector<int> OriginalIndices;
    std::vector<int> ObjectTruth;
    void Reset();
  };
 
  struct VTKIOEXODUS_EXPORT ObjectInfoType
  {
    int Size;
    int Status;
    int Id;
    vtkStdString Name;
  };
 
  struct VTKIOEXODUS_EXPORT MapInfoType : public ObjectInfoType
  {
  };
 
  struct VTKIOEXODUS_EXPORT BlockSetInfoType : public ObjectInfoType
  {
    vtkIdType FileOffset;
    std::map<vtkIdType, vtkIdType> PointMap;
    std::map<vtkIdType, vtkIdType> ReversePointMap;
    vtkIdType NextSqueezePoint;
    vtkUnstructuredGrid* CachedConnectivity;
 
    BlockSetInfoType() { this->CachedConnectivity = nullptr; }
    BlockSetInfoType(const BlockSetInfoType& block);
    ~BlockSetInfoType();
    BlockSetInfoType& operator=(const BlockSetInfoType& block);
  };
 
  struct VTKIOEXODUS_EXPORT BlockInfoType : public BlockSetInfoType
  {
    vtkStdString OriginalName; // useful to reset the name if XML metadata is invalid.
    vtkStdString TypeName;
    // number of boundaries per entry
    // The index is the dimensionality of the entry. 0=node, 1=edge, 2=face
    int64_t BdsPerEntry[3];
    vtkIdType AttributesPerEntry;
    std::vector<vtkStdString> AttributeNames;
    std::vector<int> AttributeStatus;
    // VTK cell type (a function of TypeName and BdsPerEntry...)
    int CellType;
    // Number of points per cell as used by VTK
    // -- not what's in the file (i.e., BdsPerEntry[0] >= PointsPerCell)
    int PointsPerCell;
  };
 
  struct PartInfoType : public ObjectInfoType
  {
    std::vector<int> BlockIndices;
  };
  struct AssemblyInfoType : public ObjectInfoType
  {
    std::vector<int> BlockIndices;
  };
  struct MaterialInfoType : public ObjectInfoType
  {
    std::vector<int> BlockIndices;
  };
 
  struct SetInfoType : public BlockSetInfoType
  {
    int DistFact; // Number of distribution factors
                  // (for the entire block, not per array or entry)
  };
 
  enum GlomTypes
  {
    Scalar = 0,          
    Vector2 = 1,         
    Vector3 = 2,         
    SymmetricTensor = 3, 
                         //   (order xx, yy, zz, xy, yz, zx)
    IntegrationPoint = 4 
  };
 
  enum ArraySourceTypes
  {
    Result = 0,    
                   //   (that vary over time)
    Attribute = 1, 
                   //   (constants over time)
    Map = 2,       
    Generated = 3  
  };
 
  vtkTimeStamp InformationTimeStamp;
 
  friend class vtkExodusIIReader;
  friend class vtkPExodusIIReader;
 
  virtual void SetParser(vtkExodusIIReaderParser*);
  vtkGetObjectMacro(Parser, vtkExodusIIReaderParser);
 
  // BUG #15632: This method allows vtkPExodusIIReader to pass time information
  // from one spatial file to another and avoiding have to read it for each of
  // the files.
  void SetTimesOverrides(const std::vector<double>& times)
  {
    this->Times = times;
    this->SkipUpdateTimeInformation = true;
  }
 
  // Because Parts, Materials, and assemblies are not stored as arrays,
  // but rather as maps to the element blocks they make up,
  // we cannot use the Get|SetObject__() methods directly.
 
  int GetNumberOfParts();
  const char* GetPartName(int idx);
  const char* GetPartBlockInfo(int idx);
  int GetPartStatus(int idx);
  int GetPartStatus(const vtkStdString& name);
  void SetPartStatus(int idx, int on);
  void SetPartStatus(const vtkStdString& name, int flag);
 
  int GetNumberOfMaterials();
  const char* GetMaterialName(int idx);
  int GetMaterialStatus(int idx);
  int GetMaterialStatus(const vtkStdString& name);
  void SetMaterialStatus(int idx, int on);
  void SetMaterialStatus(const vtkStdString& name, int flag);
 
  int GetNumberOfAssemblies();
  const char* GetAssemblyName(int idx);
  int GetAssemblyStatus(int idx);
  int GetAssemblyStatus(const vtkStdString& name);
  void SetAssemblyStatus(int idx, int on);
  void SetAssemblyStatus(const vtkStdString& name, int flag);
 
  void SetFastPathObjectType(vtkExodusIIReader::ObjectType type)
  {
    this->FastPathObjectType = type;
  }
  void SetFastPathObjectId(vtkIdType id) { this->FastPathObjectId = id; }
  vtkSetStringMacro(FastPathIdType);
 
  bool IsXMLMetadataValid();
 
  void GetInitialObjectStatus(int otype, ObjectInfoType* info);
 
  void GetInitialObjectArrayStatus(int otype, ArrayInfoType* info);
 
  void SetInitialObjectStatus(int otype, const char* name, int stat);
 
  void SetInitialObjectArrayStatus(int otype, const char* name, int stat);
 
  int UpdateTimeInformation();
 
  bool ProducedFastPathOutput;
 
protected:
  vtkExodusIIReaderPrivate();
  ~vtkExodusIIReaderPrivate() override;
 
  void BuildSIL();
 
  int VerifyIntegrationPointGlom(
    int nn, char** np, vtksys::RegularExpression& re, vtkStdString& field, vtkStdString& ele);
 
  void GlomArrayNames(int i, int num_obj, int num_vars, char** var_names, int* truth_tab);
 
  void PrepareGeneratedArrayInfo();
 
  int AssembleOutputConnectivity(vtkIdType timeStep, int otyp, int oidx, int conntypidx,
    BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleOutputPoints(
    vtkIdType timeStep, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleOutputPointArrays(
    vtkIdType timeStep, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleOutputCellArrays(
    vtkIdType timeStep, int otyp, int oidx, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleOutputProceduralArrays(
    vtkIdType timeStep, int otyp, int oidx, vtkUnstructuredGrid* output);
  int AssembleOutputGlobalArrays(
    vtkIdType timeStep, int otyp, int oidx, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleOutputPointMaps(
    vtkIdType timeStep, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleOutputCellMaps(
    vtkIdType timeStep, int otyp, int oidx, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
  int AssembleArraysOverTime(vtkMultiBlockDataSet* output);
 
  vtkIdType GetPolyhedronFaceConnectivity(vtkIdType fileLocalFaceId, vtkIdType*& facePtIds);
 
  void FreePolyhedronFaceArrays();
 
  void InsertBlockPolyhedra(
    BlockInfoType* binfo, vtkIntArray* facesPerCell, vtkIdTypeArray* exoCellConn);
 
  void InsertBlockCells(int otyp, int obj, int conn_type, int timeStep, BlockInfoType* binfop);
 
  void InsertSetCells(int otyp, int obj, int conn_type, int timeStep, SetInfoType* sinfop);
 
  void AddPointArray(vtkDataArray* src, BlockSetInfoType* bsinfop, vtkUnstructuredGrid* output);
 
  void InsertSetNodeCopies(vtkIdTypeArray* refs, int otyp, int obj, SetInfoType* sinfo);
 
  void InsertSetCellCopies(vtkIdTypeArray* refs, int otyp, int obj, SetInfoType* sinfo);
 
  void InsertSetSides(vtkIdTypeArray* refs, int otyp, int obj, SetInfoType* sinfo);
 
  vtkDataArray* GetCacheOrRead(vtkExodusIICacheKey);
 
  int GetConnTypeIndexFromConnType(int ctyp);
 
  int GetObjectTypeIndexFromObjectType(int otyp);
 
  int GetNumberOfObjectsAtTypeIndex(int typeIndex);
 
  ObjectInfoType* GetObjectInfo(int typeIndex, int objectIndex);
 
  ObjectInfoType* GetSortedObjectInfo(int objectType, int objectIndex);
 
  ObjectInfoType* GetUnsortedObjectInfo(int objectType, int objectIndex);
 
  int GetBlockIndexFromFileGlobalId(int otyp, int refId);
 
  BlockInfoType* GetBlockFromFileGlobalId(int otyp, int refId);
 
  vtkIdType GetSqueezePointId(BlockSetInfoType* bsinfop, int i);
 
  void DetermineVtkCellType(BlockInfoType& binfo);
 
  ArrayInfoType* FindArrayInfoByName(int otyp, const char* name);
 
  int IsObjectTypeBlock(int otyp);
  int IsObjectTypeSet(int otyp);
  int IsObjectTypeMap(int otyp);
 
  int GetObjectTypeFromMapType(int mtyp);
  int GetMapTypeFromObjectType(int otyp);
  int GetTemporalTypeFromObjectType(int otyp);
 
  int GetSetTypeFromSetConnType(int sctyp);
 
  int GetBlockConnTypeFromBlockType(int btyp);
 
  void RemoveBeginningAndTrailingSpaces(int len, char** names, int maxNameLength);
 
  void ClearConnectivityCaches();
 
  std::map<int, std::vector<BlockInfoType>> BlockInfo;
  std::map<int, std::vector<SetInfoType>> SetInfo;
  std::map<int, std::vector<MapInfoType>> MapInfo;
 
  std::vector<PartInfoType> PartInfo;
  std::vector<MaterialInfoType> MaterialInfo;
  std::vector<AssemblyInfoType> AssemblyInfo;
 
  std::map<int, std::vector<int>> SortedObjectIndices;
  //  defined on that type.
  std::map<int, std::vector<ArrayInfoType>> ArrayInfo;
 
  std::map<int, std::vector<ArrayInfoType>> InitialArrayInfo;
 
  std::map<int, std::vector<ObjectInfoType>> InitialObjectInfo;
 
  int AppWordSize;
  int DiskWordSize;
 
  float ExodusVersion;
 
  int Exoid;
 
  struct ex_init_params ModelParameters;
 
  std::vector<double> Times;
  bool SkipUpdateTimeInformation;
 
  double ModeShapeTime;
 
  vtkTypeBool GenerateObjectIdArray;
  vtkTypeBool GenerateGlobalIdArray;
  vtkTypeBool GenerateFileIdArray;
  vtkTypeBool GenerateGlobalElementIdArray;
  vtkTypeBool GenerateGlobalNodeIdArray;
  vtkTypeBool GenerateImplicitElementIdArray;
  vtkTypeBool GenerateImplicitNodeIdArray;
 
  int FileId;
 
  vtkExodusIICache* Cache;
  //
  double CacheSize;
 
  vtkTypeBool ApplyDisplacements;
  float DisplacementMagnitude;
  vtkTypeBool HasModeShapes;
  vtkTypeBool AnimateModeShapes;
 
  bool IgnoreFileTime;
 
  int SqueezePoints;
 
  vtkExodusIIReader* Parent;
 
  vtkExodusIIReaderParser* Parser;
 
  std::map<int, std::vector<std::vector<vtkIdType>>> PolyhedralFaceConnArrays;
 
  vtkExodusIIReader::ObjectType FastPathObjectType;
  vtkIdType FastPathObjectId;
  char* FastPathIdType;
 
  vtkMutableDirectedGraph* SIL;
 
private:
  vtkExodusIIReaderPrivate(const vtkExodusIIReaderPrivate&) = delete;
  void operator=(const vtkExodusIIReaderPrivate&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkExodusIIReaderPrivate_h