dox/IO/Exodus/vtkExodusIIReaderPrivate.h

Go to the documentation of this file.

#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 "vtkToolkits.h" // make sure VTK_USE_PARALLEL is properly set
#include "vtkExodusIICache.h"
#include "vtksys/RegularExpression.hxx"

#include <map>
#include <vector>

#include "vtk_exodusII.h"
#include "vtkIOExodusModule.h" // For export macro
class vtkExodusIIReaderParser;
class vtkMutableDirectedGraph;

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(TimeStep,int);

  vtkSetMacro(TimeStep,int);

  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,int);
  vtkSetMacro(GenerateObjectIdArray,int);
  static const char* GetObjectIdArrayName() { return "ObjectId"; }

  vtkSetMacro(GenerateGlobalElementIdArray,int);
  vtkGetMacro(GenerateGlobalElementIdArray,int);
  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }

  vtkSetMacro(GenerateGlobalNodeIdArray,int);
  vtkGetMacro(GenerateGlobalNodeIdArray,int);
  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }

  vtkSetMacro(GenerateImplicitElementIdArray,int);
  vtkGetMacro(GenerateImplicitElementIdArray,int);
  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }

  vtkSetMacro(GenerateImplicitNodeIdArray,int);
  vtkGetMacro(GenerateImplicitNodeIdArray,int);
  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }

  vtkSetMacro(GenerateFileIdArray,int);
  vtkGetMacro(GenerateFileIdArray,int);
  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( int d );
  vtkGetMacro(ApplyDisplacements,int);

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

  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=0;}
    BlockSetInfoType(const BlockSetInfoType& block);
    ~BlockSetInfoType();
  };

  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];
    int 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);

  // 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(vtkStdString name);
  void SetPartStatus(int idx, int on);
  void SetPartStatus(vtkStdString name, int flag);

  int GetNumberOfMaterials();
  const char* GetMaterialName(int idx);
  int GetMaterialStatus(int idx);
  int GetMaterialStatus(vtkStdString name);
  void SetMaterialStatus(int idx, int on);
  void SetMaterialStatus(vtkStdString name, int flag);

  int GetNumberOfAssemblies();
  const char* GetAssemblyName(int idx);
  int GetAssemblyStatus(int idx);
  int GetAssemblyStatus(vtkStdString name);
  void SetAssemblyStatus(int idx, int on);
  void SetAssemblyStatus(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();

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

  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(
    vtkIntArray* refs, int otyp, int obj, SetInfoType* sinfo );

  void InsertSetCellCopies(
    vtkIntArray* refs, int otyp, int obj, SetInfoType* sinfo );

  void InsertSetSides(
    vtkIntArray* 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 );

  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;

  int TimeStep;

  double ModeShapeTime;

  int GenerateObjectIdArray;
  int GenerateGlobalIdArray;
  int GenerateFileIdArray;
  int GenerateGlobalElementIdArray;
  int GenerateGlobalNodeIdArray;
  int GenerateImplicitElementIdArray;
  int GenerateImplicitNodeIdArray;

  int FileId;

  vtkExodusIICache* Cache;
  //
  double CacheSize;

  int ApplyDisplacements;
  float DisplacementMagnitude;
  int HasModeShapes;
  int AnimateModeShapes;

  int SqueezePoints;

  vtkExodusIIReader* Parent;

  vtkExodusIIReaderParser* Parser;

  vtkExodusIIReader::ObjectType FastPathObjectType;
  vtkIdType FastPathObjectId;
  char* FastPathIdType;

  vtkMutableDirectedGraph* SIL;
private:
  vtkExodusIIReaderPrivate( const vtkExodusIIReaderPrivate& ); // Not implemented.
  void operator = ( const vtkExodusIIReaderPrivate& ); // Not implemented.
};

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