Grid Coordinates, Elements, and Flow Solutions

• Grid Coordinates Structure Definition: GridCoordinates_t
• Grid Coordinates Examples
• Elements Structure Definition: Elements_t
• Elements Examples
• Axisymmetry Structure Definition: Axisymmetry_t
• Rotating Coordinates Structure Definition: RotatingCoordinates_t
• Flow Solution Structure Definition: FlowSolution_t
• Flow Solution Example

This section defines structure types for describing the grid coordinates, element data, and flow solution data pertaining to a zone. Entities of each of the structure types defined in this section are contained in the Zone_t structure.

Grid Coordinates Structure Definition: GridCoordinates_t

The physical coordinates of the grid vertices are described by the GridCoordinates_t structure. This structure contains a list for the data arrays of the individual components of the position vector. It also provides a mechanism for identifying rind-point data included within the position-vector arrays.

  GridCoordinates_t< int IndexDimension, int VertexSize[IndexDimension] > :=
    {
    List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)
 
    Rind_t<IndexDimension> Rind ;                                      (o/d)

    List( DataArray_t<DataType, IndexDimension, DataSize[]> 
          DataArray1 ... DataArrayN ) ;                                (o)

    DataClass_t DataClass ;                                            (o)
    
    DimensionalUnits_t DimensionalUnits ;                              (o)

    List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
    } ;

1. Default names for the Descriptor_t, DataArray_t, and UserDefinedData_t lists are as shown; users may choose other legitimate names. Legitimate names must be unique within a given instance of GridCoordinates_t and shall not include the names DataClass, DimensionalUnits, or Rind.
2. There are no required fields for GridCoordinates_t. Rind has a default if absent; the default is equivalent to having a Rind structure whose RindPlanes array contains all zeros.
3. The structure parameter DataType must be consistent with the data stored in the DataArray_t substructures.

GridCoordinates_t requires two structure parameters: IndexDimension identifies the dimensionality of the grid-size arrays, and VertexSize is the number of vertices in each index direction excluding rind points. For unstructured zones, IndexDimension is always 1 and VertexSize is the total number of vertices, excluding rind points.

The grid-coordinates data is stored in the list of DataArray_t entities; each DataArray_t structure entity may contain a single component of the position vector (e.g., three separate DataArray_t entities are used for x, y, and z).

Standardized data-name identifiers for the grid coordinates are described in Conventions for Data-Name Identifiers.

Rind is an optional field that indicates the number of rind planes (for structured grids) or rind points (for unstructured grids) included in the grid-coordinates data. If Rind is absent, then the DataArray_t structure entities contain only "core" vertices of a zone; core refers to all interior and bounding vertices of a zone - VertexSize is the number of core vertices. Core vertices in a zone are assumed to begin at [1,1,1] (for a structured zone in 3-D) and end at VertexSize. If Rind is present, it will provide information on the number of "rind" points in addition to the core points that are contained in the DataArray_t structures.

DataClass defines the default class for data contained in the DataArray_t entities. For dimensional grid coordinates, DimensionalUnits may be used to describe the system of units employed. If present, these two entities take precedence over the corresponding entities at higher levels of the CGNS hierarchy, following the standard precedence rules. An example that uses these grid-coordinate defaults is shown under Grid Coordinates Examples.

The UserDefinedData_t data structure allows arbitrary user-defined data to be stored in Descriptor_t and DataArray_t children without the restrictions or implicit meanings imposed on these node types at other node locations.

FUNCTION DataSize[]:

GridCoordinates_t requires a single structure function, named DataSize, to identify the array sizes of the grid-coordinates data. A function is required for the following reasons:

• the entire grid, including both core and rind points, is stored in the DataArray_t entities;
• the DataArray_t structure is simple in that it doesn't know anything about core versus rind data; it just knows that it contains data of some given size;
• to make all the DataArray_t entities syntactically consistent in their size (i.e., by syntax entities containing x, y and z must have the same dimensionality and dimension sizes), the size of the array is passed onto the DataArray_t structure as a parameter.

  if (Rind is absent) then
    {
    DataSize[] = VertexSize[] ;
    }
  else if (Rind is present) then
    { 
    DataSize[] = VertexSize[] + [a + b,...] ;
    }

Grid Coordinates Examples

This section contains examples of grid coordinates. These examples show the storage of the grid-coordinate data arrays, as well as different mechanisms for describing the class of data and the system of units or normalization.

Example - Cartesian Coordinates for a 2-D Structured Grid

Cartesian coordinates for a 2-D grid of size 17 × 33; the data arrays include only core vertices, and the coordinates are in units of feet.

  !  IndexDimension = 2
  !  VertexSize = [17,33]
  GridCoordinates_t<2, [17,33]> GridCoordinates =
    {{
    DataArray_t<real, 2, [17,33]> CoordinateX =
      {{
      Data(real, 2, [17,33]) = ((x(i,j), i=1,17), j=1,33) ;

      DataClass_t DataClass = Dimensional ;
      
      DimensionalUnits_t DimensionalUnits = 
        {{ 
        MassUnits        = Null ;
        LengthUnits      = Foot ;
        TimeUnits        = Null ;
        TemperatureUnits = Null ;
        AngleUnits       = Null ;
        }} ;
      }} ;

    DataArray_t<real, 2, [17,33]> CoordinateY =
      {{
      Data(real, 2, [17,33]) = ((y(i,j), i=1,17), j=1,33) ;

      DataClass_t DataClass = Dimensional ;
      
      DimensionalUnits_t DimensionalUnits = 
        {{ 
        MassUnits        = Null ;
        LengthUnits      = Foot ;
        TimeUnits        = Null ;
        TemperatureUnits = Null ;
        AngleUnits       = Null ;
        }} ;
      }} ;
    }} ;

Note that FORTRAN multidimensional array indexing is used to store the data; this is reflected in the FORTRAN-like implied do-loops for x(i,j) and y(i,j).

Since the dimensional units for both x and y are the same, an alternate approach is to set the data class and system of units using DataClass and DimensionalUnits at the GridCoordinates_t level, and eliminate this information from each instance of DataArray_t.

  GridCoordinates_t<2, [17,33]> GridCoordinates =
    {{
    DataClass_t DataClass = Dimensional ;
    
    DimensionalUnits_t DimensionalUnits = 
      {{ 
      MassUnits        = Null ;
      LengthUnits      = Foot ;
      TimeUnits        = Null ;
      TemperatureUnits = Null ;
      AngleUnits       = Null ;
      }} ;

    DataArray_t<real, 2, [17,33]> CoordinateX =
      {{
      Data(real, 2, [17,33]) = ((x(i,j), i=1,17), j=1,33) ;
      }} ;

    DataArray_t<real, 2, [17,33]> CoordinateY =
      {{
      Data(real, 2, [17,33]) = ((y(i,j), i=1,17), j=1,33) ;
      }} ;
    }} ;

Example - Cylindrical Coordinates for a 3-D Structured Grid

Cylindrical coordinates for a 3-D grid whose core size is 17 × 33 × 9. The grid contains a single plane of rind on the minimum and maximum k faces. The coordinates are nondimensional.

  !  IndexDimension = 3
  !  VertexSize = [17,33,9]
  GridCoordinates_t<3, [17,33,9]> GridCoordinates =
    {{
    Rind_t<3> Rind =
      {{
      int[6] RindPlanes = [0,0,0,0,1,1] ;
      }} ;

    ! DataType = real
    ! IndexDimension = 3
    ! DataSize = VertexSize + [0,0,2] = [17,33,11]
    DataArray_t<real, 3, [17,33,11]> CoordinateRadius =
      {{
      Data(real, 3, [17,33,11]) = (((r(i,j,k), i=1,17), j=1,33), k=0,10) ;

      DataClass_t DataClass = NormalizedByUnknownDimensional ;
      }} ;

    DataArray_t<real, 3, [17,33,11]> CoordinateZ     = {{ }} ;
    DataArray_t<real, 3, [17,33,11]> CoordinateTheta = {{ }} ;
    }} ;

Note that the entities CoordinateZ and CoordinateTheta are abbreviated.

Example - Cartesian Coordinates for a 3-D Unstructured Grid

Cartesian grid coordinates for a 3-D unstructured zone where VertexSize is 15.

  GridCoordinates_t<1, 15> GridCoordinates =
    {{

    ! DataType = real
    ! IndexDimension = 1
    ! DataSize = VertexSize = 15
    DataArray_t<real, 1, 15> CoordinateX =
      {{
      Data(real, 1, 15) = (x(i), i=1,15) ;
      }} ;

    DataArray_t<real, 1, 15> CoordinateY =
      {{
      Data(real, 1, 15) = (y(i), i=1,15) ;
      }} ;

    DataArray_t<real, 1, 15> CoordinateZ =
      {{
      Data(real, 1, 15) = (z(i), i=1,15) ;
      }} ;
    }} ;

Elements Structure Definition: Elements_t

The Elements_t data structure is required for unstructured zones, and contains the element connectivity data, the element type, the element range, the parent elements data, and the number of boundary elements.

  Elements_t :=
    {
    List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)
 
    Rind_t<IndexDimension> Rind ;                                      (o/d)

    IndexRange_t ElementRange ;                                        (r)

    int ElementSizeBoundary ;                                          (o/d)

    ElementType_t ElementType ;                                        (r)

    DataArray_t<int, 1, ElementDataSize> ElementConnectivity ;         (r)

    DataArray_t<int, 2, [ElementSize, 4]> ParentData;                  (o)

    List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
    } ;

1. Default names for the Descriptor_t and UserDefinedData_t lists are as shown; users may choose other legitimate names. Legitimate names must be unique within a given instance of Elements_t and shall not include the names ElementConnectivity, ElementRange, ParentData, or Rind.
2. IndexRange_t, ElementType_t, and ElementConnectivity are the required fields within the Elements_t structure. Rind has a default if absent; the default is equivalent to having a Rind structure whose RindPlanes array contains all zeros.

Rind is an optional field that indicates the number of rind elements included in the elements data. If Rind is absent, then the DataArray_t structure entities contain only core elements of a zone. If Rind is present, it will provide information on the number of rind elements, in addition to the core elements, that are contained in the DataArray_t structures.

Note that the usage of rind data with respect to the size of the DataArray_t structures is different under Elements_t than elsewhere. For example, when rind coordinate data is stored under GridCoordinates_t, the parameter VertexSize accounts for the core data only. The size of the DataArray_t structures containing the grid coordinates is determined by the DataSize function, which adds the number of rind planes or points to VertexSize. But for the element connectivity, the size of the DataArray_t structures containing the connectivity data is just ElementDataSize, which depends on ElementSize, and includes both the core and rind elements.

ElementRange contains the index of the first and last elements defined in ElementConnectivity. The elements are indexed with a global numbering system, starting at 1, for all element sections under a given Zone_t data structure. The global numbering insures that each element, whether it's a cell, a face, or an edge, is uniquely identified by its number. They are also listed as a continuous list of element numbers within any single element section. Therefore the number of elements in a section is:

  ElementSize = ElementRange.end - ElementRange.start + 1

The element indices are used for the boundary condition and zone connectivity definition.

ElementSizeBoundary indicates if the elements are sorted, and how many boundary elements are recorded. By default, ElementSizeBoundary is set to zero, indicating that the elements are not sorted. If the elements are sorted, ElementSizeBoundary is set to the number of elements at the boundary. Consequently:

  ElementSizeInterior = ElementSize - ElementSizeBoundary

ElementType_t is an enumeration of the supported element types:

  ElementType_t := Enumeration(
     Null, NODE, BAR_2, BAR_3,
     TRI_3, TRI_6, QUAD_4, QUAD_8, QUAD_9,
     TETRA_4, TETRA_10, PYRA_5, PYRA_14,
     PENTA_6, PENTA_15, PENTA_18, 
     HEXA_8, HEXA_20, HEXA_27, MIXED, NGON_n, UserDefined );

For all element types except type MIXED, ElementConnectivity contains the list of nodes for each element. If the elements are sorted, then it must first list the connectivity of the boundary elements, then that of the interior elements.

  ElementConnectivity = Node11, Node21, ... NodeN1,
                        Node12, Node22, ... NodeN2,
                        ...
                        Node1M, Node2M, ... NodeNM

When the section ElementType is MIXED, the data array ElementConnectivity contains one extra integer per element, to hold each individual element type:

  ElementConnectivity = Etype1, Node11, Node21, ... NodeN1,
                        Etype2, Node12, Node22, ... NodeN2,
                        ...
                        EtypeM, Node1M, Node2M, ... NodeNM

ElementDataSize indicates the size (number of integers) of the array ElementConnectivity. For all element types except type MIXED, the ElementDataSize is given by:

  ElementDataSize = ElementSize * NPE[ElementType]

In the case of MIXED element section, ElementDataSize is given by:

  ElementDataSize = ∑ (NPE[ElementType_n] + 1)

where the summation is over n, and n represents a specific element type.

NPE[ElementType] is a function returning the number of nodes for the given ElementType. For example, NPE[HEXA_8]=8.

For face elements in 3D, or bar element in 2D, four more data may be saved for each element - the corresponding parents' element number, and the face position within these parent elements. At the boundaries, the second parent is set to zero.

NGON_n is used to express a polygon of n nodes. In order to record the number of nodes of any ngons, the ElementType must be set to NGON_n + Nnodes. For example, for an element type NGON_n composed of 25 nodes, one would set the ElementType to NGON_n + 25.

The UserDefinedData_t data structure allows arbitrary user-defined data to be stored in Descriptor_t and DataArray_t children without the restrictions or implicit meanings imposed on these node types at other node locations.

Elements Examples

This section contains two examples of elements definition in CGNS. In both cases, the unstructured zone contains 15 tetrahedral and 10 hexahedral elements.

Example - Unstructured Elements, Separate Element Types

In this first example, the elements are written in two separate sections, one for the tetrahedral elements and one for the hexahedral elements.

  Zone_t UnstructuredZone =
    {{
    Elements_t TetraElements =
      {{
      IndexRange_t ElementRange = [1,15] ;

      int ElementSizeBoundary = 10 ;

      ElementType_t ElementType = TETRA_4 ;

      DataArray_t<int, 1, NPE[TETRA_4] × 15> ElementConnectivity =
        {{
        Data(int, 1, NPE[TETRA_4] × 15) = (node(i,j), i=1,NPE[TETRA_4], j=1,15) ;
        }} ;
      }} ;
    Elements_t HexaElements =
      {{
      IndexRange_t ElementRange = [16,25] ;

      int ElementSizeBoundary = 0 ;

      ElementType_t ElementType = HEXA_8 ;

      DataArray_t<int, 1, NPE[HEXA_8] × 10> ElementConnectivity =
        {{
        Data(int, 1, NPE[HEXA_8] × 10) = (node(i,j), i=1,NPE[HEXA_8], j=1,10) ;
        }} ;
      }} ;
    }} ;

Example - Unstructured Elements, Element Type MIXED

In this second example, the same unstructured zone described in the example for separate element types is written in a single element section of type MIXED (i.e., an unstructured grid composed of mixed elements).

  Zone_t UnstructuredZone =
    {{
    Elements_t MixedElementsSection =
      {{
      IndexRange_t ElementRange = [1,25] ;

      ElementType_t ElementType = MIXED ;

      DataArray_t<int, 1, ElementDataSize> ElementConnectivity =
        {{
        Data(int, 1, ElementDataSize) = (etype(j),(node(i,j),
             i=1,NPE[etype(j)]), j=1,25) ;
        }} ;
      }} ;
    }} ;

Axisymmetry Structure Definition: Axisymmetry_t

The Axisymmetry_t data structure allows recording the axis of rotation and the angle of rotation around this axis for a two-dimensional dataset that represents an axisymmetric database.

  Axisymmetry_t :=
    {
    List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)

    DataArray_t<real,1,2> AxisymmetryReferencePoint ;                  (r)
    DataArray_t<real,1,2> AxisymmetryAxisVector ;                      (r)
    DataArray_t<real,1,1> AxisymmetryAngle ;                           (o)
    DataArray_t<char,2,[32,2]> CoordinateNames ;                       (o)

    DataClass_t DataClass ;                                            (o)

    DimensionalUnits_t DimensionalUnits ;                              (o)

    List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
    } ;

1. Default names for the Descriptor_t and UserDefinedData_t lists are as shown; users may choose other legitimate names. Legitimate names must be unique within a given instance of Axisymmetry_t and shall not include the names AxisymmetryAngle, AxisymmetryAxisVector, AxisymmetryReferencePoint, CoordinateNames, DataClass, or DimensionalUnits.
2. AxisymmetryReferencePoint and AxisymmetryAxisVector are the required fields within the Axisymmetry_t structure.

AxisymmetryReferencePoint specifies the origin used for defining the axis of rotation.

AxisymmetryAxisVector contains the direction cosines of the axis of rotation, through the AxisymmetryReferencePoint. For example, for a 2-D dataset defined in the (x,y) plane, if AxisymmetryReferencePoint contains (0,0) and AxisymmetryAxisVector contains (1,0), the x-axis is the axis of rotation.

AxisymmetryAngle allows specification of the circumferential extent about the axis of rotation. If this angle is undefined, it is assumed to be 360°.

CoordinateNames may be used to specify the first and second coordinates used in the definition of AxisymmetryReferencePoint and AxisymmetryAxisVector. If not found, it is assumed that the first coordinate is CoordinateX and the second is CoordinateY. The coordinates given under CoordinateNames, or implied by using the default, must correspond to those found under GridCoordinates_t.

DataClass defines the default class for numerical data contained in the DataArray_t entities. For dimensional data, DimensionalUnits may be used to describe the system of units employed. If present, these two entities take precedence over the corresponding entities at higher levels of the CGNS hierarchy, following the standard precedence rules.

The UserDefinedData_t data structure allows arbitrary user-defined data to be stored in Descriptor_t and DataArray_t children without the restrictions or implicit meanings imposed on these node types at other node locations.

Rotating Coordinates Structure Definition: RotatingCoordinates_t

The RotatingCoordinates_t data structure is used to record the rotation center and rotation rate vector of a rotating coordinate system.

  RotatingCoordinates_t :=
    {
    List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)

    DataArray_t<real,1,PhysicalDimension> RotationCenter ;             (r)
    DataArray_t<real,1,PhysicalDimension> RotationRateVector ;         (r)

    DataClass_t DataClass ;                                            (o)

    DimensionalUnits_t DimensionalUnits ;                              (o)

    List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
    } ;

1. Default names for the Descriptor_t and UserDefinedData_t lists are as shown; users may choose other legitimate names. Legitimate names must be unique within a given instance of RotatingCoordinates_t and shall not include the names DataClass, DimensionalUnits, RotationCenter, or RotationRateVector.
2. RotationCenter and RotationRateVector are the required fields within the RotatingCoordinates_t structure.

RotationCenter specifies the coordinates of the center of rotation, and RotationRateVector specifies the components of the angular velocity of the grid about the center of rotation. Together, they define the angular velocity vector. The direction of the angular velocity vector specifies the axis of rotation, and its magnitude specifies the rate of rotation.

For example, for the common situation of rotation about the x-axis, RotationCenter would be specified as any point on the x-axis, like (0,0,0). RotationRateVector would then be specified as (ω,0,0), where ω is the rotation rate. Using the right-hand rule, ω would be positive for clockwise rotation (looking in the +x direction), and negative for counter-clockwise rotation.

Note that for a rotating coordinate system, the axis of rotation is defined in the inertial frame of reference, while the grid coordinates stored using the GridCoordinates_t data structure are relative to the rotating frame of reference.

DataClass defines the default class for data contained in the DataArray_t entities. For dimensional data, DimensionalUnits may be used to describe the system of units employed. If present, these two entities take precedence over the corresponding entities at higher levels of the CGNS hierarchy, following the standard precedence rules.

The UserDefinedData_t data structure allows arbitrary user-defined data to be stored in Descriptor_t and DataArray_t children without the restrictions or implicit meanings imposed on these node types at other node locations.

If rotating coordinates are used, it is useful to store variables relative to the rotating frame. Standardized data-name identifiers should be used for these variables, as defined for flow-solution quantities in the section Conventions for Data-Name Identifiers.

Flow Solution Structure Definition: FlowSolution_t

The flow solution within a given zone is described by the FlowSolution_t structure. This structure contains a list for the data arrays of the individual flow-solution variables, as well as identifying the grid location of the solution. It also provides a mechanism for identifying rind-point data included within the data arrays.

  FlowSolution_t< int IndexDimension, int VertexSize[IndexDimension], 
                  int CellSize[IndexDimension] > :=
    {
    List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)

    GridLocation_t GridLocation ;                                      (o/d)

    Rind_t<IndexDimension> Rind ;                                      (o/d)

    List( DataArray_t<DataType, IndexDimension, DataSize[]> 
          DataArray1 ... DataArrayN ) ;                                (o)

    DataClass_t DataClass ;                                            (o)
    
    DimensionalUnits_t DimensionalUnits ;                              (o)

    List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
    } ;

1. Default names for the Descriptor_t, DataArray_t, and UserDefinedData_t lists are as shown; users may choose other legitimate names. Legitimate names must be unique within a given instance of FlowSolution_t and shall not include the names DataClass, DimensionalUnits, GridLocation, or Rind.
2. There are no required fields for FlowSolution_t. GridLocation has a default of Vertex if absent. Rind also has a default if absent; the default is equivalent to having an instance of Rind whose RindPlanes array contains all zeros.
3. The structure parameter DataType must be consistent with the data stored in the DataArray_t structure entities; DataType is real for all flow-solution identifiers defined in the section Conventions for Data-Name Identifiers.
4. For unstructured zones GridLocation options are limited to Vertex or CellCenter, meaning that solution data may only be expressed at these locations. The data arrays must follow the node ordering if GridLocation = Vertex, and the element ordering if GridLocation = CellCenter.

FlowSolution_t requires three structure parameters; IndexDimension identifies the dimensionality of the grid-size arrays, and VertexSize and CellSize are the number of core vertices and cells, respectively, in each index direction. For unstructured zones, IndexDimension is always 1.

The flow solution data is stored in the list of DataArray_t entities; each DataArray_t structure entity may contain a single component of the solution vector. Standardized data-name identifiers for the flow-solution quantities are described in the section Conventions for Data-Name Identifiers. The field GridLocation specifies the location of the solution data with respect to the grid; if absent, the data is assumed to coincide with grid vertices (i.e., GridLocation = Vertex). All data within a given instance of FlowSolution_t must reside at the same grid location.

Rind is an optional field that indicates the number of rind planes (for structured grids) or rind points or elements (for unstructured grids) included in the data. Its purpose and function are identical to those described for the GridCoordinates_t structure. Note, however, that the Rind in this structure is independent of the Rind contained in GridCoordinates_t. They are not required to contain the same number of rind planes or elements. Also, the location of any flow-solution rind points is assumed to be consistent with the location of the core flow solution points (e.g., if GridLocation = CellCenter, rind points are assumed to be located at fictitious cell centers).

DataClass defines the default class for data contained in the DataArray_t entities. For dimensional flow solution data, DimensionalUnits may be used to describe the system of units employed. If present, these two entities take precedence over the corresponding entities at higher levels of the CGNS hierarchy, following the standard precedence rules.

The UserDefinedData_t data structure allows arbitrary user-defined data to be stored in Descriptor_t and DataArray_t children without the restrictions or implicit meanings imposed on these node types at other node locations.

FUNCTION DataSize[]:

The function DataSize[] is the size of flow solution data arrays. If Rind is absent then DataSize represents only the core points; it will be the same as VertexSize or CellSize depending on GridLocation. The definition of the function DataSize[] is as follows:

  if (Rind is absent) then
    {
    if (GridLocation = Vertex) or (GridLocation is absent)
      {
      DataSize[] = VertexSize[] ;
      }
    else if (GridLocation = CellCenter) then
      {
      DataSize[] = CellSize[] ;
      }
    }
  else if (Rind is present) then
    {
    if (GridLocation = Vertex) or (GridLocation is absent) then
      {
      DataSize[] = VertexSize[] + [a + b,...] ;
      }
    else if (GridLocation = CellCenter)
      {
      DataSize[] = CellSize[] + [a + b,...] ;
      }
    }

Flow Solution Example

This section contains an example of the flow solution entity, including the designation of grid location and rind planes and data-normalization mechanisms.

Example - Flow Solution

Conservation-equation variables (ρ, ρu, ρv, and ρe₀) for a 2-D grid of size 11 × 5. The flowfield is cell-centered with two planes of rind data. The density, momentum and stagnation energy (ρe₀) data is nondimensionalized with respect to a freestream reference state whose quantities are dimensional. The freestream density and pressure are used for normalization; these values are 1.226 kg/m³ and 1.0132×10⁵ N/m² (standard atmosphere conditions). The data-name identifier conventions for the conservation-equation variables are Density, MomentumX, MomentumY and EnergyStagnationDensity.

  !  IndexDimension = 2
  !  VertexSize = [11,5]
  !  CellSize = [10,4]
  FlowSolution_t<2, [11,5], [10,4]> FlowExample =
    {{
    GridLocation_t GridLocation = CellCenter ;

    Rind_t<2> Rind =
      {{
      int[4] RindPlanes = [2,2,2,2] ;
      }} ;

    DataClass_t DataClass = NormalizedByDimensional ;
    
    DimensionalUnits_t DimensionalUnits = 
      {{ 
      MassUnits        = Kilogram ;
      LengthUnits      = Meter ;
      TimeUnits        = Second ;
      TemperatureUnits = Null ;
      AngleUnits       = Null ;
      }} ;

    !  DataType = real
    !  Dimension = 2
    !  DataSize = CellSize + [4,4] = [14,8]
    DataArray_t<real, 2, [14,8]> Density =
      {{
      Data(real, 2, [14,8]) = ((rho(i,j), i=-1,12), j=-1,6) ;

      DataConversion_t DataConversion =
        {{
        ConversionScale  = 1.226 ;
        ConversionOffset = 0 ;
        }} ;

      DimensionalExponents_t DimensionalExponents =
        {{
        MassExponent        = +1 ;
        LengthExponent      = -3 ;
        TimeExponent        =  0 ;
        TemperatureExponent =  0 ;
        AngleExponent       =  0 ;
        }} ;
      }} ;

    DataArray_t<real, 2, [14,8]> MomentumX =
      {{
      Data(real, 2, [14,8]) = ((rho_u(i,j), i=-1,12), j=-1,6) ;

      DataConversion_t DataConversion =
        {{
        ConversionScale  = 352.446 ;
        ConversionOffset = 0 ;
        }} ;
      }} ;

    DataArray_t<real, 2, [14,8]> MomentumY =
      {{
      Data(real, 2, [14,8]) = ((rho_v(i,j), i=-1,12), j=-1,6) ;

      DataConversion_t DataConversion =
        {{
        ConversionScale  = 352.446 ;
        ConversionOffset = 0 ;
        }} ;
      }} ;

    DataArray_t<real, 2, [14,8]> EnergyStagnationDensity =
      {{
      Data(real, 2, [14,8]) = ((rho_e0(i,j), i=-1,12), j=-1,6) ;

      DataConversion_t DataConversion =
        {{
        ConversionScale  = 1.0132e+05 ;
        ConversionOffset = 0 ;
        }} ;
      }} ;
    }} ;

Since the data are all nondimensional and normalized by dimensional reference quantities, this information is stated in DataClass and DimensionalUnits at the FlowSolution_t level rather than attaching the appropriate DataClass and DimensionalUnits to each DataArray_t entity. It could possibly be at even higher levels in the heirarchy. The contents of DataConversion are in each case the denominator of the normalization; this is ρ_∞ for density, (p_∞ ρ_∞)^1/2 for momentum, and p_∞ for stagnation energy. The dimensional exponents are specified for density. For all the other data, the dimensional exponents are to be inferred from the data-name identifiers.

Note that no information is provided to identify the actual reference state or indicate that it is freestream. This information is not needed for data manipulations involving renormalization or changing the units of the converted raw data.