Skip navigation links
(CGNS Documentation Home Page) (Steering Committee Charter) (Overview and Entry-Level Document) (A User's Guide to CGNS) (Mid-Level Library) (Standard Interface Data Structures) (SIDS File Mapping Manual) (CGIO User's Guide) (Parallel CGNS User's Guide) (ADF Implementation) (HDF5 Implementation) (Python Implementation) (CGNS Tools and Utilities)

(Introduction) (Design Philosophy of Standard Interface Data Structures) (Conventions) (Building-Block Structure Definitions) (Data-Array Structure Definitions) (Hierarchical Structures) (Grid Coordinates, Elements, and Flow Solution) (Multizone Interface Connectivity) (Boundary Conditions) (Governing Flow Equations) (Time-Dependent Flow) (Miscellaneous Data Structures) (Conventions for Data-Name Identifiers) (Structured Two-Zone Flat Plate Example)

4 Building-Block Structure Definitions

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( 
    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,
                                           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 nondimensional.

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( 
    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.