/*========================================================================= 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. ----------------------------------------------------------------------------*/ /** * @class vtkModelMetadata * @brief This class encapsulates the metadata * that appear in mesh-based file formats but do not appear in * vtkUnstructuredGrid. * * * This class is inspired by the Exodus II file format, but * because this class does not depend on the Exodus library, it * should be possible to use it to represent metadata for other * dataset file formats. Sandia Labs uses it in their Exodus II * reader, their Exodus II writer and their EnSight writer. * vtkDistributedDataFilter looks for metadata attached to * it's input and redistributes the metadata with the grid. * * The fields in this class are those described in the document * "EXODUS II: A Finite Element Data Model", SAND92-2137, November 1995. * * Element and node IDs stored in this object must be global IDs, * in the event that the original dataset was partitioned across * many files. * * One way to initialize this object is by using vtkExodusModel * (a Sandia class used by the Sandia Exodus reader). * That class will take an open Exodus II file and a * vtkUnstructuredGrid drawn from it and will set the required fields. * * Alternatively, you can use all the Set* * methods to set the individual fields. This class does not * copy the data, it simply uses your pointer. This * class will free the storage associated with your pointer * when the class is deleted. Most fields have sensible defaults. * The only requirement is that if you are using this ModelMetadata * to write out an Exodus or EnSight file in parallel, you must * SetBlockIds and SetBlockIdArrayName. Your vtkUnstructuredGrid must * have a cell array giving the block ID for each cell. * * @warning * The Exodus II library supports an optimized element order map * (section 3.7 in the SAND document). It contains all the element * IDs, listed in the order in which a solver should process them. * We don't include this, and won't unless there is a request. * * @warning * There is an assumption in some classes that the name of the cell * array containing global element ids is "GlobalElementId" and the * name of the point array containing global node ids is "GlobalNodeId". * (element == cell) and (node == point). * * @sa * vtkDistributedDataFilter vtkExtractCells */ #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(); /** * The global fields are those which pertain to the whole * file. Examples are the title, information lines, * and list of block IDs. This method prints out all the * global information. */ virtual void PrintGlobalInformation(); /** * The local fields are those which depend on exactly which * blocks, which time step, and which variables you read in * from the file. Examples are the number of cells in * each block, and the list of nodes in a node set, or the * value of the global variables at a time step. If * VERBOSE_TESTING is defined in your execution environment, * this method will print more than mere counts, and actually * print a few of the IDs, distribution factors and so on. If * VERY_VERBOSE_TESTING is defined, it will print out * all ID lists, distribution factor lists, and so on. */ virtual void PrintLocalInformation(); //@{ /** * The title of the dataset. */ vtkSetStringMacro(Title); const char *GetTitle() const {return this->Title;} //@} /** * Set the information lines. */ void SetInformationLines(int numLines, char **lines); /** * Get a pointer to all the information lines. The number * of lines is returned; */ int GetInformationLines(char ***lines) const; /** * Get the number of information lines. */ int GetNumberOfInformationLines() const { return this->NumberOfInformationLines;} //@{ /** * Set the index of the time step represented by the results * data in the file attached to this ModelMetadata object. Time * step indices start at 0 in this file, they start at 1 in * an Exodus file. */ vtkSetMacro(TimeStepIndex, int); int GetTimeStepIndex() const {return this->TimeStepIndex;} //@} /** * Set the total number of time steps in the file, * and the value at each time step. We use your time * step value array and delete it when we're done. */ void SetTimeSteps(int numberOfTimeSteps, float *timeStepValues); int GetNumberOfTimeSteps() const {return this->NumberOfTimeSteps;} /** * Get the time step values */ float *GetTimeStepValues() const {return this->TimeStepValues;} /** * The name of the one, two or three coordinate dimensions. */ void SetCoordinateNames(int dimension, char **); char **GetCoordinateNames() const {return this->CoordinateNames;} /** * Get the dimension of the model. This is also the number * of coordinate names. */ int GetDimension() const {return this->Dimension;} //@{ /** * The number of blocks in the file. Set this before setting * any of the block arrays. */ vtkSetMacro(NumberOfBlocks, int); int GetNumberOfBlocks() const {return this->NumberOfBlocks;} //@} /** * An arbitrary integer ID for each block. * We use your pointer, and free the memory when the object is freed. */ void SetBlockIds(int *); int *GetBlockIds() const {return this->BlockIds;} /** * Element type for each block - a name that means * something to person who created the file. * We use your pointers, and free the memory when the object is freed. */ void SetBlockElementType(char **); char **GetBlockElementType() const {return this->BlockElementType;} /** * Set or get a pointer to a list of the number of elements in * each block. * We use your pointers, and free the memory when the object is freed. */ int SetBlockNumberOfElements(int *nelts); int *GetBlockNumberOfElements()const{return this->BlockNumberOfElements;} /** * Set or get a pointer to a list of the number of nodes in the * elements of each block. * We use your pointers, and free the memory when the object is freed. */ void SetBlockNodesPerElement(int *); int *GetBlockNodesPerElement()const{return this->BlockNodesPerElement;} /** * Set or get a pointer to a list global element IDs for the * elements in each block. * We use your pointers, and free the memory when the object is freed. */ void SetBlockElementIdList(int *); int *GetBlockElementIdList() const {return this->BlockElementIdList;} /** * Get the length of the list of elements in every block. */ int GetSumElementsPerBlock() const {return this->SumElementsPerBlock;} /** * Get a list of the index into the BlockElementIdList of the * start of each block's elements. */ int *GetBlockElementIdListIndex()const {return this->BlockElementIdListIndex;} /** * Set or get a pointer to a list of the number of attributes * stored for the elements in each block. * We use your pointers, and free the memory when the object is freed. */ int SetBlockNumberOfAttributesPerElement(int *natts); int *GetBlockNumberOfAttributesPerElement()const {return this->BlockNumberOfAttributesPerElement;} /** * Set or get a pointer to a list of the attributes for all * blocks. The order of the list should be by block, by element * within the block, by attribute. Omit blocks that don't * have element attributes. */ void SetBlockAttributes(float *); float *GetBlockAttributes()const {return this->BlockAttributes;} /** * Get the length of the list of floating point block attributes. */ int GetSizeBlockAttributeArray() const { return this->SizeBlockAttributeArray;} /** * Get a list of the index into the BlockAttributes of the * start of each block's element attribute list. */ int *GetBlockAttributesIndex() const {return this->BlockAttributesIndex;} //@{ /** * The number of node sets in the file. Set this value before * setting the various node set arrays. */ vtkSetMacro(NumberOfNodeSets, int); int GetNumberOfNodeSets() const {return this->NumberOfNodeSets;} //@} void SetNodeSetNames (vtkStringArray *names) { this->NodeSetNames = names; } vtkStringArray* GetNodeSetNames() const { return this->NodeSetNames; } /** * Set or get the list the IDs for each node set. * Length of list is the number of node sets. * We use your pointer, and free the memory when the object is freed. */ void SetNodeSetIds(int *); int *GetNodeSetIds() const {return this->NodeSetIds;} /** * Set or get a pointer to a list of the number of nodes in each node set. * We use your pointer, and free the memory when the object is freed. */ void SetNodeSetSize(int *); int *GetNodeSetSize() const {return this->NodeSetSize;} /** * Set or get a pointer to a concatenated list of the * IDs of all nodes in each node set. First list all IDs in * node set 0, then all IDs in node set 1, and so on. * We use your pointer, and free the memory when the object is freed. */ void SetNodeSetNodeIdList(int *); int *GetNodeSetNodeIdList() const {return this->NodeSetNodeIdList;} /** * Set or get a list of the number of distribution factors stored * by each node set. This is either 0 or equal to the number of * nodes in the node set. * Length of list is number of node sets. * We use your pointer, and free the memory when the object is freed. */ void SetNodeSetNumberOfDistributionFactors(int *); int *GetNodeSetNumberOfDistributionFactors() const {return this->NodeSetNumberOfDistributionFactors;} /** * Set or get a list of the distribution factors for the node sets. * The list is organized by node set, and within node set by node. * We use your pointer, and free the memory when the object is freed. */ void SetNodeSetDistributionFactors(float *); float *GetNodeSetDistributionFactors() const { return this->NodeSetDistributionFactors;} //@{ /** * Get the total number of nodes in all node sets */ vtkSetMacro(SumNodesPerNodeSet, int); int GetSumNodesPerNodeSet() const {return this->SumNodesPerNodeSet;} //@} /** * Get the total number of distribution factors stored for all node sets */ int GetSumDistFactPerNodeSet() const {return this->SumDistFactPerNodeSet;} /** * Get a list of the index of the starting entry for each node set * in the list of node set node IDs. */ int *GetNodeSetNodeIdListIndex() const { return this->NodeSetNodeIdListIndex;} /** * Get a list of the index of the starting entry for each node set * in the list of node set distribution factors. */ int *GetNodeSetDistributionFactorIndex() const { return this->NodeSetDistributionFactorIndex;} //@{ /** * Set or get the number of side sets. Set this value before * setting any of the other side set arrays. */ vtkSetMacro(NumberOfSideSets, int); int GetNumberOfSideSets() const {return this->NumberOfSideSets;} //@} void SetSideSetNames (vtkStringArray *names) { this->SideSetNames = names; } vtkStringArray* GetSideSetNames() const { return this->SideSetNames; } /** * Set or get a pointer to a list giving the ID of each side set. * We use your pointer, and free the memory when the object is freed. */ void SetSideSetIds(int *); int *GetSideSetIds() const {return this->SideSetIds;} /** * Set or get a pointer to a list of the number of sides in each side set. * We use your pointer, and free the memory when the object is freed. */ int SetSideSetSize(int *sizes); int *GetSideSetSize() const {return this->SideSetSize;} /** * Set or get a pointer to a list of the number of distribution * factors stored by each side set. Each side set has either * no distribution factors, or 1 per node in the side set. * We use your pointer, and free the memory when the object is freed. */ int SetSideSetNumberOfDistributionFactors(int *df); int *GetSideSetNumberOfDistributionFactors() const { return this->SideSetNumberOfDistributionFactors;} /** * Set or get a pointer to a list of the elements containing each * side in each side set. The list is organized by side set, and * within side set by element. * We use your pointer, and free the memory when the object is freed. */ void SetSideSetElementList(int *); int *GetSideSetElementList() const {return this->SideSetElementList;} /** * Set or get a pointer to the element side for each side in the side set. * (See the manual for the convention for numbering sides in different * types of cells.) Side Ids are arranged by side set and within * side set by side, and correspond to the SideSetElementList. * We use your pointer, and free the memory when the object is freed. */ void SetSideSetSideList(int *); int *GetSideSetSideList() const {return this->SideSetSideList;} /** * Set or get a pointer to a list of the number of nodes in each * side of each side set. This list is organized by side set, and * within side set by side. * We use your pointer, and free the memory when the object is freed. */ void SetSideSetNumDFPerSide(int *numNodes); int *GetSideSetNumDFPerSide() const {return this->SideSetNumDFPerSide;} /** * Set or get a pointer to a list of all the distribution factors. * For every side set that has distribution factors, the number of * factors per node was given in the SideSetNumberOfDistributionFactors * array. If this number for a given side set is N, then for that * side set we have N floating point values for each node for each * side in the side set. If nodes are repeated in more than one * side, we repeat the distribution factors. So this list is in order * by side set, by node. * We use your pointer, and free the memory when the object is freed. */ void SetSideSetDistributionFactors(float *); float *GetSideSetDistributionFactors() const { return this->SideSetDistributionFactors;} //@{ /** * Get the total number of sides in all side sets */ vtkSetMacro(SumSidesPerSideSet, int); int GetSumSidesPerSideSet() const {return this->SumSidesPerSideSet;} //@} /** * Get the total number of distribution factors stored for all side sets */ int GetSumDistFactPerSideSet() const {return this->SumDistFactPerSideSet;} /** * Get a list of the index of the starting entry for each side set * in the list of side set side IDs. */ int *GetSideSetListIndex() const {return this->SideSetListIndex;} /** * Get a list of the index of the starting entry for each side set * in the list of side set distribution factors. */ int *GetSideSetDistributionFactorIndex() const { return this->SideSetDistributionFactorIndex;} /** * The number of block properties (global variables) */ int GetNumberOfBlockProperties() const { return this->NumberOfBlockProperties;} /** * Set or get the names of the block properties. */ void SetBlockPropertyNames(int numProp, char **names); char **GetBlockPropertyNames() const {return this->BlockPropertyNames;} /** * Set or get value for each variable for each block. List * the integer values in order by variable and within variable * by block. */ void SetBlockPropertyValue(int *); int *GetBlockPropertyValue() const {return this->BlockPropertyValue;} /** * The number of node set properties (global variables) */ int GetNumberOfNodeSetProperties() const { return this->NumberOfNodeSetProperties;} /** * Set or get the names of the node setproperties. */ void SetNodeSetPropertyNames(int numProp, char **names); char **GetNodeSetPropertyNames() const {return this->NodeSetPropertyNames;} /** * Set or get value for each variable for each node set. List * the integer values in order by variable and within variable * by node set. */ void SetNodeSetPropertyValue(int *); int *GetNodeSetPropertyValue() const {return this->NodeSetPropertyValue;} /** * The number of side set properties (global variables) */ int GetNumberOfSideSetProperties() const { return this->NumberOfSideSetProperties;} /** * Set or get the names of the side set properties. */ void SetSideSetPropertyNames(int numProp, char **names); char **GetSideSetPropertyNames() const {return this->SideSetPropertyNames;} /** * Set or get value for each variable for each side set. List * the integer values in order by variable and within variable * by side set. */ void SetSideSetPropertyValue(int *); int *GetSideSetPropertyValue() const {return this->SideSetPropertyValue;} /** * Get the number of global variables per time step */ int GetNumberOfGlobalVariables() const { return this->NumberOfGlobalVariables;} /** * Set or get the names of the global variables */ void SetGlobalVariableNames(int numVarNames, char **n); char **GetGlobalVariableNames() const {return this->GlobalVariableNames;} /** * Set or get the values of the global variables at the current * time step. */ void SetGlobalVariableValue(float *f); float *GetGlobalVariableValue() const {return this->GlobalVariableValue;} /** * The ModelMetadata maintains a list of the element variables that * were in the original file, and a list of the cell variables * in the UGrid derived from that file. Some of the scalar variables * in the original file were combined into vectors in the UGrid. * In this method, provide the number of original element variables, * the names of the original element variables, the number of * element variables in the UGrid, the number of components for each * of those variables, and a map from each UGrid variable to the * the variable in the list of original names that represents it's * first component. */ void SetElementVariableInfo(int numOrigNames, char **origNames, int numNames, char **names, int *numComp, int *map); /** * The ModelMetadata maintains a list of the node variables that * were in the original file, and a list of the node variables * in the UGrid derived from that file. Some of the scalar variables * in the original file were combined into vectors in the UGrid. * In this method, provide the number of original node variables, * the names of the original node variables, the number of * node variables in the UGrid, the number of components for each * of those variables, and a map from each UGrid variable to the * the variable in the list of original names that represents it's * first component. */ void SetNodeVariableInfo(int numOrigNames, char **origNames, int numNames, char **names, int *numComp, int *map); /** * A truth table indicating which element variables are * defined for which blocks. The variables are all the original * element variables that were in the file. * The table is by block ID and within block ID by variable. */ void SetElementVariableTruthTable(int *); int *GetElementVariableTruthTable() const { return this->ElementVariableTruthTable;} //@{ /** * Instead of a truth table of all "1"s, you can set this * instance variable to indicate that all variables are * defined in all blocks. */ vtkSetMacro(AllVariablesDefinedInAllBlocks, int); vtkBooleanMacro(AllVariablesDefinedInAllBlocks, int); int GetAllVariablesDefinedInAllBlocks() const { return this->AllVariablesDefinedInAllBlocks;} //@} /** * The ModelMetadata object may contain these lists: * o the variables in the original data file * o the variables created in the u grid from those original variables * o a mapping from the grid variable names to the original names * o a list of the number of components each grid variable has * (Example: Variables in Exodus II files are all scalars. Some are * combined by the ExodusReader into vector variables in the grid.) * These methods return names of the original variables, the names * of the grid variables, a list of the number of components in * each grid variable, and a list of the index into the list of * original variable names where the original name of the first * component of a grid variable may be found. The names of subsequent * components would immediately follow the name of the the first * component. */ 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;} //@{ /** * Free selected portions of the metadata when updating values * in the vtkModelMetadata object. Resetting a particular field, * (i.e. SetNodeSetIds) frees the previous setting, but if you * are not setting every field, you may want to do a wholesale * "Free" first. * FreeAllGlobalData frees all the fields which don't depend on * which time step, which blocks, or which variables are in the input. * FreeAllLocalData frees all the fields which do depend on which * time step, blocks or variables are in the input. * FreeBlockDependentData frees all metadata fields which depend on * which blocks were read in. */ void FreeAllGlobalData(); void FreeAllLocalData(); void FreeBlockDependentData(); void FreeOriginalElementVariableNames(); void FreeOriginalNodeVariableNames(); void FreeUsedElementVariableNames(); void FreeUsedNodeVariableNames(); void FreeUsedElementVariables(); void FreeUsedNodeVariables(); //@} /** * Set the object back to it's initial state */ 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 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 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 int AllVariablesDefinedInAllBlocks; private: vtkModelMetadata(const vtkModelMetadata&) = delete; void operator=(const vtkModelMetadata&) = delete; }; #endif