(CGNS Documentation Home Page) (Steering Committee Charter) (Overview and Entry-Level Document) (A User's Guide to CGNS) () (SIDS-to-ADF File Mapping Manual) (SIDS-to-HDF File Mapping Manual) (Mid-Level Library) (ADF User's Guide) (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) () (Time-Dependent Flow) (Miscellaneous Data Structures) (Conventions for Data-Name Identifiers) (Structured Two-Zone Flat Plate Example)

Governing Flow Equations

This section provides structure type definitions for describing the governing flow-equation set associated with the database. The description includes the general class of governing equations, the turbulent closure equations, the gas and chemistry models, the viscosity and thermal-conductivity models, and the electromagnetics models. Included with each equation description are associated constants. The structure definitions attempt to balance the opposing requirements for future growth and extensibility with initial ease of implementation. Included in the final section are examples of flow-equation sets.

The intended use of these structures initially is primarily for archival purposes and to provide additional documentation of the flow solution. If successful in this role, it is foreseeable that these flow-equation structures may eventually be also used as inputs for grid generators, flow solvers, and post-processors.

Flow Equation Set Structure Definition: FlowEquationSet_t

FlowEquationSet_t is a general description of the governing flow equations. It includes the dimensionality of the governing equations, and the collection of specific equation-set descriptions covered in subsequent sections. It can be a child node of either CGNSBase_t or Zone_t (or both).

```  FlowEquationSet_t< int CellDimension > :=
{
List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)

int EquationDimension ;                                            (o)

GoverningEquations_t<CellDimension> GoverningEquations ;           (o)

GasModel_t GasModel ;                                              (o)

ViscosityModel_t ViscosityModel ;                                  (o)

ThermalConductivityModel_t ThermalConductivityModel ;              (o)

TurbulenceClosure_t TurbulenceClosure ;                            (o)

TurbulenceModel_t<CellDimension> TurbulenceModel ;                 (o)

ThermalRelaxationModel_t ThermalRelaxationModel ;                  (o)

ChemicalKineticsModel_t ChemicalKineticsModel ;                    (o)

EMElectricFieldModel_t EMElectricFieldModel ;                      (o)

EMMagneticFieldModel_t EMMagneticFieldModel ;                      (o)

EMConductivityModel_t EMConductivityModel ;                        (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 FlowEquationSet_t and shall not include the names EMConductivityModel, EMElectricFieldModel, EMMagneticFieldModel, EquationDimension, GoverningEquations, GasModel, ViscosityModel, ThermalConductivityModel, TurbulenceClosure, TurbulenceModel, ThermalRelaxationModel, ChemicalKineticsModel, DataClass, or DimensionalUnits.
2. There are no required elements for FlowEquationSet_t.

FlowEquationSet_t requires a single structure parameter, CellDimension, to identify the dimensionality of index arrays for structured grids. This parameter is passed onto several substructures.

EquationDimension is the dimensionality of the governing equations; it is the number of spatial variables describing the flow. GoverningEquations describes the general class of flow equations. GasModel describes the equation of state, and ViscosityModel and ThermalConductivityModel describe the auxiliary relations for molecular viscosity and the thermal conductivity coefficient. TurbulenceClosure and TurbulenceModel describe the turbulent closure for the Reynolds-averaged Navier-Stokes equations. ThermalRelaxationModel and ChemicalKineticsModel describe the equations used to model thermal relaxation and chemical kinetics. EMElectricFieldModel, EMMagneticFieldModel, and EMConductivityModel describe the equations used to model electromagnetics.

DataClass defines the default for the class of data contained in the flow-equation set. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Governing Equations Structure Definition: GoverningEquations_t

GoverningEquations_t describes the class of governing flow equations associated with the solution.

```  GoverningEquationsType_t := Enumeration(
Null,
FullPotential,
Euler,
NSLaminar,
NSTurbulent,
NSLaminarIncompressible,
NSTurbulentIncompressible,
UserDefined ) ;

GoverningEquations_t< int CellDimension > :=
{
List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)

GoverningEquationsType_t GoverningEquationsType ;                  (r)

int[CellDimension*(CellDimension + 1)/2] DiffusionModel ;          (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 GoverningEquations_t and shall not include the name DiffusionModel.
2. GoverningEquationsType is the only required element.
3. The length of the DiffusionModel array is as follows: in 1-D it is int[1]; in 2-D it is int[3]; and in 3-D it is int[6]. For unstructured zones, DiffusionModel is not supported, and should not be used.

GoverningEquations_t requires a single structure parameter, CellDimension. It is used to define the length of the array DiffusionModel.

DiffusionModel describes the viscous diffusion terms modeled in the flow equations, and is applicable only to the Navier-Stokes equations with structured grids. Typically, thin-layer approximations include only the diffusion terms in one or two computational-coordinate directions. DiffusionModel encodes the coordinate directions that include second-derivative and cross-derivative diffusion terms. The first CellDimension elements are second-derivative terms and the remainder elements are cross-derivative terms. Allowed values for individual elements in the array DiffusionModel are 0 and 1; a value of 1 indicates the diffusion term is modeled, and 0 indicates that they are not modeled. In 3-D, the encoding of DiffusionModel is as follows:

Element Modeled Terms n = 1 Diffusion terms in i (∂2/∂ξ2) n = 2 Diffusion terms in j (∂2/∂η2) n = 3 Diffusion terms in k (∂2/∂ζ2) n = 4 Cross-diffusion terms in i-j (∂2/∂ξ ∂η and ∂2/∂η ∂ξ) n = 5 Cross-diffusion terms in j-k (∂2/∂η ∂ζ and ∂2/∂ζ ∂η) n = 6 Cross-diffusion terms in k-i (∂2/∂ζ ∂ξ and ∂2/∂ξ ∂ζ)

where derivatives in the i, j and k computational-coordinates are ξ, η and ζ, respectively. The full Navier-Stokes equations in 3-D are indicated by DiffusionModel = [1,1,1,1,1,1], and the thin-layer equations including only diffusion in the j-direction are [0,1,0,0,0,0].

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.

Thermodynamic Gas Model Structure Definition: GasModel_t

GasModel_t describes the equation of state model used in the governing equations to relate pressure, temperature and density.

```  GasModelType_t := Enumeration(
Null,
Ideal,
VanderWaals,
CaloricallyPerfect,
ThermallyPerfect,
ConstantDensity,
RedlichKwong,
UserDefined ) ;

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

GasModelType_t GasModelType ;                                      (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 GasModel_t and shall not include the names DataClass or DimensionalUnits.
2. GasModelType is the only required element.
3. The GasModelType enumeration name Ideal implies a calorically perfect single-component gas, but the more descriptive name CaloricallyPerfect is generally preferred.

For a perfect gas (GasModelType = CaloricallyPerfect), the pressure, temperature, and density are related by

p = ρRT

where R is the ideal gas constant. Related quantities are the specific heat at constant pressure (cp), specific heat at constant volume (cv) and specific heat ratio γ = cp/cv). The gas constant and specific heats are related by R = cpcv. Data-name identifiers associated with the perfect gas law are listed below.

Data-Name Identifier Description Units IdealGasConstant Ideal gas constant (R) L2/(T2Θ) SpecificHeatRatio Ratio of specific heats (γ = cp/cv) - SpecificHeatVolume Specific heat at constant volume (cv) L2/(T2Θ) SpecificHeatPressure Specific heat at constant pressure (cp) L2/(T2Θ)

If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArrays under GasModel_t.

The dimensional units are defined as follows: M is mass, L is length, T is time and Θ is temperature. These are further described in the section on Conventions for Data-Name Identifiers.

DataClass defines the default for the class of data contained in the thermodynamic gas model. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Molecular Viscosity Model Structure Definition: ViscosityModel_t

ViscosityModel_t describes the model for relating molecular viscosity (μ) to temperature.

```  ViscosityModelType_t := Enumeration(
Null,
Constant,
PowerLaw,
SutherlandLaw,
UserDefined ) ;

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

ViscosityModelType_t ViscosityModelType ;                          (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 ViscosityModel_t and shall not include the names DataClass or DimensionalUnits.
2. ViscosityModelType is the only required element.

The molecular viscosity models are as follows: Constant states that molecular viscosity is constant throughout the field and is equal to some reference value (μ = μref); PowerLaw states that molecular viscosity follows a power-law relation,

μ = μref (T/Tref)n

and SutherlandLaw is Sutherland's Law for molecular viscosity,

μ = μref (T/Tref)3/2 (Tref + Ts) / (T + Ts)

where Ts is the Sutherland's Law constant, and μref and Tref are the reference viscosity and temperature, respectively. For air [White, F. M., Viscous Fluid Flow, McGraw-Hill, 1974, p. 28-29], the power-law exponent is n = 0.666, Sutherland's law constant (Ts) is 110.6 K, the reference temperature (Tref) is 273.15 K, and the reference viscosity (μref) is 1.716 × 10-5 kg/(m-s). The data-name identifiers for molecular viscosity models are defined below.

ViscosityModelType Data-Name Identifier Description Units PowerLaw PowerLawExponent Power-law exponent (n) - SutherlandLaw SutherlandLawConstant Sutherland's Law constant (Ts) Θ All TemperatureReference Reference temperature (Tref) Θ All ViscosityMolecularReference Reference viscosity (μref) M/(LT)

If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArrays under ViscosityModel_t.

DataClass defines the default for the class of data contained in the molecular viscosity model. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Thermal Conductivity Model Structure Definition: ThermalConductivityModel_t

ThermalConductivityModel_t describes the model for relating the thermal-conductivity coefficient (k) to temperature.

```  ThermalConductivityModelType_t := Enumeration(
Null,
ConstantPrandtl,
PowerLaw,
SutherlandLaw,
UserDefined ) ;

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

ThermalConductivityModelType_t ThermalConductivityModelType ;      (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 ThermalConductivityModel_t and shall not include the names DataClass or DimensionalUnits.
2. ThermalConductivityModelType is the only required element.

The thermal-conductivity models parallel the molecular viscosity models. ConstantPrandtl states that the Prandtl number (Pr = μcp/k) is constant and equal to some reference value. PowerLaw relates k to temperature via a power-law relation,

k = kref (T/Tref)n

and SutherlandLaw is Sutherland's Law for molecular viscosity,

k = kref (T/Tref)3/2 (Tref + Ts) / (T + Ts)

where kref is the reference thermal conductivity, Tref is the reference temperature, and Ts is the Sutherland's law constant. For air [White, F. M., Viscous Fluid Flow, McGraw-Hill, 1974, p. 32-33], the Prandtl number is Pr = 0.72, the power-law exponent is n = 0.81, Sutherland's law constant (Ts) is 194.4 K, the reference temperature (Tref) is 273.15 K, and the reference thermal conductivity (kref) is 2.414 × 10-2 kg-m/(s3-K). Data-name identifiers for thermal conductivity models are listed below.

ThermalConduc- Data-Name Identifier Description Units tivityModelType ConstantPrandtl Prandtl Prandtl number (Pr) - PowerLaw PowerLawExponent Power-law exponent (n) - SutherlandLaw SutherlandLawConstant Sutherland's Law constant (Ts) Θ All TemperatureReference Reference temperature (Tref) Θ All ThermalConductivityReference Reference thermal conductivity (kref) ML/(T3 Θ)

If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArrays under ThermalConductivityModel_t.

DataClass defines the default for the class of data contained in the thermal conductivity model. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Turbulence Structure Definitions

This section presents structure definitions for describing the form of closure used in the Reynolds-averaged (or Favre-averaged) Navier-Stokes equations for determining the Reynolds stress terms. Here "turbulence closure" refers to eddy viscosity or other approximations for the Reynolds stress terms, and "turbulence model" refers to the actual algebraic or turbulence-transport equation models used. To an extent these are independent choices (e.g., using either an eddy viscosity closure or an algebraic Reynolds-stress closure with a two-equation model).

Turbulence Closure Structure Definition: TurbulenceClosure_t

TurbulenceClosure_t describes the turbulence closure for the Reynolds stress terms of the Navier-Stokes equations.

```  TurbulenceClosureType_t := Enumeration(
Null,
EddyViscosity,
ReynoldsStress,
ReynoldsStressAlgebraic,
UserDefined ) ;

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

TurbulenceClosureType_t TurbulenceClosureType ;                    (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 TurbulenceClosure_t and shall not include the names DataClass or DimensionalUnits.
2. TurbulenceClosureType is the only required element.

The different types of turbulent closure are as follows: EddyViscosity is the Boussinesq eddy-viscosity closure, where the Reynolds stresses are approximated as the product of an eddy viscosity (νt) and the mean strain tensor. Using indicial notation, the relation is,

−(uiuj)ave = νt ( ∂ui / ∂xj + ∂uj / ∂xi )

where −(uiuj)ave are the Reynolds stresses; the notation is further discussed under Flowfield Solution in the section on Conventions for Data-Name Identifiers. ReynoldsStress is no approximation of the Reynolds stresses. ReynoldsStressAlgebraic is an algebraic approximation for the Reynolds stresses based on some intermediate transport quantities.

Associated with the turbulent closure is a list of constants, where each constant is described by a separate DataArray_t entity. Constants associated with the eddy-viscosity closure are listed below.

Data-Name Identifier Description Units PrandtlTurbulent Turbulent Prandtl number (ρ νt cp / kt) -

If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArrays under TurbulenceClosure_t.

DataClass defines the default for the class of data contained in the turbulence closure. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Turbulence Model Structure Definition: TurbulenceModel_t

TurbulenceModel_t describes the equation set used to model the turbulence quantities.

```  TurbulenceModelType_t := Enumeration(
Null,
Algebraic_BaldwinLomax,
Algebraic_CebeciSmith,
HalfEquation_JohnsonKing,
OneEquation_BaldwinBarth,
OneEquation_SpalartAllmaras,
TwoEquation_JonesLaunder,
TwoEquation_Wilcox,
UserDefined ) ;

TurbulenceModel_t< int CellDimension > :=
{
List( Descriptor_t Descriptor1 ... DescriptorN ) ;                 (o)

TurbulenceModelType_t TurbulenceModelType ;                        (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

int[CellDimension*(CellDimension + 1)/2] DiffusionModel ;          (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 TurbulenceModel_t and shall not include the names DiffusionModel, DataClass, or DimensionalUnits.
2. TurbulenceModelType is the only required element.
3. The length of the DiffusionModel array is as follows: in 1-D it is int[1]; in 2-D it is int[3]; and in 3-D it is int[6]. For unstructured zones, DiffusionModel is not supported, and should not be used.

TurbulenceModel_t requires a single structure parameter, CellDimension. It is used to define the length of the array DiffusionModel. DiffusionModel describes the viscous diffusion terms included in the turbulent transport model equations.

The TurbulenceModelType names currently listed correspond to the following particular references.

 Algebraic_BaldwinLomax Baldwin, B. S., and Lomax, H. (1978) "Thin Layer Approximations and Algebraic Model for Separated Turbulent Flows," AIAA Paper 78-257. Algebraic_CebeciSmith Cebeci, T., and Smith, A. M. O. (1974) Analysis of Turbulent Boundary Layers, Academic Press, New York. HalfEquation_JohnsonKing Johnson, D., and King, L. (1985) "A Mathematically Simple Turbulence Closure Model for Attached and Separated Turbulent Boundary Layers," AIAA Journal, Vol. 23, No. 11, pp. 1684-1692. OneEquation_BaldwinBarth Baldwin, B., and Barth, T. (1990) "A One-Equation Turbulent Transport Model for High Reynolds Number Wall-Bounded Flows," NASA TM-102847. OneEquation_SpalartAllmaras Spalart, P. R., and Allmaras, S. R. (1994) "A One-Equation Turbulence Model for Aerodynamic Flows," La Recherche Aerospatiale, Vol. 1, pp. 5-21. TwoEquation_JonesLaunder Jones, W., and Launder, B. (1972) "The Prediction of Laminarization with a Two-Equation Model of Turbulence," International Journal of Heat and Mass Transfer, Vol. 15, pp. 301-314. TwoEquation_MenterSST Menter, F. R. (1994) "Two-Equation Eddy-Viscosity Turbulence Models for Engineering Application," AIAA Journal, Vol. 32, No. 8, pp. 1598-1605. TwoEquation_Wilcox Wilcox, D. C. (1994) Turbulence Modeling for CFD, First Edition, DCW Industries, La Canada, California.

There is no formal mechanism for accounting for subsequent changes to these models. (For example, Wilcox later published 1998 and 2006 versions of his k-ω model). If it is a mere change to constant(s), then this could be described by retaining the same TurbulenceModelType name and listing each constant using a separate DataArray_t entry. If the change is more involved, then it is recommended to employ TurbulenceModelType = UserDefined with a child Descriptor_t node giving details about it.

Associated with each choice of turbulence model may be a list of constants, where each constant is described by a separate DataArray_t entity. If used, the Data-Name Identifier of each constant should include the turbulence model name, as well as the constant name (e.g., TurbulentSACb1, TurbulentSSTCmu, TurbulentKESigmak, etc.). However, no attempt is made here to formalize the names for all possible turbulence models.

DataClass defines the default for the class of data contained in the turbulence model equation set. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Example - Spalart-Allmaras Turbulence Model

Description for the eddy-viscosity closure and Spalart-Allmaras turbulence model, including associated constants.

```  TurbulenceClosure_t TurbulenceClosure =
{{
TurbulenceClosureType_t TurbulenceClosureType = EddyViscosity ;

DataArray_t<real, 1, 1> PrandtlTurbulent = {{ 0.90 }} ;
}} ;

TurbulenceModel_t TurbulenceModel =
{{
TurbulenceModelType_t TurbulenceModelType = OneEquation_SpalartAllmaras ;

DataArray_t<real, 1, 1> TurbulentSACb1   = {{ 0.1355 }} ;
DataArray_t<real, 1, 1> TurbulentSACb2   = {{ 0.622 }} ;
DataArray_t<real, 1, 1> TurbulentSASigma = {{ 2/3 }} ;
DataArray_t<real, 1, 1> TurbulentSAKappa = {{ 0.41 }} ;
DataArray_t<real, 1, 1> TurbulentSACw1   = {{ 3.2391 }} ;
DataArray_t<real, 1, 1> TurbulentSACw2   = {{ 0.3 }} ;
DataArray_t<real, 1, 1> TurbulentSACw3   = {{ 2 }} ;
DataArray_t<real, 1, 1> TurbulentSACv1   = {{ 7.1 }} ;
DataArray_t<real, 1, 1> TurbulentSACt1   = {{ 1 }} ;
DataArray_t<real, 1, 1> TurbulentSACt2   = {{ 2 }} ;
DataArray_t<real, 1, 1> TurbulentSACt3   = {{ 1.2 }} ;
DataArray_t<real, 1, 1> TurbulentSACt4   = {{ 0.5 }} ;
}} ;
```
Note that each DataArray_t entity is abbreviated.

Thermal Relaxation Model Structure Definition: ThermalRelaxationModel_t

ThermalRelaxationModel_t describes the equation set used to model thermal relaxation quantities.

```  ThermalRelaxationModelType_t := Enumeration(
Null,
Frozen,
ThermalEquilib,
ThermalNonequilib,
UserDefined ) ;

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

ThermalRelaxationModelType_t ThermalRelaxationModelType ;          (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 ThermalRelaxationModel_t and shall not include the names DataClass or DimensionalUnits.
2. ThermalRelaxationModelType is the only required element.

ThermalRelaxationModelType_t is an enumeration type describing the type of thermal relaxation model.

DataArray_t data structures may be used to store data associated with the thermal relaxation model. DataClass defines the default for the class of data being used. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the hierarchy, following the standard precedence rules.

Additional information, if needed, may be stored using Descriptor_t data structures.

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.

Chemical Kinetics Model Structure Definition: ChemicalKineticsModel_t

ChemicalKineticsModel_t describes the equation set used to model chemical kinetics quantities.

```  ChemicalKineticsModelType_t := Enumeration(
Null,
Frozen,
ChemicalEquilibCurveFit,
ChemicalEquilibMinimization,
ChemicalNonequilib,
UserDefined ) ;

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

ChemicalKineticsModelType_t ChemicalKineticsModelType ;            (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 ChemicalKineticsModel_t and shall not include the names DataClass or DimensionalUnits.
2. ChemicalKineticsModelType is the only required element.

ChemicalKineticsModelType_t is an enumeration type describing the type of chemical kinetics model.

DataArray_t data structures may be used to store data associated with the chemical kinetics model. Recommended data-name identifiers are listed in the following table.

Data-Name Identifier Description Units MolecularWeightSymbol Molecular weight for species Symbol - HeatOfFormationSymbol Heat of formation per unit mass for species Symbol L2/T2 FuelAirRatio Fuel/air mass ratio - ReferenceTemperatureHOF Reference temperature for the heat of formation Θ

The dimensional units are defined as follows: L is length, T is time and Θ is temperature. These are further described in the section on Conventions for Data-Name Identifiers.

The variable string Symbol in the above data-name identifiers represents the chemical symbol for the desired species. For example, H represents hydrogen atoms, O represents oxygen atoms, H2 represents hydrogen molecules, H2O represents water molecules, and C3H5O3(NO2)3 represents nitroglycerin molecules. Any symbols off the periodic table of the elements can be used. For charged molecules or particles, the word "plus" or "minus" should be spelled out in lower case. For example, a CNO+ molecule should be denoted as CNOplus.

Other commonly used mixtures, that are usually not referred to by their chemical symbols, are defined in the following table. Individual users may define new names, but these may not be recognized by other CGNS applications. For consistency, additional names should be proposed as SIDS extensions.

Symbol Mixture Air Generic air model eminus Electrons Fuel Generic fuel model FuelAir Generic fuel/air mixture JP5 JP5 jet fuel JP7 JP7 jet fuel JP10 JP10 jet fuel Product Generic fuel/air product of combustion RP1 RP1 rocket fuel

DataClass defines the default for the class of data being used. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the hierarchy, following the standard precedence rules.

Additional information, if needed, may be stored using Descriptor_t data structures. For example, if CHEMKIN is used, it is recommended that a Descriptor_t data structure be used to indicate this. Reaction equations could also be specified using Descriptor_t data structures.

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.

Electromagnetics Structure Definitions

This section presents structure definitions for describing the electric field, magnetic field, and conductivity models used for electromagnetic flows.

Electromagnetics Electric Field Model Structure Definition: EMElectricFieldModel_t

EMElectricFieldModel_t describes the electric field model used for electromagnetic flows.

```  EMElectricFieldModelType_t := Enumeration(
Null,
Constant,
Frozen,
Interpolated,
Voltage,
UserDefined ) ;

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

EMElectricFieldModelType_t EMElectricFieldModelType ;              (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 EMElectricFieldModel_t and shall not include the names DataClass or DimensionalUnits.
2. EMElectricFieldModelType is the only required element.

EMElectricFieldModelType_t is an enumeration type describing the type of electric field model.

DataArray_t data structures may be used to store data associated with the electric field model. Recommended data-name identifiers are listed in the section describing the electromagnetics conductivity model.

DataClass defines the default for the class of data contained in the electric field model. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Electromagnetics Magnetic Field Model Structure Definition: EMMagneticFieldModel_t

EMMagneticFieldModel_t describes the magnetic field model used for electromagnetic flows.

```  EMMagneticFieldModelType_t := Enumeration(
Null,
Constant,
Frozen,
Interpolated,
UserDefined ) ;

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

EMMagneticFieldModelType_t EMMagneticFieldModelType ;              (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 EMMagneticFieldModel_t and shall not include the names DataClass or DimensionalUnits.
2. EMMagneticFieldModelType is the only required element.

EMMagneticFieldModelType_t is an enumeration type describing the type of magnetic field model.

DataArray_t data structures may be used to store data associated with the magnetic field model. Recommended data-name identifiers are listed in the section describing the electromagnetics conductivity model.

DataClass defines the default for the class of data contained in the magnetic field model. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Electromagnetics Conductivity Model Structure Definition: EMConductivityModel_t

EMConductivityModel_t describes the conductivity model used for electromagnetic flows.

```  EMConductivityModelType_t := Enumeration(
Null,
Constant,
Frozen,
Equilibrium_LinRessler,
Chemistry_LinRessler,
UserDefined ) ;

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

EMConductivityModelType_t EMConductivityModelType ;                (r)

List( DataArray_t<DataType, 1, 1> DataArray1 ... DataArrayN ) ;    (o)

DataClass_t DataClass ;                                            (o)

DimensionalUnits_t DimensionalUnits ;                              (o)

List( UserDefinedData_t UserDefinedData1 ... UserDefinedDataN ) ;  (o)
} ;
```
Notes
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 EMConductivityModel_t and shall not include the names DataClass or DimensionalUnits.
2. EMConductivityModelType is the only required element.

EMConductivityModelType_t is an enumeration type describing the type of conductivity model.

DataArray_t data structures may be used to store data associated with the conductivity model. Recommended data-name identifiers for all three electromagnetics models are listed in the following table.

Data-Name Identifier Description Units Voltage Voltage ML2/TI ElectricFieldX x-component of electric field vector ML/TI ElectricFieldY y-component of electric field vector ML/TI ElectricFieldZ z-component of electric field vector ML/TI MagneticFieldX x-component of magnetic field vector I/L MagneticFieldY y-component of magnetic field vector I/L MagneticFieldZ z-component of magnetic field vector I/L CurrentDensityX x-component of current density vector I/L2 CurrentDensityY y-component of current density vector I/L2 CurrentDensityZ z-component of current density vector I/L2 ElectricConductivity Electrical conductivity ML/T3I2 LorentzForceX x-component of Lorentz force vector ML/T2 LorentzForceY y-component of Lorentz force vector ML/T2 LorentzForceZ z-component of Lorentz force vector ML/T2 JouleHeating Joule heating ML2/T2

The dimensional units are defined as follows: M is mass, L is length, T is time, and I is electric current. These are further described in the section on Conventions for Data-Name Identifiers.

DataClass defines the default for the class of data contained in the conductivity model. For any data that is dimensional, DimensionalUnits may be used to describe the system of dimensional units employed. If present, these two entities take precedence of all corresponding entities at higher levels of the 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.

Flow Equation Examples

This section presents two examples of flow-equation sets. The first is an inviscid case and the second is a turbulent case with a one-equation turbulence model.

Example - 3-D Compressible Euler

3-D compressible Euler with a perfect gas assumption for a monatomic gas:

```  FlowEquationSet_t<3> EulerEquations =
{{
int EquationDimension = 3 ;

GoverningEquations_t<3> GoverningEquations =
{{
GoverningEquationsType_t GoverningEquationsType = Euler ;
}} ;

GasModel_t GasModel =
{{
GasModelType_t GasModelType = CaloricallyPerfect ;

DataArray_t<real, 1, 1> SpecificHeatRatio =
{{
Data(real, 1, 1) = 1.667 ;

DataClass_t DataClass = NondimensionalParameter ;
}} ;
}} ;
}} ;
```

Example - 3-D Compressible Navier-Stokes

3-D compressible Navier-Stokes for a structured grid, with the S-A turbulence model, a perfect gas assumption, Sutherland's law for the molecular viscosity, a constant Prandtl-number assumption, and inclusion of the full Navier-Stokes diffusion terms; all models assume air:

```  FlowEquationSet_t<3> NSEquations =
{{
int EquationDimension = 3 ;

GoverningEquations_t<3> GoverningEquations =
{{
GoverningEquationsType_t GoverningEquationsType = NSTurbulent ;

int[6] DiffusionModel = [1,1,1,1,1,1] ;
}} ;

GasModel_t GasModel =
{{
GasModelType_t GasModelType = CaloricallyPerfect ;

DataArray_t<real, 1, 1> SpecificHeatRatio = {{ 1.4 }} ;
}} ;

ViscosityModel_t ViscosityModel =
{{
ViscosityModelType_t ViscosityModelType = SutherlandLaw ;

DataArray_t<real, 1, 1> SutherlandLawConstant =
{{
Data(real, 1, 1) = 110.6 }} ;

DataClass_t DataClass = Dimensional ;
DimensionalUnits_t DimensionalUnits = {{ TemperatureUnits = Kelvin }} ;
}} ;
}} ;

ThermalConductivityModel_t ThermalConductivityModel =
{{
ThermalConductivityModelType_t ThermalConductivityModelType =
ConstantPrandtl ;

DataArray_t<real, 1, 1> Prandtl = {{ 0.72 }} ;
}} ;

TurbulenceClosure_t<3> TurbulenceClosure =
{{
TurbulenceClosureType_t TurbulenceClosureType = EddyViscosity ;

DataArray_t<real, 1, 1> PrandtlTurbulent = {{ 0.90 }} ;
}} ;

TurbulenceModel_t<3> TurbulenceModel =
{{
TurbulenceModelType_t TurbulenceModelType = OneEquation_SpalartAllmaras ;

int[6] DiffusionModel = [1,1,1,1,1,1] ;
}} ;
}} ;
```
Note that all DataArray_t entities are abbreviated except SutherlandLawConstant.