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"
#include "vtkSmartPointer.h" // for vtkSmartPointer
#include "vtkStringArray.h"  // for vtkStringArray
class vtkDataSet;
class vtkCharArray;
class vtkIdTypeArray;
class vtkIntArray;
class vtkFloatArray;
class vtkIntArray;
class vtkStringArray;
class vtkModelMetadataSTLCloak;
 
class VTKIOEXODUS_EXPORT vtkModelMetadata : public vtkObject
{
public:
  vtkTypeMacro(vtkModelMetadata, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  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 SetNodeSetNames(vtkStringArray* names) { this->NodeSetNames = names; }
  vtkStringArray* GetNodeSetNames() const { return this->NodeSetNames; }
 
  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 SetSideSetNames(vtkStringArray* names) { this->SideSetNames = names; }
  vtkStringArray* GetSideSetNames() const { return this->SideSetNames; }
 
  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, vtkTypeBool);
  vtkBooleanMacro(AllVariablesDefinedInAllBlocks, vtkTypeBool);
  vtkTypeBool 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() override;
 
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)
 
  vtkSmartPointer<vtkStringArray> NodeSetNames;
 
  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)
 
  vtkSmartPointer<vtkStringArray> SideSetNames;
 
  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
  vtkTypeBool AllVariablesDefinedInAllBlocks;
 
private:
  vtkModelMetadata(const vtkModelMetadata&) = delete;
  void operator=(const vtkModelMetadata&) = delete;
};
#endif