const BASE = Union{MA,MO,SY,DT}

Concrete BASE type union for parametric abstract types.

const DEF = Dict{Symbol,Any}(...)

EngThermBase defaults

DIMLESS{𝗽,𝘅} where {𝗽<:PREC,𝘅<:EXAC}

Dimensionless amount type union.

ENERGYA{𝗽,𝘅,𝗯} where {𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE}

Energy amount type union.

ENERGYI{𝗽,𝘅,𝗯} where {𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE}

Energy interaction type union.

ENERGYP{𝗽,𝘅,𝗯} where {𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE}

Energy property type union.

const EXAC = Union{EX,MM}

Concrete EXAC type union for parametric abstract types.

NTROPYA{𝗽,𝘅,𝗯} where {𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE}

Entropy amount type union.

NTROPYP{𝗽,𝘅,𝗯} where {𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE}

Entropy property type union.

const PREC = Union{Float16,Float32,Float64,BigFloat}

Concrete PREC type union for parametric abstract types.

UATY{𝗽,𝗱,𝘂} = Union{UETY{𝗽,𝗱,𝘂},UMTY{𝗽,𝗱,𝘂}} where {𝗽<:PREC,𝗱,𝘂} 𝗨nited 𝗔mount 𝗧𝗬pe: PRECision and EXACtness-parametric, united Quantity(ie)s — the default underlying data type for EngTherm AMOUNTS.

VELOCYP{𝗽,𝘅} where {𝗽<:PREC,𝘅<:EXAC}

Velocity property type union.

const _NA = __amt(measurement("6.0221415(10)e+23") / u"mol")

The Avogadro constant, $N_A$, [Lide, D. R., 2006], as a __amt{Float64,MM}.

const _R̄ = R_amt(measurement("8.314472(15)"), MO)

The molar gas constant, $R̄$, [Lide, D. R., 2006], as a R_amt{Float64,MM,MO}.

const _gn = gvamt{Float64,MM}(gvamt(9_806_650u"μm/s^2"))

The gvamt{Float64,MM} representation of the exact standard gravity, $g_n ≡ 9.80665 m/s^2$, [Lide, D. R., 2006].

const _kB = __amt(measurement("1.3806505(24)e-23") * u"J/K")

The Boltzmann constant, $k_B = R̄/N_A$, [Lide, D. R., 2006], as a __amt{Float64,MM}.

const _mu = m_amt(measurement("1.66053886(28)e-27") ,SY)

The atomic mass constant, $m_u = (1/12)m(¹²C)$, [Lide, D. R., 2006], as a m_amt{Float64,MM,SY}.

const _stdP = P_amt{Float64,MM}(P_amt(101350u"Pa"))

The P_amt{Float64,MM} representation of the exact standard atmosphere, $P_0 ≡ 101350Pa$, [Lide, D. R., 2006].

const _stdT = T_amt{Float64,MM}(T_amt(25u"°C"))

The T_amt{Float64,MM} representation of the exact standard temperature, $T_0 ≡ 25°C$, [Lide, D. R., 2006].

atoM_16

NamedTuple of atomic weights, with uncertainty, by chemical element symbol. Entries are of Measurement{Float16} precision.

Data Source: [1] Lide, David, L; CRC Handbook of Chemistry and Physics, 86th Ed. Boca Raton, London, New York, Singapore. 2005–2006.

atoM_32

NamedTuple of atomic weights, with uncertainty, by chemical element symbol. Entries are of Measurement{Float32} precision.

Data Source: [1] Lide, David, L; CRC Handbook of Chemistry and Physics, 86th Ed. Boca Raton, London, New York, Singapore. 2005–2006.

atoM_64 = (; ...)

NamedTuple of atomic weights, with uncertainty, by chemical element symbol. Entries are of Measurement{Float64} precision.

Data Source: [1] Lide, David, L; CRC Handbook of Chemistry and Physics, 86th Ed. Boca Raton, London, New York, Singapore. 2005–2006.

abstract type AMOUNTS{𝗽<:PREC,𝘅<:EXAC} <: AbstractTherm end

Abstract supertype for thermodynamic amounts.

Hierarchy

AMOUNTS <: AbstractTherm <: Any

abstract type AbstractTherm <: Any end

Abstract supertype for thermodynamic entities.

Hierarchy

AbstractTherm <: Any

abstract type BASES <: AbstractTherm end

Abstract supertype for quantity bases.

Hierarchy

BASES <: AbstractTherm <: Any

abstract type BInteract{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BasedAmt{𝗽,𝘅,𝗯} end

Abstract supertype for based interaction groups.

Hierarchy

BInteract <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type BProperty{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BasedAmt{𝗽,𝘅,𝗯} end

Abstract supertype for based property groups.

Hierarchy

BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type BUnranked{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BasedAmt{𝗽,𝘅,𝗯} end

Abstract supertype for based unranked amount groups.

Hierarchy

BUnranked <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type BasedAmt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: AMOUNTS{𝗽,𝘅} end

Abstract supertype for based amount groups of fixed units.

Hierarchy

BasedAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type BivarHeat{𝗽<:PREC,𝘅<:EXAC} <: Heat{𝗽,𝘅} end

Abstract supertype for bivariate specific heat models.

Hierarchy

BivarHeat <: Heat <: MODELS <: AbstractTherm <: Any

abstract type COMBOS{𝗽<:PREC,𝘅<:EXAC} <: AbstractTherm end

Abstract supertype for thermodynamic property combinations.

Hierarchy

COMBOS <: AbstractTherm <: Any

abstract type ChFPair{𝗽<:PREC,𝘅<:EXAC} <: PropPair{𝗽,𝘅} end

Abstract supertype for Characteristic Function property pairs.

Hierarchy

ChFPair <: PropPair <: COMBOS <: AbstractTherm <: Any

abstract type ConstHeat{𝗽<:PREC,𝘅<:EXAC} <: Heat{𝗽,𝘅} end

Abstract supertype for constant specific heat models.

Hierarchy

ConstHeat <: Heat <: MODELS <: AbstractTherm <: Any

abstract type DT <: ExtBase end

Abstract supertype for the Time Derivative (rate) base.

Hierarchy

DT <: ExtBase <: ThermBase <: BASES <: AbstractTherm <: Any

abstract type EX <: ExactBase end

Abstract supertype for the EXact base.

Hierarchy

EX <: ExactBase <: BASES <: AbstractTherm <: Any

abstract type EoSPair{𝗽<:PREC,𝘅<:EXAC} <: PropPair{𝗽,𝘅} end

Abstract supertype for Equation of State property pairs.

Hierarchy

EoSPair <: PropPair <: COMBOS <: AbstractTherm <: Any

abstract type ExactBase <: BASES end

Abstract supertype for type-exactness bases.

Hierarchy

ExactBase <: BASES <: AbstractTherm <: Any

abstract type ExtBase <: ThermBase end

Abstract supertype for non-intensive bases.

Hierarchy

ExtBase <: ThermBase <: BASES <: AbstractTherm <: Any

abstract type GenerAmt{𝗽<:PREC,𝘅<:EXAC} <: AMOUNTS{𝗽,𝘅} end

Abstract supertype for generic, arbitrary unit amounts.

Hierarchy

GenerAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type GenerHeat{𝗽<:PREC,𝘅<:EXAC} <: Heat{𝗽,𝘅} end

Abstract supertype for generic specific heat models.

Hierarchy

GenerHeat <: Heat <: MODELS <: AbstractTherm <: Any

abstract type Heat{𝗽<:PREC,𝘅<:EXAC} <: MODELS{𝗽,𝘅} end

Abstract supertype for specific heat models.

Hierarchy

Heat <: MODELS <: AbstractTherm <: Any

abstract type IntBase <: ThermBase end

Abstract supertype for intensive bases.

Hierarchy

IntBase <: ThermBase <: BASES <: AbstractTherm <: Any

abstract type MA <: IntBase end

Abstract supertype for the MAss base.

Hierarchy

MA <: IntBase <: ThermBase <: BASES <: AbstractTherm <: Any

abstract type MM <: ExactBase end

Abstract supertype for the MeasureMent base.

Hierarchy

MM <: ExactBase <: BASES <: AbstractTherm <: Any

abstract type MO <: IntBase end

Abstract supertype for the MOlar base.

Hierarchy

MO <: IntBase <: ThermBase <: BASES <: AbstractTherm <: Any

abstract type MODELS{𝗽<:PREC,𝘅<:EXAC} <: AbstractTherm end

Abstract supertype for thermodynamic models.

Hierarchy

MODELS <: AbstractTherm <: Any

struct Maamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric Mach number amounts based in –.

Maamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A Maamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

Maamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type Medium{𝗽<:PREC,𝘅<:EXAC} <: MODELS{𝗽,𝘅} end

Abstract supertype for substance/medium models.

Hierarchy

Medium <: MODELS <: AbstractTherm <: Any

abstract type Mixtures{𝗽<:PREC,𝘅<:EXAC} <: Scope{𝗽,𝘅} end

Abstract supertype for a substance mixture.

Hierarchy

Mixtures <: Scope <: System <: MODELS <: AbstractTherm <: Any

struct Molecule

Auxiliary Molecule data type with a data::Dict{Symbol,Real} data member. Inner constructor makes sure Symbol keys are chemical element symbols.

NTROPYI{𝗽,𝘅,𝗯} where {𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE}

Entropy interaction type union.

struct N_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric chemical amount amounts based in kmol.

N_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kmol, kmol s^-1, kmol kg^-1, or .

A N_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

N_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

PMTY{𝗽} = Union{Measurement{𝗽}} where 𝗽<:Union{Float16,Float32,Float64,BigFloat}

𝗣lain 𝗠easurement 𝗧𝗬pe: Plain (unitless) Measurements.

struct P_amt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric pressure amounts based in kPa.

P_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A P_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

P_amt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct Pramt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric relative pressure amounts based in –.

Pramt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A Pramt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

Pramt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type PropPair{𝗽<:PREC,𝘅<:EXAC} <: COMBOS{𝗽,𝘅} end

Abstract supertype for propery pairs.

Hierarchy

PropPair <: COMBOS <: AbstractTherm <: Any

abstract type PropQuad{𝗽<:PREC,𝘅<:EXAC} <: COMBOS{𝗽,𝘅} end

Abstract supertype for propery quads.

Hierarchy

PropQuad <: COMBOS <: AbstractTherm <: Any

abstract type PropTrio{𝗽<:PREC,𝘅<:EXAC} <: COMBOS{𝗽,𝘅} end

Abstract supertype for propery trios.

Hierarchy

PropTrio <: COMBOS <: AbstractTherm <: Any

abstract type PureSubs{𝗽<:PREC,𝘅<:EXAC} <: Scope{𝗽,𝘅} end

Abstract supertype for a defined amount of a pure substance.

Hierarchy

PureSubs <: Scope <: System <: MODELS <: AbstractTherm <: Any

struct Pvamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric flux work amounts based in kJ.

Pvamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A Pvamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

Pvamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct RTamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric RT product amounts based in kJ.

RTamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A RTamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

RTamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct R_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric gas constant amounts based in kJ/K.

R_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A R_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

R_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type Reactiv{𝗽<:PREC,𝘅<:EXAC} <: Mixtures{𝗽,𝘅} end

Abstract supertype for a reactive mixture.

Hierarchy

Reactiv <: Mixtures <: Scope <: System <: MODELS <: AbstractTherm <: Any

abstract type SY <: ExtBase end

Abstract supertype for the SYstem (extensive) base.

Hierarchy

SY <: ExtBase <: ThermBase <: BASES <: AbstractTherm <: Any

abstract type Scope{𝗽<:PREC,𝘅<:EXAC} <: System{𝗽,𝘅} end

Abstract supertype for defined amounts of substance.

Hierarchy

Scope <: System <: MODELS <: AbstractTherm <: Any

abstract type Substance{𝗽<:PREC,𝘅<:EXAC} <: Medium{𝗽,𝘅} end

Abstract supertype for substance model by Equation of State.

Hierarchy

Substance <: Medium <: MODELS <: AbstractTherm <: Any

abstract type System{𝗽<:PREC,𝘅<:EXAC} <: MODELS{𝗽,𝘅} end

Abstract supertype for system models.

Hierarchy

System <: MODELS <: AbstractTherm <: Any

struct T_amt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric temperature amounts based in K.

T_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A T_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

T_amt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type ThermBase <: BASES end

Abstract supertype for thermodynamic bases.

Hierarchy

ThermBase <: BASES <: AbstractTherm <: Any

struct Tsamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric Ts product amounts based in kJ.

Tsamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A Tsamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

Tsamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

UETY{𝗽,𝗱,𝘂} = Union{Quantity{𝗽,𝗱,𝘂}} where {𝗽<:PREC,𝗱,𝘂}

𝗨nited 𝗘xact 𝗧𝗬pe: PRECision-parametric united Quantity(ie)s.

UMTY{𝗽,𝗱,𝘂} = Union{Quantity{Measurement{𝗽},𝗱,𝘂}} where {𝗽<:PREC,𝗱,𝘂}

𝗨nited 𝗠easurement 𝗧𝗬pe: PRECision-parametric, Measurement united Quantity(ie)s.

abstract type Unreact{𝗽<:PREC,𝘅<:EXAC} <: Mixtures{𝗽,𝘅} end

Abstract supertype for an unreactive mixture.

Hierarchy

Unreact <: Mixtures <: Scope <: System <: MODELS <: AbstractTherm <: Any

abstract type UnvarHeat{𝗽<:PREC,𝘅<:EXAC} <: Heat{𝗽,𝘅} end

Abstract supertype for univariate specific heat models.

Hierarchy

UnvarHeat <: Heat <: MODELS <: AbstractTherm <: Any

abstract type WInteract{𝗽<:PREC,𝘅<:EXAC} <: WholeAmt{𝗽,𝘅} end

Abstract supertype for whole, unbased interactions.

Hierarchy

WInteract <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type WProperty{𝗽<:PREC,𝘅<:EXAC} <: WholeAmt{𝗽,𝘅} end

Abstract supertype for whole, unbased properties.

Hierarchy

WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type WUnranked{𝗽<:PREC,𝘅<:EXAC} <: WholeAmt{𝗽,𝘅} end

Abstract supertype for whole, unbased unranked amounts.

Hierarchy

WUnranked <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

abstract type WholeAmt{𝗽<:PREC,𝘅<:EXAC} <: AMOUNTS{𝗽,𝘅} end

Abstract supertype for whole, unbased amounts of fixed units.

Hierarchy

WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct Z_amt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric generalized compressibility factor amounts based in –.

Z_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A Z_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

Z_amt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct __amt{𝗽<:PREC,𝘅<:EXAC} <: GenerAmt{𝗽,𝘅}

Precision-, and Exactness- parametric generic amounts based in arbitrary units.

__amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A __amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with any units.

Hierarchy

__amt <: GenerAmt <: AMOUNTS <: AbstractTherm <: Any

struct a_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric Helmholtz energy amounts based in kJ.

a_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A a_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

a_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct beamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric coefficient of volume expansion amounts based in /K.

beamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A beamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

beamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct c_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric incompressible substance specific heat amounts based in kJ/K.

c_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A c_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

c_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct cpamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric iso-P specific heat amounts based in kJ/K.

cpamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A cpamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

cpamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct csamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric adiabatic speed of sound amounts based in √(kJ/kg).

csamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A csamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

csamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct cvamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric iso-v specific heat amounts based in kJ/K.

cvamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A cvamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

cvamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct deamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BInteract{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric energy variation amounts based in kJ.

deamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A deamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

deamt <: BInteract <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct dpamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric os. exergy variation amounts based in kJ.

dpamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A dpamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

dpamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct dsamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BInteract{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric entropy variation amounts based in kJ/K.

dsamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A dsamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

dsamt <: BInteract <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct dxamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric cs. exergy variation amounts based in kJ.

dxamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A dxamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

dxamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct e_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric total energy amounts based in kJ.

e_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A e_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

e_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct ekamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric kinetic energy amounts based in kJ.

ekamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A ekamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

ekamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct epamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric potential energy amounts based in kJ.

epamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A epamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

epamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct g_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric Gibbs energy amounts based in kJ.

g_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A g_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

g_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct gaamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric specific heat ratio amounts based in –.

gaamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A gaamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

gaamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct gvamt{𝗽<:PREC,𝘅<:EXAC} <: WUnranked{𝗽,𝘅}

Precision-, and Exactness- parametric gravity amounts based in m/s².

gvamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A gvamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

gvamt <: WUnranked <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct h_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric enthalpy amounts based in kJ.

h_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A h_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

h_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct i_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BInteract{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric irreversibility amounts based in kJ.

i_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A i_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

i_amt <: BInteract <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct j_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric Massieu function amounts based in kJ/K.

j_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A j_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

j_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct kTamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric isothermal compressibility amounts based in /kPa.

kTamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A kTamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

kTamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct k_amt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric isentropic expansion exponent amounts based in –.

k_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A k_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

k_amt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct ksamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric isentropic compressibility amounts based in /kPa.

ksamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A ksamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

ksamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct mJamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric Joule-Thomson coefficient amounts based in K/kPa.

mJamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A mJamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

mJamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct mSamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric isentropic expansion coefficient amounts based in K/kPa.

mSamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A mSamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

mSamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct m_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric mass amounts based in kg.

m_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kg, kg s^-1, , or kg kmol^-1.

A m_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

m_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct psamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric open system exergy amounts based in kJ.

psamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A psamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

psamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct q_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BInteract{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric heat amounts based in kJ.

q_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A q_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

q_amt <: BInteract <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct s_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric entropy amounts based in kJ/K.

s_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A s_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

s_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct spamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric speed amounts based in m/s.

spamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A spamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

spamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct t_amt{𝗽<:PREC,𝘅<:EXAC} <: WUnranked{𝗽,𝘅}

Precision-, and Exactness- parametric time amounts based in s.

t_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A t_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

t_amt <: WUnranked <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct u_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric internal energy amounts based in kJ.

u_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A u_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

u_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct v_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric volume amounts based in m³.

v_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of m^3, m^3 s^-1, m^3 kg^-1, or m^3 kmol^-1.

A v_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

v_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct veamt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric velocity amounts based in √(kJ/kg).

veamt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A veamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

veamt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct vramt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric relative specific volume amounts based in –.

vramt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A vramt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

vramt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct w_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BInteract{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric work amounts based in kJ.

w_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A w_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

w_amt <: BInteract <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct x_amt{𝗽<:PREC,𝘅<:EXAC} <: WProperty{𝗽,𝘅}

Precision-, and Exactness- parametric saturated vapor mass fraction amounts based in –.

x_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A x_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

x_amt <: WProperty <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct xiamt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric closed sys. exergy amounts based in kJ.

xiamt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ, kJ s^-1, kJ kg^-1, or kJ kmol^-1.

A xiamt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

xiamt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct y_amt{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: BProperty{𝗽,𝘅,𝗯}

Precision-, Exactness-, and Base- parametric Planck function amounts based in kJ/K.

y_amt{𝗽,𝘅,𝗯} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

• Thermodynamic base 𝗯<:Union{SY,DT,MA,MO} respectively for system, rate, mass, or molar quantities, respectively in units of kJ K^-1, kJ K^-1 s^-1, kJ kg^-1 K^-1, or kJ K^-1 kmol^-1.

A y_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine parameters from their arguments. Quantity constructors do not need a base argument. Plain, AbstractFloat ones require the base argument.

Hierarchy

y_amt <: BProperty <: BasedAmt <: AMOUNTS <: AbstractTherm <: Any

struct z_amt{𝗽<:PREC,𝘅<:EXAC} <: WUnranked{𝗽,𝘅}

Precision-, and Exactness- parametric altitude amounts based in km.

z_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A z_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

z_amt <: WUnranked <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

struct ø_amt{𝗽<:PREC,𝘅<:EXAC} <: WUnranked{𝗽,𝘅}

Precision-, and Exactness- parametric generic dimensionless ratio amounts based in –.

ø_amt{𝗽,𝘅} parameters are:

• Precision 𝗽<:Union{Float16,Float32,Float64,BigFloat};

• Exactness 𝘅<:Union{EX,MM}, i.e., either a single, precise value or an uncertainty-bearing measurement, respectively;

A ø_amt can be natively constructed from the following argument types:

• A plain, unitless float;

• A plain, unitless Measurement; hence, any AbstractFloat;

• A Quantity{AbstractFloat} with compatible units.

Constructors determine all parameters from their arguments.

Hierarchy

ø_amt <: WUnranked <: WholeAmt <: AMOUNTS <: AbstractTherm <: Any

Function to return iso-P specific heat amounts in (kJ/K).

function AMT(x::Number)

Generates the default AMOUNTS from a, based on its unit dimensions. The eltype-undecorated Quantity constructors are evoked, so that the resulting type precision is taken from the x argument. This function is extensively used in operations that result in a unit change.

Function to return Mach number amounts in (–).

NA(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=EX) where {𝗽<:PREC,𝘅<:EXAC}

Returns the Avogadro constant as a __amt{𝖯,𝖷}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

Function to return chemical amount amounts in (kmol).

Function to return pressure amounts in (kPa).

P_(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=EX) where {𝗽<:PREC,𝘅<:EXAC}

Returns the standard atmosphere as a P_amt{𝖯,𝖷}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

Function to return relative pressure amounts in (–).

Function to return flux work amounts in (kJ).

Function to return RT product amounts in (kJ).

Function to return gas constant amounts in (kJ/K).

R_(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=EX) where {𝗽<:PREC,𝘅<:EXAC}

Returns the molar gas constant as a R_amt{𝖯:𝖷,MO}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

Function to return temperature amounts in (K).

T_(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=EX) where {𝗽<:PREC,𝘅<:EXAC}

Returns the standard temperature as a T_amt{𝖯,𝖷}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

Function to return Ts product amounts in (kJ).

Function to return generalized compressibility factor amounts in (–).

Function to return generic amounts of arbitrary units.

Function to return Helmholtz energy amounts in (kJ).

function amt end

Interface to get an AMOUNTS' :amt field in a type-stable manner.

function bare end

Interface to get an AMOUNTS' bare (without units) value in a type-stable manner.

baseof(::Type{𝗧} | x::𝗧) where 𝗧<:BasedAmt{𝗽,𝘅,𝗯} where {𝗽,𝘅,𝗯} = 𝗯

Returns the thermodynamic base of the AMOUNTS subtype or instance as a DataType.

Function to return coefficient of volume expansion amounts in (/K).

Function to return incompressible substance specific heat amounts in (kJ/K).

Function to return adiabatic speed of sound amounts in (√(kJ/kg)).

Function to return iso-v specific heat amounts in (kJ/K).

Function to return energy variation amounts in (kJ).

function deco end

Interface to return a unique decorative Symbol from a method's argument type.

Function to return os. exergy variation amounts in (kJ).

Function to return entropy variation amounts in (kJ/K).

Function to return cs. exergy variation amounts in (kJ).

Function to return total energy amounts in (kJ).

Function to return kinetic energy amounts in (kJ).

Function to return potential energy amounts in (kJ).

exacof(::Type{𝗧} | x::𝗧) where 𝗧<:AMOUNTS{𝗽} where 𝗽 = 𝗽

Returns the exactness of the AMOUNTS subtype or instance as a DataType.

Function to return Gibbs energy amounts in (kJ).

Function to return specific heat ratio amounts in (–).

Function to return gravity amounts in (m/s²).

gv(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=E𝖷) where {𝗽<:PREC,𝘅<:EXAC}

Returns the standard gravity as a gvamt{𝖯,𝖷}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

Function to return enthalpy amounts in (kJ).

Function to return irreversibility amounts in (kJ).

Function to return Massieu function amounts in (kJ/K).

kB(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=EX) where {𝗽<:PREC,𝘅<:EXAC}

Returns the Boltzmann constant as a __amt{𝖯,𝖷}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

Function to return isothermal compressibility amounts in (/kPa).

Function to return isentropic expansion exponent amounts in (–).

Function to return isentropic compressibility amounts in (/kPa).

Function to return Joule-Thomson coefficient amounts in (K/kPa).

Function to return isentropic expansion coefficient amounts in (K/kPa).

m_(𝑀::Molecule, 𝑚::NamedTuple = atoM)::m_amt{𝕡,𝕩,MO} where {𝕡,𝕩}

Function to return mass amounts in (kg).

function mk1ParAbs(TY::Symbol, TP::Symbol, what::AbstractString, pp::Integer=1, xp::Bool=true)

Declares a new, 1-parameter abstract type. Parent type parameter count is a function of pp, so that declarations are as follows:

• TY{𝗽} <: TP{𝗽} for pp >= 1 (default);
• TY{𝗽<:PREC} <: TP for pp <= 0.

Argument what is inserted in the new type documentation, and xp controls whether or not the new abstract type is exported (default true).

function mk2ParAbs(TY::Symbol, TP::Symbol, what::AbstractString, pp::Integer=2, xp::Bool=true)

Declares a new, 2-parameter abstract type. Parent type parameter count is a function of pp, so that declarations are as follows:

• TY{𝗽,𝘅} <: TP{𝗽,𝘅} for pp >= 2 (default);
• TY{𝗽,𝘅<:EXAC} <: TP{𝗽} for pp = 1;
• TY{𝗽<:PREC,𝘅<:EXAC} <: TP for pp <= 0.

Argument what is inserted in the new type documentation, and xp controls whether or not the new abstract type is exported (default true).

function mk3ParAbs(TY::Symbol, TP::Symbol, what::AbstractString, pp::Integer=3, xp::Bool=true)

Declares a new, 3-parameter abstract type. Parent type parameter count is a function of pp, so that declarations are as follows:

• TY{𝗽,𝘅,𝗯} <: TP{𝗽,𝘅,𝗯} for pp >= 3 (default);
• TY{𝗽,𝘅,𝗯<:BASE} <: TP{𝗽,𝘅} for pp == 2;
• TY{𝗽,𝘅<:EXAC,𝗯<:BASE} <: TP{𝗽} for pp = 1;
• TY{𝗽<:PREC,𝘅<:EXAC,𝗯<:BASE} <: TP for pp <= 0.

Argument what is inserted in the new type documentation, and xp controls whether or not the new abstract type is exported (default true).

Based Amount type factory.

Generic Amount type factory.

function mkNonPAbs(TY::Symbol, TP::Symbol, what::AbstractString, xp::Bool=true)

Declares exactly one new, non-parametric, abstract type TY <: TP. Argument what is inserted in the new type documentation, and xp controls whether or not the new abstract type is exported (default true).

Whole Amount type factory.

molParse(txt::AbstractString)::Molecule

Parses the txt argument—something like "CH4", or "(CH3)2(CH2)6"—returning the corresponding Molecule object. Bails out if txt contains invalid characters, and if all parentheses aren't closed.

mu(𝖯::Type{𝗽}=Float64, 𝖷::Type{𝘅}=EX) where {𝗽<:PREC,𝘅<:EXAC}

Returns the atomic mass constant as a m_amt{𝖯:𝖷}.

Arguments 𝖯 and 𝖷 can be ommitted and/or be supplied in any order.

nxtToken(txt::AbstractString)::moleculeToken

Returns a single token from the head of the non-empty txt.

function pod end

Interface to get an AMOUNTS' POD (plain old data) value in a type-stable manner.

function ppu end

Interface to pretty-print units.

precof(::Type{𝗧} | x::𝗧) where 𝗧<:AMOUNTS{𝗽} where 𝗽 = 𝗽

Returns the precision of the AMOUNTS subtype or instance as a DataType.

Function to return open system exergy amounts in (kJ).

Function to return heat amounts in (kJ).

Function to return entropy amounts in (kJ/K).

Function to return speed amounts in (m/s).

Function to return time amounts in (s).

tokenize(txt::AbstractString)::Vector{moleculeToken}

Tokenizes until an EOS is reached.

function tyArchy(t::Union{DataType,UnionAll})

Returns a string suitable for documenting the hierarchy of an abstract type.

Function to return internal energy amounts in (kJ).

Function to return volume amounts in (m³).

Function to return velocity amounts in (√(kJ/kg)).

Function to return relative specific volume amounts in (–).

Function to return work amounts in (kJ).

Function to return saturated vapor mass fraction amounts in (–).

Function to return closed sys. exergy amounts in (kJ).

Function to return Planck function amounts in (kJ/K).

Function to return altitude amounts in (km).

Function to return generic dimensionless ratio amounts in (–).