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 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
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 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)
} ;
Notes
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/∂ξ ∂ζ) | |
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 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 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)
} ;
Notes
For a perfect gas (GasModelType = CaloricallyPerfect), the
pressure, temperature, and density are related by
| 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 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 describes the model for relating molecular viscosity (μ) 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)
} ;
Notes
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,
| 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 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 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)
} ;
Notes
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,
| ThermalConduc- tivityModelType | Data-Name Identifier | Description | Units | |||
|---|---|---|---|---|---|---|
| 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 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 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)
} ;
Notes
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,
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 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 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)
} ;
Notes
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 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 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)
} ;
Notes
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 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)
} ;
Notes
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 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 | |
|---|---|---|
| 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 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 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)
} ;
Notes
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 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)
} ;
Notes
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 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)
} ;
Notes
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 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 ;
}} ;
}} ;
}} ;
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.