This section defines and describes low-level structures types that are used in the definition of more complex structures within the hierarchy.

`DataClass_t`

¶`DataClass_t`

is an enumeration type that identifies the class of a given piece of data.

```
DataClass_t := Enumeration(
DataClassNull,
DataClassUserDefined,
Dimensional,
NormalizedByDimensional,
NormalizedByUnknownDimensional,
NondimensionalParameter,
DimensionlessConstant ) ;
```

These classes divide data into different categories depending on dimensional units or normalization associated with the data.
`Dimensional`

specifies dimensional data. `NormalizedByDimensional`

specifies nondimensional data that is normalized by dimensional reference quantities.
In contrast, `NormalizedByUnknownDimensional`

specifies nondimensional data typically found in completely nondimensional databases, where all field and reference data is nondimensional.
`NondimensionalParameter`

specifies nondimensional parameters such as Mach number and lift coefficient.
Constants such as \(π\) are designated by `DimensionlessConstant`

.
The distinction between these different classes is further discussed in Data-Array Structure Definition.

`Descriptor_t`

¶`Descriptor_t`

is a documentation or annotation structure that contains a character string.
Characters allowed within the string include newlines, tabs and other special characters; this potentially allows for unlimited documentation inclusion within the database.
For example, a single `Descriptor_t`

structure could be used to “swallow” an entire ASCII file.
In the hierarchical structures defined in the next sections, each allows for the inclusion of multiple `Descriptor_t`

substructures.
Conventions could be made for names of often-used `Descriptor_t`

structure entities, such as *ReadMe* or *YouReallyWantToReadMeFirst*.

```
Descriptor_t :=
{
Data(char, 1, string_length) ; (r)
} ;
```

where `string_length`

is the length of the character string.

`DimensionalUnits_t`

¶`DimensionalUnits_t`

describes the system of units used to measure dimensional data. It is composed of a set of enumeration types that define the units for mass, length, time, temperature, angle, electric current, substance amount, and luminous intensity.

```
MassUnits_t := Enumeration( MassUnitsNull, MassUnitsUserDefined,
Kilogram, Gram, Slug, PoundMass ) ;
LengthUnits_t := Enumeration( LengthUnitsNull, LengthUnitsUserDefined,
Meter, Centimeter, Millimeter, Foot,
Inch ) ;
TimeUnits_t := Enumeration( TimeUnitsNull, TimeUnitsUserDefined,
Second ) ;
TemperatureUnits_t := Enumeration( TemperatureUnitsNull,
TemperatureUnitsUserDefined, Kelvin,
Celsius, Rankine, Fahrenheit ) ;
AngleUnits_t := Enumeration( AngleUnitsNull, AngleUnitsUserDefined,
Degree, Radian ) ;
ElectricCurrentUnits_t := Enumeration( ElectricCurrentUnitsNull,
ElectricCurrentUnitsUserDefined, Ampere,
Abampere, Statampere, Edison, auCurrent ) ;
SubstanceAmountUnits_t := Enumeration( SubstanceAmountUnitsNull,
SubstanceAmountUnitsUserDefined, Mole,
Entities, StandardCubicFoot,
StandardCubicMeter ) ;
LuminousIntensityUnits_t := Enumeration( LuminousIntensityUnitsNull,
LuminousIntensityUnitsUserDefined,
Candela, Candle, Carcel, Hefner, Violle ) ;
DimensionalUnits_t :=
{
MassUnits_t MassUnits ; (r)
LengthUnits_t LengthUnits ; (r)
TimeUnits_t TimeUnits ; (r)
TemperatureUnits_t TemperatureUnits ; (r)
AngleUnits_t AngleUnits ; (r)
AdditionalUnits_t := (o)
{
ElectricCurrentUnits_t ElectricCurrentUnits ; (r)
SubstanceAmountUnits_t SubstanceAmountUnits ; (r)
LuminousIntensityUnits_t LuminousIntensityUnits ; (r)
}
} ;
```

The International System (**SI**) uses the following units.

Physical Quantity |
Unit |
---|---|

Mass |
Kilogram |

Length |
Meter |

Time |
Second |

Temperature |
Kelvin |

Angle |
Radian |

Electric Current |
Ampere |

Substance Amount |
Mole |

Luminous Intensity |
Candela |

For an entity of type `DimensionalUnits_t`

, if all the elements of that entity have the value `Null`

(i.e., `MassUnits`

= `MassUnitsNull`

, etc.), this is equivalent to stating that the data described by the entity is nondimensionsal.

`DimensionalExponents_t`

¶`DimensionalExponents_t`

describes the dimensionality of data by defining the exponents associated with each of the fundamental units.

```
DimensionalExponents_t :=
{
real MassExponent ; (r)
real LengthExponent ; (r)
real TimeExponent ; (r)
real TemperatureExponent ; (r)
real AngleExponent ; (r)
AdditionalExponents_t := (o)
{
real ElectricCurrentExponent ; (r)
real SubstanceAmountExponent ; (r)
real LuminousIntensityExponent ; (r)
}
} ;
```

For example, an instance of `DimensionalExponents_t`

that describes velocity is,

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

`GridLocation_t`

¶`GridLocation_t`

identifies locations with respect to the grid; it is an enumeration type.

```
GridLocation_t := Enumeration(
GridLocationNull,
GridLocationUserDefined,
Vertex,
CellCenter,
FaceCenter,
IFaceCenter,
JFaceCenter,
KFaceCenter,
EdgeCenter ) ;
```

`Vertex`

is coincident with the grid vertices. `CellCenter`

is the center of a cell; this is also appropriate for entities associated with cells but not necessarily with a given location in a cell.
For structured zones, `IFaceCenter`

is the center of a face in 3-D whose computational normal points in the i direction.
`JFaceCenter`

and `KFaceCenter`

are similarly defined, again only for structured zones.
`FaceCenter`

is the center of a generic face that can point in any coordinate direction.
These are also appropriate for entities associated with a face, but not located at a specific place on the face.
`EdgeCenter`

is the center of an edge.
See Structured Grid Notation and Indexing Conventions for descriptions of cells, faces and edges.

All of the entities of type `GridLocation_t`

defined in this document use a default value of `Vertex`

.

`IndexArray_t`

¶`IndexArray_t`

specifies an array of indices.
An argument is included that allows for specifying the data type of each index;
typically the data type will be integer (`int`

).
`IndexArray_t`

defines an array of indices of size `ArraySize`

, where the dimension of each index is `IndexDimension`

.

```
IndexArray_t< int IndexDimension, int ArraySize, DataType > :=
{
Data( DataType, 2, [IndexDimension,ArraySize] ) ; (r)
} ;
```

`IndexRange_t`

¶`IndexRange_t`

specifies the beginning and ending indices of a subrange.
The subrange may describe a portion of a grid line, grid plane, or grid volume.

```
IndexRange_t< int IndexDimension > :=
{
int[IndexDimension] Begin ; (r)
int[IndexDimension] End ; (r)
} ;
```

where `Begin`

and `End`

are the indices of the opposing corners of the subrange.

`Rind_t`

¶`Rind_t`

describes the number of rind planes (for structured grids) or rind points and elements (for unstructured grids) associated with a data array containing grid coordinates, flow-solution data or any other grid-related discrete data.

```
Rind_t< int IndexDimension > :=
{
int[2*IndexDimension] RindPlanes ; (r)
} ;
```

For structured grids, `RindPlanes`

contains the number of rind planes attached to the minimum and maximum faces of a zone. The face corresponding to each index *n* of `RindPlanes`

in 3-D is:

n= 1 –> i-min

n= 2 –> i-max

n= 3 –> j-min

n= 4 –> j-max

n= 5 –> k-min

n= 6 –> k-max

For a 3-D grid whose “core” size is `II×JJ×KK`

, a value of `RindPlanes = [a,b,c,d,e,f]`

indicates that the range of indices for the grid with rind is:

i:

`(1 - a, II + b)`

j:

`(1 - c, JJ + d)`

k:

`(1 - e, KK + f)`

For unstructured grids, `RindPlanes`

does not actually contain planes, but rather contains the number of rind points or elements.
The points are defined by the grid coordinates rind node, and the elements by the element set rind node.
Note that to maintain consistency with the structured usage of `Rind_t`

, `RindPlanes`

is still dimensioned `2*IndexDimension`

for unstructured grids (and, for unstructured grids, `IndexDimension = 1`

).
The first `RindPlanes`

value is the number of rind nodes/elements stored before the core data, and the second is the number stored after.
Thus `RindPlanes[2] = {1 2}`

would mean there is one rind value before the core data, and two after the core data.
However, it is preferable to write all the rind points or elements at the end of the array; in other words, for unstructured grids `RindPlanes[2]`

should be set to `{0 nrind}`

, where `nrind`

is the number of rind points or elements.