vtkModelMetadata.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   ParaView
  Module:    vtkModelMetadata.h
 
  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html 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 vtkModelMetadata_h
#define vtkModelMetadata_h
 
#include "vtkIOExodusModule.h" // For export macro
#include "vtkObject.h"
 
class vtkDataSet;
class vtkCharArray;
class vtkIdTypeArray;
class vtkIntArray;
class vtkFloatArray;
class vtkIntArray;
class vtkModelMetadataSTLCloak;
 
class VTKIOEXODUS_EXPORT vtkModelMetadata : public vtkObject
{
public:
  vtkTypeMacro(vtkModelMetadata, vtkObject);
  virtual void PrintSelf(ostream &os, vtkIndent indent);
  static vtkModelMetadata *New();
 
  virtual void PrintGlobalInformation();
 
  virtual void PrintLocalInformation();
 
 
  vtkSetStringMacro(Title);
  const char *GetTitle() const {return this->Title;}
 
  void SetInformationLines(int numLines, char **lines);
 
  int GetInformationLines(char ***lines) const;
 
 
  int GetNumberOfInformationLines() const {
    return this->NumberOfInformationLines;}
 
 
  vtkSetMacro(TimeStepIndex, int);
  int GetTimeStepIndex() const {return this->TimeStepIndex;}
 
 
  void SetTimeSteps(int numberOfTimeSteps, float *timeStepValues);
  int GetNumberOfTimeSteps() const {return this->NumberOfTimeSteps;}
 
  float *GetTimeStepValues() const {return this->TimeStepValues;}
 
 
  void SetCoordinateNames(int dimension, char **);
  char **GetCoordinateNames() const {return this->CoordinateNames;}
 
  int GetDimension() const {return this->Dimension;}
 
 
  vtkSetMacro(NumberOfBlocks, int);
  int GetNumberOfBlocks() const {return this->NumberOfBlocks;}
 
 
  void SetBlockIds(int *);
  int *GetBlockIds() const {return this->BlockIds;}
 
 
  void SetBlockElementType(char **);
  char **GetBlockElementType() const {return this->BlockElementType;}
 
 
  int SetBlockNumberOfElements(int *nelts);
  int *GetBlockNumberOfElements()const{return this->BlockNumberOfElements;}
 
 
  void SetBlockNodesPerElement(int *);
  int *GetBlockNodesPerElement()const{return this->BlockNodesPerElement;}
 
 
  void SetBlockElementIdList(int *);
  int *GetBlockElementIdList() const {return this->BlockElementIdList;}
 
  int GetSumElementsPerBlock() const {return this->SumElementsPerBlock;}
 
  int *GetBlockElementIdListIndex()const {return this->BlockElementIdListIndex;}
 
 
  int SetBlockNumberOfAttributesPerElement(int *natts);
  int *GetBlockNumberOfAttributesPerElement()const {return this->BlockNumberOfAttributesPerElement;}
 
 
  void SetBlockAttributes(float *);
  float *GetBlockAttributes()const {return this->BlockAttributes;}
 
 
  int GetSizeBlockAttributeArray() const {
    return this->SizeBlockAttributeArray;}
 
  int *GetBlockAttributesIndex() const {return this->BlockAttributesIndex;}
 
 
  vtkSetMacro(NumberOfNodeSets, int);
  int GetNumberOfNodeSets() const {return this->NumberOfNodeSets;}
 
 
  void SetNodeSetIds(int *);
  int *GetNodeSetIds() const {return this->NodeSetIds;}
 
 
  void SetNodeSetSize(int *);
  int *GetNodeSetSize() const {return this->NodeSetSize;}
 
 
  void SetNodeSetNodeIdList(int *);
  int *GetNodeSetNodeIdList() const {return this->NodeSetNodeIdList;}
 
 
  void SetNodeSetNumberOfDistributionFactors(int *);
  int *GetNodeSetNumberOfDistributionFactors() const
    {return this->NodeSetNumberOfDistributionFactors;}
 
 
  void SetNodeSetDistributionFactors(float *);
  float *GetNodeSetDistributionFactors() const {
    return this->NodeSetDistributionFactors;}
 
 
  vtkSetMacro(SumNodesPerNodeSet, int);
  int GetSumNodesPerNodeSet() const {return this->SumNodesPerNodeSet;}
 
  int GetSumDistFactPerNodeSet() const {return this->SumDistFactPerNodeSet;}
 
 
  int *GetNodeSetNodeIdListIndex() const {
    return this->NodeSetNodeIdListIndex;}
 
 
  int *GetNodeSetDistributionFactorIndex() const {
    return this->NodeSetDistributionFactorIndex;}
 
 
  vtkSetMacro(NumberOfSideSets, int);
  int GetNumberOfSideSets() const {return this->NumberOfSideSets;}
 
 
  void SetSideSetIds(int *);
  int *GetSideSetIds() const {return this->SideSetIds;}
 
 
  int SetSideSetSize(int *sizes);
  int *GetSideSetSize() const {return this->SideSetSize;}
 
 
  int SetSideSetNumberOfDistributionFactors(int *df);
  int *GetSideSetNumberOfDistributionFactors() const {
    return this->SideSetNumberOfDistributionFactors;}
 
 
  void SetSideSetElementList(int *);
  int *GetSideSetElementList() const {return this->SideSetElementList;}
 
 
  void SetSideSetSideList(int *);
  int *GetSideSetSideList() const {return this->SideSetSideList;}
 
 
  void SetSideSetNumDFPerSide(int *numNodes);
  int *GetSideSetNumDFPerSide() const {return this->SideSetNumDFPerSide;}
 
 
  void SetSideSetDistributionFactors(float *);
  float *GetSideSetDistributionFactors() const {
    return this->SideSetDistributionFactors;}
 
 
  vtkSetMacro(SumSidesPerSideSet, int);
  int GetSumSidesPerSideSet() const {return this->SumSidesPerSideSet;}
 
  int GetSumDistFactPerSideSet() const {return this->SumDistFactPerSideSet;}
 
  int *GetSideSetListIndex() const {return this->SideSetListIndex;}
 
 
  int *GetSideSetDistributionFactorIndex() const {
    return this->SideSetDistributionFactorIndex;}
 
 
  int GetNumberOfBlockProperties() const {
    return this->NumberOfBlockProperties;}
 
 
  void SetBlockPropertyNames(int numProp, char **names);
  char **GetBlockPropertyNames() const {return this->BlockPropertyNames;}
 
 
  void SetBlockPropertyValue(int *);
  int *GetBlockPropertyValue() const {return this->BlockPropertyValue;}
 
 
  int GetNumberOfNodeSetProperties() const {
    return this->NumberOfNodeSetProperties;}
 
 
  void SetNodeSetPropertyNames(int numProp, char **names);
  char **GetNodeSetPropertyNames() const {return this->NodeSetPropertyNames;}
 
 
  void SetNodeSetPropertyValue(int *);
  int *GetNodeSetPropertyValue() const {return this->NodeSetPropertyValue;}
 
 
  int GetNumberOfSideSetProperties() const {
    return this->NumberOfSideSetProperties;}
 
 
  void SetSideSetPropertyNames(int numProp, char **names);
  char **GetSideSetPropertyNames() const {return this->SideSetPropertyNames;}
 
 
  void SetSideSetPropertyValue(int *);
  int *GetSideSetPropertyValue() const {return this->SideSetPropertyValue;}
 
 
  int GetNumberOfGlobalVariables() const {
    return this->NumberOfGlobalVariables;}
 
 
  void SetGlobalVariableNames(int numVarNames, char **n);
  char **GetGlobalVariableNames() const {return this->GlobalVariableNames;}
 
 
  void SetGlobalVariableValue(float *f);
  float *GetGlobalVariableValue() const {return this->GlobalVariableValue;}
 
 
  void SetElementVariableInfo(int numOrigNames, char **origNames,
                              int numNames, char **names, int *numComp,
                              int *map);
 
 
  void SetNodeVariableInfo(int numOrigNames, char **origNames,
                           int numNames, char **names,  int *numComp,
                           int *map);
 
 
  void SetElementVariableTruthTable(int *);
  int *GetElementVariableTruthTable() const {
    return this->ElementVariableTruthTable;}
 
 
  vtkSetMacro(AllVariablesDefinedInAllBlocks, int);
  vtkBooleanMacro(AllVariablesDefinedInAllBlocks, int);
  int GetAllVariablesDefinedInAllBlocks() const {
    return this->AllVariablesDefinedInAllBlocks;}
 
 
  int GetOriginalNumberOfElementVariables() const {
    return this->OriginalNumberOfElementVariables;}
  char **GetOriginalElementVariableNames() const {
    return this->OriginalElementVariableNames;}
  int GetNumberOfElementVariables() const {
    return this->NumberOfElementVariables;}
  char **GetElementVariableNames() const {
    return this->ElementVariableNames;}
  int *GetElementVariableNumberOfComponents() const {
    return this->ElementVariableNumberOfComponents;}
  int *GetMapToOriginalElementVariableNames() const {
    return this->MapToOriginalElementVariableNames;}
 
  int GetOriginalNumberOfNodeVariables() const {
    return this->OriginalNumberOfNodeVariables;}
  char **GetOriginalNodeVariableNames() const {
    return this->OriginalNodeVariableNames;}
  int GetNumberOfNodeVariables() const {
    return this->NumberOfNodeVariables;}
  char **GetNodeVariableNames() const {
    return this->NodeVariableNames;}
  int *GetNodeVariableNumberOfComponents() const {
    return this->NodeVariableNumberOfComponents;}
  int *GetMapToOriginalNodeVariableNames() const {
    return this->MapToOriginalNodeVariableNames;}
 
 
  void FreeAllGlobalData();
  void FreeAllLocalData();
  void FreeBlockDependentData();
  void FreeOriginalElementVariableNames();
  void FreeOriginalNodeVariableNames();
  void FreeUsedElementVariableNames();
  void FreeUsedNodeVariableNames();
  void FreeUsedElementVariables();
  void FreeUsedNodeVariables();
 
  void Reset();
 
protected:
  vtkModelMetadata();
  ~vtkModelMetadata();
 
private:
  void InitializeAllMetadata();
  void InitializeAllIvars();
 
  void FreeAllMetadata();
  void FreeAllIvars();
 
  int BuildBlockElementIdListIndex();
  int BuildBlockAttributesIndex();
  int BuildSideSetDistributionFactorIndex();
 
  static char *StrDupWithNew(const char *s);
 
  static int FindNameOnList(char *name, char **list, int listLen);
 
  void ShowFloats(const char *what, int num, float *f);
  void ShowLines(const char *what, int num, char **l);
  void ShowIntArray(const char *what, int numx, int numy, int *id);
  void ShowInts(const char *what, int num, int *id);
  void ShowListsOfInts(const char *what, int *list,
                       int nlists, int *idx, int len, int verbose);
  void ShowListsOfFloats(const char *what, float *list,
                         int nlists, int *idx, int len, int verbose);
 
  void SetOriginalElementVariableNames(int nvars, char **names);
  void SetElementVariableNames(int nvars, char **names);
  void SetElementVariableNumberOfComponents(int *comp);
  void SetMapToOriginalElementVariableNames(int *map);
 
  void SetOriginalNodeVariableNames(int nvars, char **names);
  void SetNodeVariableNames(int nvars, char **names);
  void SetNodeVariableNumberOfComponents(int *comp);
  void SetMapToOriginalNodeVariableNames(int *map);
 
  int CalculateMaximumLengths(int &maxString, int &maxLine);
 
  // Fields in Exodus II file and their size (defined in exodusII.h)
  //   (G - global fields, relevant to entire file or file set)
  //   (L - local fields, they differ depending on which cells and nodes are
  //        in a file of a partitioned set, or are read in from file)
 
  char *Title;                 // (G)
 
  int NumberOfInformationLines; // (G)
  char **InformationLine;       // (G)
 
  int Dimension;            // (G)
  char **CoordinateNames;   // (at most 3 of these) (G)
 
  // Time steps
 
  int TimeStepIndex;     // starting at 0 (Exodus file starts at 1)
  int NumberOfTimeSteps; // (G)
  float *TimeStepValues; // (G)
 
  // Block information - arrays that are input with Set*
 
  int NumberOfBlocks;       // (G)
 
  int *BlockIds;               // NumberOfBlocks (G) (start at 1)
  char **BlockElementType;     // NumberOfBlocks (G)
  int *BlockNumberOfElements;  // NumberOfBlocks (L)
  int *BlockNodesPerElement;   // NumberOfBlocks (G)
  int *BlockNumberOfAttributesPerElement;// NumberOfBlocks (G)
  int *BlockElementIdList;     // SumElementsPerBlock     (L)
  float *BlockAttributes;      // SizeBlockAttributeArray (L)
 
  // Block information - values that we calculate
 
  int SumElementsPerBlock;
  int SizeBlockAttributeArray;
 
  int *BlockElementIdListIndex;          // NumberOfBlocks
  int *BlockAttributesIndex;             // NumberOfBlocks
 
  vtkModelMetadataSTLCloak *BlockIdIndex;    // computed map
 
  // Node Sets - arrays that are input to the class with Set*
 
  int NumberOfNodeSets; // (G)
 
  int *NodeSetIds;             // NumberOfNodeSets (G)
  int *NodeSetSize;            // NumberOfNodeSets (L)
  int *NodeSetNumberOfDistributionFactors;  // NNS (L) (NSNDF[i] is 0 or NSS[i])
  int *NodeSetNodeIdList;   // SumNodesPerNodeSet (L)
  float *NodeSetDistributionFactors; // SumDistFactPerNodeSet (L)
 
  // Node Sets - values or arrays that the class computes
 
  int SumNodesPerNodeSet;
  int SumDistFactPerNodeSet;
 
  int *NodeSetNodeIdListIndex;           // NumberOfNodeSets
  int *NodeSetDistributionFactorIndex;   // NumberOfNodeSets
 
  // Side Sets - input to class with Set*
 
  int NumberOfSideSets; // (G)
 
  int *SideSetIds;                          // NumberOfSideSets (G)
  int *SideSetSize;                         // NumberOfSideSets (L)
  int *SideSetNumberOfDistributionFactors;  // NSS (L) (SSNDF[i] = 0 or NumNodesInSide)
  int *SideSetElementList;               // SumSidesPerSideSet (L)
  int *SideSetSideList;                  // SumSidesPerSideSet (L)
  int *SideSetNumDFPerSide;              // SumSidesPerSideSet (L)
  float *SideSetDistributionFactors;     // SumDistFactPerSideSet (L)
 
  // Side Sets - calculated by class
 
  int SumSidesPerSideSet;
  int SumDistFactPerSideSet;
 
  int *SideSetListIndex;                 // NumberOfSideSets
  int *SideSetDistributionFactorIndex;   // NumberOfSideSets
 
  // Other properties, provided as input with Set*
 
  int NumberOfBlockProperties; // (G)
  char **BlockPropertyNames;   // one per property (G)
  int *BlockPropertyValue;     // NumBlocks * NumBlockProperties (G)
 
  int NumberOfNodeSetProperties; // (G)
  char **NodeSetPropertyNames;   // one per property (G)
  int *NodeSetPropertyValue;     // NumNodeSets * NumNodeSetProperties (G)
 
  int NumberOfSideSetProperties; // (G)
  char **SideSetPropertyNames;   // one per property (G)
  int *SideSetPropertyValue;     // NumSideSets * NumSideSetProperties (G)
 
  // Global variables, 1 value per time step per variable.  We store
  // these as floats, even if they are doubles in the file.  The values
  // are global in the sense that they apply to the whole data set, but
  // the are local in the sense that they can change with each time step.
  // For the purpose of this object, which represents a particular
  // time step, they are therefore considered "local".  (Since they need
  // to be updated every time another read is done from the file.)
 
  int NumberOfGlobalVariables;   // (G)
  char **GlobalVariableNames;    // (G) NumberOfGlobalVariables
  float *GlobalVariableValue;   // (G) NumberOfGlobalVariables
 
  // The element and node arrays in the file were all scalar arrays.
  // Those with similar names were combined into vectors in VTK.  Here
  // are all the original names from the Exodus file, the names given
  // the variables in the VTK ugrid, and a mapping from the VTK names
  // to the Exodus names.
 
  int OriginalNumberOfElementVariables;    // (G)
  char **OriginalElementVariableNames;     // (G) OriginalNumberOfElementVariables
  int NumberOfElementVariables;            // (G)
  int MaxNumberOfElementVariables;         // (G)
  char **ElementVariableNames;             // (G) MaxNumberOfElementVariables
  int *ElementVariableNumberOfComponents;  // (G) MaxNumberOfElementVariables
  int *MapToOriginalElementVariableNames;  // (G) MaxNumberOfElementVariables
 
  int OriginalNumberOfNodeVariables;       // (G)
  char **OriginalNodeVariableNames;        // (G) OriginalNumberOfNodeVariables
  int NumberOfNodeVariables;               // (G)
  int MaxNumberOfNodeVariables;            // (G)
  char **NodeVariableNames;                // (G) NumberOfNodeVariables
  int *NodeVariableNumberOfComponents;     // (G) NumberOfNodeVariables
  int *MapToOriginalNodeVariableNames;     // (G) NumberOfNodeVariables
 
  int *ElementVariableTruthTable;  // (G) NumBlocks*OrigNumberOfElementVariables
  int AllVariablesDefinedInAllBlocks;
 
private:
  vtkModelMetadata(const vtkModelMetadata&); // Not implemented
  void operator=(const vtkModelMetadata&); // Not implemented
};
#endif