4. Building Block Structure Definition#
This section defines and describes low-level structures types that are used in the definition of more complex structures within the hierarchy.
4.1. Definition 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.
4.2. 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.
4.3. Definition 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.
4.4. Definition 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 ;
}} ;
4.5. Definition 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.
4.6. Definition 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)
} ;
4.7. Definition 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.
4.8. Definition 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.