dox/Graphics/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 "vtkObject.h"

#define myVtkGetMacro(name, type) virtual type Get##name() const { return this->name; }

#define myVtkGetStringMacro(name) virtual char* Get##name () const { return this->name; }

class vtkDataSet;
class vtkCharArray;
class vtkIdTypeArray;
class vtkIntArray;
class vtkFloatArray;
class vtkIntArray;
class vtkModelMetadataSTLCloak;

class VTK_GRAPHICS_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);
  myVtkGetStringMacro(Title);

  void SetInformationLines(int numLines, char **lines);
  
  void AddInformationLine(char *info);

  int GetInformationLines(char ***lines) const;

  myVtkGetMacro(NumberOfInformationLines, int);

  void SetQARecords(int numberOfRecords, char *QARecords[][4]); 
  
  void AddQARecord(char *name, char *version, char *date, char *time);


  void GetQARecord(int which, 
          char **name, char **version, char **date, char **time) const;

  myVtkGetMacro(NumberOfQARecords, int);


  vtkSetMacro(TimeStepIndex, int);
  myVtkGetMacro(TimeStepIndex, int);


  void SetTimeSteps(int numberOfTimeSteps, float *timeStepValues);
  myVtkGetMacro(NumberOfTimeSteps, int);

  float *GetTimeStepValues() const {return this->TimeStepValues;}


  void SetCoordinateNames(int dimension, char **);
  char **GetCoordinateNames() const {return this->CoordinateNames;}

  myVtkGetMacro(Dimension, int);


  vtkSetMacro(NumberOfBlocks, int);
  myVtkGetMacro(NumberOfBlocks, int);


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

  myVtkGetMacro(SumElementsPerBlock, int);                                         

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

  myVtkGetMacro(SizeBlockAttributeArray, int);

  int *GetBlockAttributesIndex()const {return this->BlockAttributesIndex;};


  vtkSetMacro(NumberOfNodeSets, int);
  myVtkGetMacro(NumberOfNodeSets, int);


  void SetNodeSetIds(int *);
  int *GetNodeSetIds()const {return this->NodeSetIds;}


  int SetNodeSetSize(int *);
  int *GetNodeSetSize()const {return this->NodeSetSize;}


  void SetNodeSetNodeIdList(int *);
  int *GetNodeSetNodeIdList()const {return this->NodeSetNodeIdList;}


  int SetNodeSetNumberOfDistributionFactors(int *);
  int *GetNodeSetNumberOfDistributionFactors()const {return this->NodeSetNumberOfDistributionFactors;}


  void SetNodeSetDistributionFactors(float *);
  float *GetNodeSetDistributionFactors()const {return this->NodeSetDistributionFactors;}

  myVtkGetMacro(SumNodesPerNodeSet, int);     

  myVtkGetMacro(SumDistFactPerNodeSet, int);

  int *GetNodeSetNodeIdListIndex() const {return this->NodeSetNodeIdListIndex;}

  int *GetNodeSetDistributionFactorIndex() const {return this->NodeSetDistributionFactorIndex;}


  vtkSetMacro(NumberOfSideSets, int);
  myVtkGetMacro(NumberOfSideSets, int);


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

  myVtkGetMacro(SumSidesPerSideSet, int);

  myVtkGetMacro(SumDistFactPerSideSet, int);

  int *GetSideSetListIndex()const {return this->SideSetListIndex;}

  int *GetSideSetDistributionFactorIndex()const {return this->SideSetDistributionFactorIndex;}

  myVtkGetMacro(NumberOfBlockProperties, int);


  void SetBlockPropertyNames(int numProp, char **names);
  char **GetBlockPropertyNames()const {return this->BlockPropertyNames;}


  void SetBlockPropertyValue(int *);
  int *GetBlockPropertyValue()const {return this->BlockPropertyValue;}

  myVtkGetMacro(NumberOfNodeSetProperties, int);


  void SetNodeSetPropertyNames(int numProp, char **names);
  char **GetNodeSetPropertyNames()const {return this->NodeSetPropertyNames;}


  void SetNodeSetPropertyValue(int *);
  int *GetNodeSetPropertyValue()const {return this->NodeSetPropertyValue;}

  myVtkGetMacro(NumberOfSideSetProperties, int);


  void SetSideSetPropertyNames(int numProp, char **names);
  char **GetSideSetPropertyNames()const {return this->SideSetPropertyNames;}


  void SetSideSetPropertyValue(int *);
  int *GetSideSetPropertyValue()const {return this->SideSetPropertyValue;}

  myVtkGetMacro(NumberOfGlobalVariables, int);


  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);
  myVtkGetMacro(AllVariablesDefinedInAllBlocks, int);
  vtkBooleanMacro(AllVariablesDefinedInAllBlocks, int);

  int ElementVariableIsDefinedInBlock(char *varname, int blockId);


  myVtkGetMacro(OriginalNumberOfElementVariables, int);
  char **GetOriginalElementVariableNames()const {return this->OriginalElementVariableNames;}
  myVtkGetMacro(NumberOfElementVariables, int);
  char **GetElementVariableNames()const {return this->ElementVariableNames;}
  int *GetElementVariableNumberOfComponents()const {return this->ElementVariableNumberOfComponents;}
  int *GetMapToOriginalElementVariableNames()const {return this->MapToOriginalElementVariableNames;}

  myVtkGetMacro(OriginalNumberOfNodeVariables, int);
  char **GetOriginalNodeVariableNames()const {return this->OriginalNodeVariableNames;}
  myVtkGetMacro(NumberOfNodeVariables, int);
  char **GetNodeVariableNames()const {return this->NodeVariableNames;}
  int *GetNodeVariableNumberOfComponents()const {return this->NodeVariableNumberOfComponents;}
  int *GetMapToOriginalNodeVariableNames()const {return this->MapToOriginalNodeVariableNames;}

  char *FindOriginalElementVariableName(const char *name, int component);

  char *FindOriginalNodeVariableName(const char *name, int component);

  static int HasMetadata(vtkDataSet *grid);

  static void RemoveMetadata(vtkDataSet *grid);

  void Pack(vtkDataSet *ugrid);

  int Unpack(vtkDataSet *ugrid, int deleteIt);


  int AddUGridElementVariable(char *ugridVarName, char *origName, int numComponents);
  int RemoveUGridElementVariable(char *ugridVarName);

  int AddUGridNodeVariable(char *ugridVarName, char *origName, int numComponents);
  int RemoveUGridNodeVariable(char *ugridVarName);

  int MergeModelMetadata(const vtkModelMetadata *em);

  int MergeGlobalInformation(const vtkModelMetadata *em);


  vtkModelMetadata *ExtractModelMetadata(vtkIdTypeArray *globalCellIdList,
                                         vtkDataSet *grid);

  vtkModelMetadata *ExtractGlobalMetadata();


  void FreeAllGlobalData();
  void FreeAllLocalData();
  void FreeBlockDependentData();
  void FreeOriginalElementVariableNames();
  void FreeOriginalNodeVariableNames();
  void FreeUsedElementVariableNames();
  void FreeUsedNodeVariableNames();
  void FreeUsedElementVariables();
  void FreeUsedNodeVariables();

  void Reset();

  int GetBlockLocalIndex(int id);

protected:
  vtkModelMetadata();
  ~vtkModelMetadata();

private:
  void InitializeAllMetadata();
  void InitializeAllIvars();

  void FreeAllMetadata();
  void FreeAllIvars();

  void FreeQARecords();

  int BuildBlockElementIdListIndex();
  int BuildBlockAttributesIndex();
  int BuildNodeSetNodeIdListIndex();
  int BuildNodeSetDistributionFactorIndex();
  int BuildSideSetListIndex();
  int BuildSideSetDistributionFactorIndex();

  int InitializeFromSizeArray(vtkIntArray *ia, int &maxStr, int &maxLine);
  vtkIntArray *PackSizeArray(int maxStr, int maxLine);
  int InitializeFromIntArray(vtkModelMetadata *sizes, vtkIntArray *ia);
  vtkIntArray *PackIntArray();
  int InitializeFromCharArray(vtkModelMetadata *sizes, 
                   vtkCharArray *uca, int maxStr, int maxLine);
  vtkCharArray *PackCharArray(int maxStr, int maxLine);
  int InitializeFromFloatArray(vtkFloatArray *fa);
  vtkFloatArray *PackFloatArray();

  static char *StrDupWithNew(const char *s);

  static char *WriteLines(char *p, int maxLines, int maxLen, char **lines);
  static char *ReadLines(char ***to, int maxLines, 
                            int maxLen, char *from);
  static char **CopyLines(char **lines, int num);
  static int *CopyInts(int *vals, int num);

  static int FindNameOnList(char *name, char **list, int listLen);

  int MergeIdLists(int numSubLists,
    int *id1, int *id1Idx, int id1Len,
      float *dist1, int *dist1Idx, int dist1Len,
    int *id2, int *id2Idx, int id2Len,
      float *dist2, int *dist2Idx, int dist2Len,
    int **idNew, int **idNewIdx, int *idNewLen,
      float **distNew, int **distNewIdx, int *distNewLen);

  int AppendFloatLists(int numSubLists,
    float *id1, int *id1Idx, int id1Len,
    float *id2, int *id2Idx, int id2Len,
    float **idNew, int **idNewIdx, int *idNewLen);

  int AppendIntegerLists(int numSubLists,
    int *id1, int *id1Idx, int id1Len,
    int *id2, int *id2Idx, int id2Len,
    int **idNew, int **idNewIdx, int *idNewLen);

  void ExtractCellsFromBlockData(vtkModelMetadataSTLCloak *idset, 
                                 vtkModelMetadata *mmd);
  void ExtractNodesFromNodeSetData(vtkModelMetadataSTLCloak *idset, 
                                   vtkModelMetadata *mmd);
  void ExtractSidesFromSideSetData(vtkModelMetadataSTLCloak *idset, 
                                   vtkModelMetadata *mmd);

  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 NumberOfQARecords;       // (G)
//BTX
  char *(*QARecord)[4];        // NumberOfQARecords * 4 (G)
//ETX

  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 everytime 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

---