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.
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)
} ;
Note
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.
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 over 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.
GoverningEquations_t¶GoverningEquations_t describes the class of governing flow equations associated with the solution.
GoverningEquationsType_t := Enumeration(
GoverningEquationsTypeNull,
GoverningEquationsTypeUserDefined,
FullPotential,
Euler,
NSLaminar,
NSTurbulent,
NSLaminarIncompressible,
NSTurbulentIncompressible ) ;
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)
} ;
Note
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.
GoverningEquationsType is the only required element.
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 (\(\partial^2 / \partial \xi^{2}\)) |
n = 2 |
Diffusion terms in j (\(\partial^2 / \partial \eta^{2}\)) |
n = 3 |
Diffusion terms in k (\(\partial^2 / \partial \zeta^{2}\)) |
n = 4 |
Cross-diffusion terms in i-j (\(\partial^2/\partial \xi \partial \eta\) and \(\partial^2 / \partial \eta \partial \xi\)) |
n = 5 |
Cross-diffusion terms in j-k (\(\partial^2/\partial \eta \partial \zeta\) and \(\partial^2/\partial \zeta \partial \eta\)) |
n = 6 |
Cross-diffusion terms in k-i (\(\partial^2/\partial \zeta \partial \xi\) and \(\partial^2/\partial \xi \partial \zeta\)) |
where derivatives in the i, j and k computational-coordinates are \(\xi\), \(eta\) and \(zeta\), 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.
ModelType_t¶ModelType_t is a complete list of all models covered in subsequent sections. A specific model will contain a subset of this enumeration.
ModelType_t := Enumeration(
ModelTypeNull, ModelTypeUserDefined,
Ideal, VanderWaals, Constant, PowerLaw,
SutherlandLaw, ConstantPrandtl, EddyViscosity,
ReynoldsStress, ReynoldsStressAlgebraic,
Algebraic_BaldwinLomax, Algebraic_CebeciSmith,
HalfEquation_JohnsonKing, OneEquation_BaldwinBarth,
OneEquation_SpalartAllmaras, TwoEquation_JonesLaunder,
TwoEquation_MenterSST, TwoEquation_Wilcox,
CaloricallyPerfect, ThermallyPerfect, ConstantDensity,
RedlichKwong, Frozen, ThermalEquilib, ThermalNonequilib,
ChemicalEquilibCurveFit, ChemicalEquilibMinimization,
ChemicalNonequilib, EMElectricField, EMMagneticField,
EMConductivity, Voltage, Interpolated,
Equilibrium_LinRessler, Chemistry_LinRessler ) ;
GasModel_t¶GasModel_t describes the equation of state model used in the governing equations to relate pressure, temperature and density. The enumerated values for GasModelType_t are a subset of the ModelType_t enumeration.
GasModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Ideal,
VanderWaals,
CaloricallyPerfect,
ThermallyPerfect,
ConstantDensity,
RedlichKwong ) ;
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)
} ;
Note
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.
GasModelType is the only required element.
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
where \(R\) is the ideal gas constant. Related quantities are the specific heat at constant pressure (\(c_{p}\)), specific heat at constant volume (\(c_{v}\)) and specific heat ratio \(\gamma = c_{p}/c_{v}\)). The gas constant and specific heats are related by \(R = c_{p} − c_{v}\). Data-name identifiers associated with the perfect gas law are listed below.
Data-Name Identifier |
Description |
Units |
|---|---|---|
IdealGasConstant |
Ideal gas constant (\(R\)) |
\(L^2/(T^2 \Theta)\) |
SpecificHeatRatio |
Ratio of specific heats (\(\gamma = c_{p}/c_{v}\)) |
- |
SpecificHeatVolume |
Specific heat at constant volume (\(c_{v}\)) |
\(L^2/(T^2 \Theta)\) |
SpecificHeatPressure |
Specific heat at constant pressure (\(c_{p}\)) |
\(L^2/(T^2 \Theta)\) |
If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArray under GasModel_t.
The dimensional units are defined as follows: \(M\) is mass, \(L\) is length, \(T\) is time and \(\Theta\) 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 over 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.
ViscosityModel_t¶ViscosityModel_t describes the model for relating molecular viscosity (\(\mu\)) to temperature. The enumerated values for ViscosityModelType_t are a subset of the ModelType_t enumeration.
ViscosityModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Constant,
PowerLaw,
SutherlandLaw ) ;
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)
} ;
Note
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.
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 (\(\mu = \mu_{ref}\)); PowerLaw states that molecular viscosity follows a power-law relation,
and SutherlandLaw is Sutherland’s Law for molecular viscosity,
where \(T_{s}\) is the Sutherland’s Law constant, and \(\mu_{ref}\) and \(T_{ref}\) 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 (\(T_{s}\)) is 110.6 K, the reference temperature (\(T_{ref}\)) is 273.15 K, and the reference viscosity (\(\mu_{ref}\)) is \(1.716 \times 10^{-5}\ kg/(m s)\). The data-name identifiers for molecular viscosity models are defined below.
|
Data-Name Identifier |
Description |
Units |
|---|---|---|---|
|
|
Power-law exponent (n) |
- |
|
|
Sutherland’s Law constant (\(T_{s}\)) |
\(\Theta\) |
All |
|
Reference temperature (\(T_{ref}\)) |
\(\Theta\) |
All |
|
Reference viscosity (\(\mu_{ref}\)) |
\(M/(LT)\) |
If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArray 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 over 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.
ThermalConductivityModel_t¶ThermalConductivityModel_t describes the model for relating the thermal-conductivity coefficient (\(k\)) to temperature. The enumerated values for ThermalConductivityModelType_t are a subset of the ModelType_t enumeration.
ThermalConductivityModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
ConstantPrandtl,
PowerLaw,
SutherlandLaw ) ;
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)
} ;
Note
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.
ThermalConductivityModelType is the only required element.
The thermal-conductivity models parallel the molecular viscosity models. ConstantPrandtl states that the Prandtl number (\(Pr = \mu c_{p}/k\)) is constant and equal to some reference value.
PowerLaw relates \(k\) to temperature via a power-law relation,
and SutherlandLaw is Sutherland’s Law for molecular viscosity,
where \(k_{ref}\) is the reference thermal conductivity, \(T_{ref}\) is the reference temperature, and \(T_{s}\) 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 (\(T_{s}\)) is 194.4 K, the reference temperature (\(T_{ref}\)) is 273.15 K, and the reference thermal conductivity (\(k_{ref}\)) is \(2.414 \times 10^{-2}\ kg\ m/(s^{3} K)\). Data-name identifiers for thermal conductivity models are listed below.
|
Data-Name Identifier |
Description |
Units |
|---|---|---|---|
|
|
Prandtl number (\(Pr\)) |
\(-\) |
|
|
Power-law exponent (\(n\)) |
\(-\) |
|
|
Sutherland’s Law constant (\(T_{s}\)) |
\(\Theta\) |
All |
|
Reference temperature (\(T_{ref}\)) |
\(\Theta\) |
All |
|
Reference thermal conductivity (\(k_{ref}\)) |
\(M L/(T^{3} \Theta)\) |
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 over 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.
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).
TurbulenceClosure_t¶TurbulenceClosure_t describes the turbulence closure for the Reynolds stress terms of the Navier-Stokes equations. The enumerated values for TurbulenceClosureType_t are a subset of the ModelType_t enumeration.
TurbulenceClosureType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
EddyViscosity,
ReynoldsStress,
ReynoldsStressAlgebraic ) ;
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)
} ;
Note
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.
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 (\(nu_{t}\)) and the mean strain tensor. Using indicial notation, the relation is,
where \(−(u′_{i} u′_{j})_{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 |
|---|---|---|
|
Turbulent Prandtl number (\(\rho \nu_{t} c_{p} / k_{t}\)) |
\(-\) |
If it is desired to specify any of these identifiers in a CGNS database, they should be defined as DataArray 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 over 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.
TurbulenceModel_t¶TurbulenceModel_t describes the equation set used to model the turbulence quantities. The enumerated values for TurbulenceModelType_t are a subset of the ModelType_t enumeration.
TurbulenceModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Algebraic_BaldwinLomax,
Algebraic_CebeciSmith,
HalfEquation_JohnsonKing,
OneEquation_BaldwinBarth,
OneEquation_SpalartAllmaras,
TwoEquation_JonesLaunder,
TwoEquation_MenterSST,
TwoEquation_Wilcox ) ;
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)
} ;
Note
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.
TurbulenceModelType is the only required element.
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.
|
Baldwin, B. S., and Lomax, H. (1978) “Thin Layer Approximations and Algebraic Model for Separated Turbulent Flows,” AIAA Paper 78-257. |
|
Cebeci, T., and Smith, A. M. O. (1974) Analysis of Turbulent Boundary Layers, Academic Press, New York. |
|
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. |
|
Baldwin, B., and Barth, T. (1990) “A One-Equation Turbulent Transport Model for High Reynolds Number Wall-Bounded Flows,” NASA TM-102847. |
|
Spalart, P. R., and Allmaras, S. R. (1994) “A One-Equation Turbulence Model for Aerodynamic Flows,” La Recherche Aerospatiale, Vol. 1, pp. 5-21. |
|
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. |
|
Menter, F. R. (1994) “Two-Equation Eddy-Viscosity Turbulence Models for Engineering Application,” AIAA Journal, Vol. 32, No. 8, pp. 1598-1605. |
|
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 over 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.
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.
ThermalRelaxationModel_t¶ThermalRelaxationModel_t describes the equation set used to model thermal relaxation quantities. The enumerated values for ThermalRelaxationModelType_t are a subset of the ModelType_t enumeration.
ThermalRelaxationModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Frozen,
ThermalEquilib,
ThermalNonequilib ) ;
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)
} ;
Note
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.
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 over 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.
ChemicalKineticsModel_t¶ChemicalKineticsModel_t describes the equation set used to model chemical kinetics quantities. The enumerated values for ChemicalKineticsModelType_t are a subset of the ModelType_t enumeration.
ChemicalKineticsModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Frozen,
ChemicalEquilibCurveFit,
ChemicalEquilibMinimization,
ChemicalNonequilib ) ;
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)
} ;
Note
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.
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 |
|---|---|---|
|
Molecular weight for species Symbol |
\(-\) |
|
Heat of formation per unit mass for species Symbol |
\(L^{2}/T^{2}\) |
|
Fuel/air mass ratio |
\(-\) |
|
Reference temperature for the heat of formation |
\(\Theta\) |
The dimensional units are defined as follows: \(L\) is length, \(T\) is time and \(\Theta\) 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 from 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 |
|---|---|
|
Generic air model |
|
Electrons |
|
Generic fuel model |
|
Generic fuel/air mixture |
|
JP5 jet fuel |
|
JP7 jet fuel |
|
JP10 jet fuel |
|
Generic fuel/air product of combustion |
|
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 over 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.
This section presents structure definitions for describing the electric field, magnetic field, and conductivity models used for electromagnetic flows.
EMElectricFieldModel_t¶EMElectricFieldModel_t describes the electric field model used for electromagnetic flows. The enumerated values for EMElectricFieldModelType_t are a subset of the ModelType_t enumeration.
EMElectricFieldModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Constant,
Frozen,
Interpolated,
Voltage ) ;
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)
} ;
Note
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.
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 over 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.
EMMagneticFieldModel_t¶EMMagneticFieldModel_t describes the magnetic field model used for electromagnetic flows. The enumerated values for EMMagneticFieldModelType_t are a subset of the ModelType_t enumeration.
EMMagneticFieldModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Constant,
Frozen,
Interpolated ) ;
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)
} ;
Note
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.
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 over 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.
EMConductivityModel_t¶EMConductivityModel_t describes the conductivity model used for electromagnetic flows. The enumerated values for EMConductivityModelType_t are a subset of the ModelType_t enumeration.
EMConductivityModelType_t := Enumeration(
ModelTypeNull,
ModelTypeUserDefined,
Constant,
Frozen,
Equilibrium_LinRessler,
Chemistry_LinRessler ) ;
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)
} ;
Note
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.
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 |
\(M L^{2}/TI\) |
|
x-component of electric field vector |
\(ML/TI\) |
|
y-component of electric field vector |
\(ML/TI\) |
|
z-component of electric field vector |
\(ML/TI\) |
|
x-component of magnetic field vector |
\(I/L\) |
|
y-component of magnetic field vector |
\(I/L\) |
|
z-component of magnetic field vector |
\(I/L\) |
|
x-component of current density vector |
\(I/L^{2}\) |
|
y-component of current density vector |
\(I/L^{2}\) |
|
z-component of current density vector |
\(I/L^{2}\) |
|
Electrical conductivity |
\(ML/T^{3}I^{2}\) |
|
x-component of Lorentz force vector |
\(ML/T^{2}\) |
|
y-component of Lorentz force vector |
\(ML/T^{2}\) |
|
z-component of Lorentz force vector |
\(ML/T^{2}\) |
|
Joule heating |
\(ML^{2}/T^{2}\) |
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 over 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.
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.
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 ;
}} ;
}} ;
}} ;