vtkExodusIIReaderPrivate.h

Go to the documentation of this file.

#ifndef vtkExodusIIReaderPrivate_h
#define vtkExodusIIReaderPrivate_h
#ifndef __VTK_WRAP__
#ifndef VTK_WRAPPING_CXX

// Do not include this file directly. It is only for use
// from inside the ExodusII reader and its descendants.

#include "vtkExodusIICache.h"
#include "vtkExodusIIReader.h"
#include "vtkStdString.h"
#include "vtkToolkits.h" // make sure VTK_USE_PARALLEL is properly set
#include "vtksys/RegularExpression.hxx"

#include <map>
#include <vector>

#include "vtkIOExodusModule.h" // For export macro
#include "vtk_exodusII.h"
class vtkExodusIIReaderParser;
class vtkIdTypeArray;
class vtkMultiBlockDataSet;
class vtkMutableDirectedGraph;
class vtkTypeInt64Array;
class vtkUnstructuredGrid;

class VTKIOEXODUS_EXPORT vtkExodusIIReaderPrivate : public vtkObject
{
public:
  static vtkExodusIIReaderPrivate* New();
  void PrintData(ostream& os, vtkIndent indent);
  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);

  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
    int 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;
};

#endif
#endif
#endif // vtkExodusIIReaderPrivate_h
// VTK-HeaderTest-Exclude: vtkExodusIIReaderPrivate.h