Emscripten bindings for the AGA8 gas calculation library. More...

#include <emscripten/bind.h>
#include <emscripten/val.h>
#include "Detail.h"
#include "GERG2008.h"
#include "Gross.h"

Include dependency graph for bindings.cpp:

Data Structures
struct	gasMixture

struct	PressureResult

struct	DensityResult
	Structure to hold the results of density calculations. More...

struct	PropertiesDetailResult

struct	PropertiesGERGResult
	Structure containing thermodynamic properties for GERG-2008 calculations. More...

struct	xGrs

struct	PressureGrossResult

struct	GrossHvResult

struct	GrossInputsResult

struct	BmixResult

struct	GrossMethod1Result

struct	GrossMethod2Result

Functions
std::vector< double >	gasMixture_to_vector (gasMixture js_object)
	Converts a JavaScript gasMixture Object to a C++ struct.

std::vector< double >	xGrs_to_vector (xGrs js_object)
	Converts a JavaScript xGrs Object to a C++ struct.

xGrs	vector_to_xGrs (const std::vector< double > &vec)
	Converts a C++ vector to a JavaScript xGrs object.

std::vector< double >	array_to_vector (const val &js_array)
	Converts a JavaScript array to a C++ vector of doubles.

val	vector_to_array (const std::vector< double > &vec)
	Converts a C++ vector of doubles to a JavaScript array.

double	MolarMassDetail_wrapper (gasMixture x_array)
	Calculates the molar mass of a gas mixture given mole percentages.

PressureResult	PressureDetail_wrapper (double T, double D, gasMixture x_array)
	Wraps the PressureDetail function to calculate pressure and compressibility factor.

DensityResult	DensityDetail_wrapper (double T, double P, gasMixture x_array)
	Calculates the density of a gas mixture given temperature, pressure and composition.

PropertiesDetailResult	PropertiesDetail_wrapper (double T, double D, gasMixture x_array)
	Wrapper function to calculate detailed thermodynamic properties of a gas mixture.

double	MolarMassGERG_wrapper (gasMixture x_array)
	Calculates the molar mass of a gas mixture using GERG-2008 equation of state.

PressureResult	PressureGERG_wrapper (double T, double D, gasMixture x_array)
	Calculates pressure and compressibility factor using GERG-2008 equation of state.

DensityResult	DensityGERG_wrapper (int iflag, double T, double P, gasMixture x_array)
	Wrapper function to calculate density using GERG-2008 equation of state.

PropertiesGERGResult	PropertiesGERG_wrapper (double T, double D, gasMixture x_array)
	Calculates thermodynamic properties using GERG-2008 equation of state.

double	MolarMassGross_wrapper (gasMixture x_array)
	Calculates the gross molar mass of a gas mixture.

PressureGrossResult	PressureGross_wrapper (double T, double D, xGrs xGrs_object, double HCH)
	Wrapper function for PressureGross calculation.

DensityResult	DensityGross_wrapper (double T, double P, xGrs xGrs_object, double HCH)
	Wrapper function for DensityGross calculation.

GrossHvResult	GrossHv_wrapper (gasMixture x_array)
	Wrapper function to calculate gross heating values for a gas mixture.

GrossInputsResult	GrossInputs_wrapper (double T, double P, gasMixture x_array)
	Wrapper function for GrossInputs calculation.

BmixResult	Bmix_wrapper (double T, xGrs xGrs_object, double HCH)
	Calculates mixture second and third virial coefficients using the GERG-2008 equation of state.

GrossMethod1Result	GrossMethod1_wrapper (double Th, double Td, double Pd, xGrs xGrs_object, double Gr, double Hv)
	Wrapper function for GrossMethod1 calculation method.

GrossMethod2Result	GrossMethod2_wrapper (double Th, double Td, double Pd, xGrs xGrs_object, double Gr)
	Wrapper function for the GrossMethod2 calculation method.

	EMSCRIPTEN_BINDINGS (AGA8_module)
	Emscripten bindings for the AGA8 gas calculation module.

Detailed Description

Emscripten bindings for the AGA8 gas calculation library.

This file provides WebAssembly bindings for the AGA8 gas calculation library, enabling its use in JavaScript environments. It implements three main calculation methods:

Detail method (high accuracy)
GERG-2008 method (reference equations)
Gross method (simplified calculations)

The gas composition is represented using a 21-component system where:

Index 1: Methane
Index 2: Nitrogen
Index 3: Carbon dioxide
Index 4-14: Various hydrocarbons (Ethane through n-Decane)
Index 15-21: Other components (Hydrogen, Oxygen, CO, Water, H2S, Helium, Argon)

Note: All compositions must be provided as mole fractions (not percentages); Temperature inputs are in Kelvin; Pressure inputs are in kPa; Density inputs are in mol/l (mol/dm³)

Example mixture (94% methane, 5% CO2, 1% helium): gasMixtureInMolePercent(1) = 0.94 // Methane gasMixtureInMolePercent(3) = 0.05 // CO2 gasMixtureInMolePercent(20) = 0.01 // Helium

Copyright: (C) 2025 Ronan LE MEILLAT @license GNU Affero General Public License v3.0

Definition in file bindings.cpp.

Function Documentation

◆ array_to_vector()

std::vector< double > array_to_vector ( const val & js_array )

Converts a JavaScript array to a C++ vector of doubles.

Parameters

js_array JavaScript array object passed as an emscripten::val

Returns: std::vector<double> C++ vector containing the converted values

This function takes a JavaScript array passed through emscripten's val interface and converts it to a C++ std::vector<double>. Each element in the JavaScript array is converted to a double value.

Definition at line 379 of file bindings.cpp.

{
    auto length = js_array["length"].as<unsigned>();
    std::vector<double> result(length);
    for (unsigned i = 0; i < length; ++i)
    {
        result[i] = js_array[i].as<double>();
    }
    return result;
}

◆ Bmix_wrapper()

BmixResult Bmix_wrapper	(	double	T,
		xGrs	xGrs_object,
		double	HCH )

Calculates mixture second and third virial coefficients using the GERG-2008 equation of state.

Parameters

T	Temperature [K]
xGrs_object	Array of mole fractions for each component in the mixture
HCH	Parameter for handling hydrocarbon mixtures

Returns

BmixResult Structure containing:

B: Second virial coefficient [cm³/mol]
C: Third virial coefficient [(cm³/mol)²]
ierr: Error code (0 = successful)
herr: Error message string

This function serves as a wrapper for the Bmix calculation, converting array inputs to the required vector format and returning results in a structured format.

See also: Bmix For the underlying calculation implementation

Definition at line 790 of file bindings.cpp.

{
    std::vector<double> xGrs = xGrs_to_vector(xGrs_object);
    double B = 0, C = 0;
    int ierr = 0;
    std::string herr;
 
    Bmix(T, xGrs, HCH, B, C, ierr, herr);
 
    BmixResult result = {B, C, ierr, herr};
    return result;
}

References Bmix(), and xGrs_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ DensityDetail_wrapper()

DensityResult DensityDetail_wrapper	(	double	T,
		double	P,
		gasMixture	x_array )

Calculates the density of a gas mixture given temperature, pressure and composition.

This function wraps the DensityDetail calculation for easier interface handling.

Parameters

T	Temperature in K
P	Pressure in kPa
x_array	Gas mixture composition in mole percent

Returns

DensityResult struct containing:

D: Density in kg/m³
ierr: Error code (0 = successful)
herr: Error message

See also: DensityDetail For the underlying calculation implementation

Definition at line 468 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double D = 0;
    int ierr = 0;
    std::string herr;
 
    DensityDetail(T, P, x, D, ierr, herr);
 
    DensityResult result = {D, ierr, herr};
    return result;
}

References DensityDetail(), and gasMixture_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ DensityGERG_wrapper()

DensityResult DensityGERG_wrapper	(	int	iflag,
		double	T,
		double	P,
		gasMixture	x_array )

Wrapper function to calculate density using GERG-2008 equation of state.

Parameters

iflag	Flag to specify calculation path (1: density from pressure/temperature, 2: pressure from density/temperature)
T	Temperature [K]
P	Pressure [kPa]
x_array	Array containing mole fractions of components in percent

Returns

DensityResult Struct containing:

D: Density [kg/m³]
ierr: Error flag (0: successful, non-zero: error occurred)
herr: Error message string

See also: DensityGERG For the underlying calculation implementation

Definition at line 580 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double D = 0;
    int ierr = 0;
    std::string herr;
 
    DensityGERG(iflag, T, P, x, D, ierr, herr);
 
    DensityResult result = {D, ierr, herr};
    return result;
}

References DensityGERG(), and gasMixture_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ DensityGross_wrapper()

DensityResult DensityGross_wrapper	(	double	T,
		double	P,
		xGrs	xGrs_object,
		double	HCH )

Wrapper function for DensityGross calculation.

This function calculates the density of a natural gas mixture using the GERG-2008 equation of state

Parameters

T	Temperature [K]
P	Pressure [kPa]
xGrs_object	Array containing mole fractions of the mixture components
HCH	Heating value [MJ/m³]

Returns

DensityResult struct containing:

D: Density [kg/m³]
ierr: Error code (0 = successful)
herr: Error message string

See also: DensityGross For the underlying calculation implementation

Note: This is a wrapper function that converts the input array to a vector before calling the main DensityGross function

Definition at line 703 of file bindings.cpp.

{
    std::vector<double> xGrs = xGrs_to_vector(xGrs_object);
    double D = 0;
    int ierr = 0;
    std::string herr;
 
    DensityGross(T, P, xGrs, HCH, D, ierr, herr);
 
    DensityResult result = {D, ierr, herr};
    return result;
}

References DensityGross(), and xGrs_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ EMSCRIPTEN_BINDINGS()

EMSCRIPTEN_BINDINGS ( AGA8_module )

Emscripten bindings for the AGA8 gas calculation module.

These bindings expose the AGA8 gas calculation functionality to JavaScript/WebAssembly. It includes:

Enums:

GasComponent: Enumeration of different gas components (methane, nitrogen, etc.)

Types:

gasMixtureInMolePercent: Gas mixture composition in mole percent
xGrsArray: Array for gross method calculations
VectorDouble: Vector of double precision numbers

Value Objects:

PressureResult: Pressure calculation results (P, Z)
DensityResult: Density calculation results (D, error info)
PropertiesDetailResult: Detailed gas properties results
PropertiesGERGResult: GERG-2008 properties calculation results
PressureGrossResult: Gross method pressure calculation results
GrossHvResult: Heating value calculation results
GrossInputsResult: Gross method input processing results
BmixResult: Binary mixture calculation results
GrossMethod1Result: Results for gross characterization method 1
GrossMethod2Result: Results for gross characterization method 2

Functions: Detail Methods:

SetupDetail: Initialize detail calculation method
MolarMassDetail: Calculate molar mass using detail method
PressureDetail: Calculate pressure using detail method
DensityDetail: Calculate density using detail method
PropertiesDetail: Calculate detailed properties

GERG Methods:

SetupGERG: Initialize GERG-2008 calculation method
MolarMassGERG: Calculate molar mass using GERG-2008
PressureGERG: Calculate pressure using GERG-2008
DensityGERG: Calculate density using GERG-2008
PropertiesGERG: Calculate properties using GERG-2008

Gross Methods:

SetupGross: Initialize gross calculation method
MolarMassGross: Calculate molar mass using gross method
PressureGross: Calculate pressure using gross method
DensityGross: Calculate density using gross method
GrossHv: Calculate heating value
GrossInputs: Process inputs for gross calculations
Bmix: Calculate binary mixture properties
GrossMethod1: Perform gross characterization method 1
GrossMethod2: Perform gross characterization method 2

Definition at line 921 of file bindings.cpp.

{
    register_vector<double>("VectorDouble");
 
    value_object<gasMixture>("GasMixture")
        .field("methane", &gasMixture::methane)
        .field("nitrogen", &gasMixture::nitrogen)
        .field("carbon_dioxide", &gasMixture::carbon_dioxide)
        .field("ethane", &gasMixture::ethane)
        .field("propane", &gasMixture::propane)
        .field("isobutane", &gasMixture::isobutane)
        .field("n_butane", &gasMixture::n_butane)
        .field("isopentane", &gasMixture::isopentane)
        .field("n_pentane", &gasMixture::n_pentane)
        .field("n_hexane", &gasMixture::n_hexane)
        .field("n_heptane", &gasMixture::n_heptane)
        .field("n_octane", &gasMixture::n_octane)
        .field("n_nonane", &gasMixture::n_nonane)
        .field("n_decane", &gasMixture::n_decane)
        .field("hydrogen", &gasMixture::hydrogen)
        .field("oxygen", &gasMixture::oxygen)
        .field("carbon_monoxide", &gasMixture::carbon_monoxide)
        .field("water", &gasMixture::water)
        .field("hydrogen_sulfide", &gasMixture::hydrogen_sulfide)
        .field("helium", &gasMixture::helium)
        .field("argon", &gasMixture::argon);
 
    value_object<xGrs>("xGrs")
        .field("hydrocarbon", &xGrs::hydrocarbon)
        .field("nitrogen", &xGrs::nitrogen)
        .field("carbon_dioxide", &xGrs::carbon_dioxide);
 
    value_object<PressureResult>("PressureResult")
        .field("P", &PressureResult::P)
        .field("Z", &PressureResult::Z);
 
    value_object<DensityResult>("DensityResult")
        .field("D", &DensityResult::D)
        .field("ierr", &DensityResult::ierr)
        .field("herr", &DensityResult::herr);
 
    value_object<PropertiesDetailResult>("PropertiesDetailResult")
        .field("P", &PropertiesDetailResult::P)
        .field("Z", &PropertiesDetailResult::Z)
        .field("dPdD", &PropertiesDetailResult::dPdD)
        .field("d2PdD2", &PropertiesDetailResult::d2PdD2)
        .field("d2PdTD", &PropertiesDetailResult::d2PdTD)
        .field("dPdT", &PropertiesDetailResult::dPdT)
        .field("U", &PropertiesDetailResult::U)
        .field("H", &PropertiesDetailResult::H)
        .field("S", &PropertiesDetailResult::S)
        .field("Cv", &PropertiesDetailResult::Cv)
        .field("Cp", &PropertiesDetailResult::Cp)
        .field("W", &PropertiesDetailResult::W)
        .field("G", &PropertiesDetailResult::G)
        .field("JT", &PropertiesDetailResult::JT)
        .field("Kappa", &PropertiesDetailResult::Kappa)
        .field("Cf", &PropertiesDetailResult::Cf);
 
    value_object<PropertiesGERGResult>("PropertiesGERGResult")
        .field("P", &PropertiesGERGResult::P)
        .field("Z", &PropertiesGERGResult::Z)
        .field("dPdD", &PropertiesGERGResult::dPdD)
        .field("d2PdD2", &PropertiesGERGResult::d2PdD2)
        .field("d2PdTD", &PropertiesGERGResult::d2PdTD)
        .field("dPdT", &PropertiesGERGResult::dPdT)
        .field("U", &PropertiesGERGResult::U)
        .field("H", &PropertiesGERGResult::H)
        .field("S", &PropertiesGERGResult::S)
        .field("Cv", &PropertiesGERGResult::Cv)
        .field("Cp", &PropertiesGERGResult::Cp)
        .field("W", &PropertiesGERGResult::W)
        .field("G", &PropertiesGERGResult::G)
        .field("JT", &PropertiesGERGResult::JT)
        .field("Kappa", &PropertiesGERGResult::Kappa)
        .field("A", &PropertiesGERGResult::A)
        .field("Cf", &PropertiesGERGResult::Cf);
 
    value_object<PressureGrossResult>("PressureGrossResult")
        .field("P", &PressureGrossResult::P)
        .field("Z", &PressureGrossResult::Z)
        .field("ierr", &PressureGrossResult::ierr)
        .field("herr", &PressureGrossResult::herr);
 
    value_object<GrossHvResult>("GrossHvResult")
        .field("xGrs", &GrossHvResult::xGrs)
        .field("HN", &GrossHvResult::HN)
        .field("HCH", &GrossHvResult::HCH);
 
    value_object<GrossInputsResult>("GrossInputsResult")
        .field("xGrs", &GrossInputsResult::xGrs)
        .field("Gr", &GrossInputsResult::Gr)
        .field("HN", &GrossInputsResult::HN)
        .field("HCH", &GrossInputsResult::HCH)
        .field("ierr", &GrossInputsResult::ierr)
        .field("herr", &GrossInputsResult::herr);
 
    value_object<BmixResult>("BmixResult")
        .field("B", &BmixResult::B)
        .field("C", &BmixResult::C)
        .field("ierr", &BmixResult::ierr)
        .field("herr", &BmixResult::herr);
 
    value_object<GrossMethod1Result>("GrossMethod1Result")
        .field("xGrs", &GrossMethod1Result::xGrs)
        .field("Mm", &GrossMethod1Result::Mm)
        .field("HCH", &GrossMethod1Result::HCH)
        .field("HN", &GrossMethod1Result::HN)
        .field("ierr", &GrossMethod1Result::ierr)
        .field("herr", &GrossMethod1Result::herr);
 
    value_object<GrossMethod2Result>("GrossMethod2Result")
        .field("xGrs", &GrossMethod2Result::xGrs)
        .field("Hv", &GrossMethod2Result::Hv)
        .field("Mm", &GrossMethod2Result::Mm)
        .field("HCH", &GrossMethod2Result::HCH)
        .field("HN", &GrossMethod2Result::HN)
        .field("ierr", &GrossMethod2Result::ierr)
        .field("herr", &GrossMethod2Result::herr);
 
    // Detail bindings
    function("SetupDetail", &SetupDetail);
    function("MolarMassDetail", &MolarMassDetail_wrapper);
    function("PressureDetail", &PressureDetail_wrapper);
    function("DensityDetail", &DensityDetail_wrapper);
    function("PropertiesDetail", &PropertiesDetail_wrapper);
 
    // GERG bindings
    function("SetupGERG", &SetupGERG);
    function("MolarMassGERG", &MolarMassGERG_wrapper);
    function("PressureGERG", &PressureGERG_wrapper);
    function("DensityGERG", &DensityGERG_wrapper);
    function("PropertiesGERG", &PropertiesGERG_wrapper);
 
    // Gross bindings
    function("SetupGross", &SetupGross);
    function("MolarMassGross", &MolarMassGross_wrapper);
    function("PressureGross", &PressureGross_wrapper);
    function("DensityGross", &DensityGross_wrapper);
    function("GrossHv", &GrossHv_wrapper);
    function("GrossInputs", &GrossInputs_wrapper);
    function("Bmix", &Bmix_wrapper);
    function("GrossMethod1", &GrossMethod1_wrapper);
    function("GrossMethod2", &GrossMethod2_wrapper);
}

◆ gasMixture_to_vector()

std::vector< double > gasMixture_to_vector ( gasMixture js_object )

Converts a JavaScript gasMixture Object to a C++ struct.

Parameters

js_object JavaScript gasMixture object

Definition at line 311 of file bindings.cpp.

{
    std::vector<double> result(22);
    result[0] = 0;
    result[1] = js_object.methane;
    result[2] = js_object.nitrogen;
    result[3] = js_object.carbon_dioxide;
    result[4] = js_object.ethane;
    result[5] = js_object.propane;
    result[6] = js_object.isobutane;
    result[7] = js_object.n_butane;
    result[8] = js_object.isopentane;
    result[9] = js_object.n_pentane;
    result[10] = js_object.n_hexane;
    result[11] = js_object.n_heptane;
    result[12] = js_object.n_octane;
    result[13] = js_object.n_nonane;
    result[14] = js_object.n_decane;
    result[15] = js_object.hydrogen;
    result[16] = js_object.oxygen;
    result[17] = js_object.carbon_monoxide;
    result[18] = js_object.water;
    result[19] = js_object.hydrogen_sulfide;
    result[20] = js_object.helium;
    result[21] = js_object.argon;
    return result;
}

References gasMixture::argon, gasMixture::carbon_dioxide, gasMixture::carbon_monoxide, gasMixture::ethane, gasMixture::helium, gasMixture::hydrogen, gasMixture::hydrogen_sulfide, gasMixture::isobutane, gasMixture::isopentane, gasMixture::methane, gasMixture::n_butane, gasMixture::n_decane, gasMixture::n_heptane, gasMixture::n_hexane, gasMixture::n_nonane, gasMixture::n_octane, gasMixture::n_pentane, gasMixture::nitrogen, gasMixture::oxygen, gasMixture::propane, and gasMixture::water.

Referenced by DensityDetail_wrapper(), DensityGERG_wrapper(), GrossHv_wrapper(), GrossInputs_wrapper(), MolarMassDetail_wrapper(), MolarMassGERG_wrapper(), MolarMassGross_wrapper(), PressureDetail_wrapper(), PressureGERG_wrapper(), PropertiesDetail_wrapper(), and PropertiesGERG_wrapper().

◆ GrossHv_wrapper()

GrossHvResult GrossHv_wrapper ( gasMixture x_array )

Wrapper function to calculate gross heating values for a gas mixture.

Parameters

x_array Gas mixture composition in mole fraction

Returns

GrossHvResult Structure containing:

xGrs: Vector of calculated gross heating values for each component
HN: Normal gross heating value of the mixture
HCH: Chinese gross heating value of the mixture

This function serves as a wrapper around the GrossHv calculation, converting between array and vector data structures while maintaining the computational logic of the original GERG-2008 implementation.

See also: GrossHv For the underlying calculation implementation

Definition at line 731 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    std::vector<double> xGrs(x.size());
    double HN = 0, HCH = 0;
 
    GrossHv(x, xGrs, HN, HCH);
    GrossHvResult result = {vector_to_xGrs(xGrs), HN, HCH};
    return result;
}

References gasMixture_to_vector(), GrossHv(), and vector_to_xGrs().

Referenced by EMSCRIPTEN_BINDINGS().

◆ GrossInputs_wrapper()

GrossInputsResult GrossInputs_wrapper	(	double	T,
		double	P,
		gasMixture	x_array )

Wrapper function for GrossInputs calculation.

This function wraps the GrossInputs calculation to handle array conversions and provide a structured result

Parameters

T	Temperature value
P	Pressure value
x_array	Gas mixture composition in mole percent

Returns

GrossInputsResult Structure containing:

xGrs: Vector of gross mole fractions
Gr: Relative density
HN: Heating value (normal conditions) [MJ/m³]
HCH: Heating value (combustion conditions) [MJ/m³]
ierr: Error code (0 = success)
herr: Error message

See also: GrossInputs For the underlying calculation implementation

Definition at line 759 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    std::vector<double> xGrs(x.size());
    double Gr = 0, HN = 0, HCH = 0;
    int ierr = 0;
    std::string herr;
 
    GrossInputs(T, P, x, xGrs, Gr, HN, HCH, ierr, herr);
 
    GrossInputsResult result = {vector_to_xGrs(xGrs), Gr, HN, HCH, ierr, herr};
    return result;
}

References gasMixture_to_vector(), GrossInputs(), and vector_to_xGrs().

Referenced by EMSCRIPTEN_BINDINGS().

◆ GrossMethod1_wrapper()

GrossMethod1Result GrossMethod1_wrapper	(	double	Th,
		double	Td,
		double	Pd,
		xGrs	xGrs_object,
		double	Gr,
		double	Hv )

Wrapper function for GrossMethod1 calculation method.

Parameters

Th	Temperature high (T1) [K]
Td	Temperature difference (T1-T2) [K]
Pd	Pressure drop (P1-P2) [Pa]
xGrs_object	Array of mole fractions for the mixture components
Gr	Mass flow rate [kg/s]
Hv	Heating value [J/kg]

Returns

GrossMethod1Result Structure containing:

Updated mole fractions array
Mm (Molar mass) [kg/kmol]
HCH (Heat capacity [J/(kg·K)])
HN (Heat value normalized)
ierr (Error code, 0 = success)
herr (Error message string)

See also: GrossMethod1 For the underlying calculation implementation

Definition at line 823 of file bindings.cpp.

{
    std::vector<double> xGrs = xGrs_to_vector(xGrs_object);
    double Mm = 0, HCH = 0, HN = 0;
    int ierr = 0;
    std::string herr;
 
    GrossMethod1(Th, Td, Pd, xGrs, Gr, Hv, Mm, HCH, HN, ierr, herr);
 
    GrossMethod1Result result = {vector_to_xGrs(xGrs), Mm, HCH, HN, ierr, herr};
    return result;
}

References GrossMethod1(), vector_to_xGrs(), and xGrs_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ GrossMethod2_wrapper()

GrossMethod2Result GrossMethod2_wrapper	(	double	Th,
		double	Td,
		double	Pd,
		xGrs	xGrs_object,
		double	Gr )

Wrapper function for the GrossMethod2 calculation method.

Parameters

Th	Temperature at higher pressure (K)
Td	Temperature at lower pressure (K)
Pd	Pressure at lower temperature (kPa)
xGrs_object	Array containing molar composition of the gas mixture
Gr	Relative density of the gas mixture

Returns

GrossMethod2Result struct containing:

Updated molar composition array
Hv: Heating value
Mm: Molar mass
HCH: Hydrocarbon content
HN: Number related to heating value
ierr: Error code (0 = success)
herr: Error message string

See also: GrossMethod2 For the underlying calculation implementation

Definition at line 856 of file bindings.cpp.

{
    std::vector<double> xGrs = xGrs_to_vector(xGrs_object);
    double Hv = 0, Mm = 0, HCH = 0, HN = 0;
    int ierr = 0;
    std::string herr;
 
    GrossMethod2(Th, Td, Pd, xGrs, Gr, Hv, Mm, HCH, HN, ierr, herr);
 
    GrossMethod2Result result = {vector_to_xGrs(xGrs), Hv, Mm, HCH, HN, ierr, herr};
    return result;
}

References GrossMethod2(), vector_to_xGrs(), and xGrs_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ MolarMassDetail_wrapper()

double MolarMassDetail_wrapper ( gasMixture x_array )

Calculates the molar mass of a gas mixture given mole percentages.

This function wraps the MolarMassDetail calculation for use with external bindings. It converts the input array to a vector before calculating the molar mass.

Parameters

x_array Gas mixture composition in mole percentages

Returns: double Molar mass of the gas mixture in kg/mol

See also: MolarMassDetail For the underlying calculation implementation

Definition at line 423 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double Mm = 0;
    MolarMassDetail(x, Mm);
    return Mm;
}

References gasMixture_to_vector(), and MolarMassDetail().

Referenced by EMSCRIPTEN_BINDINGS().

◆ MolarMassGERG_wrapper()

double MolarMassGERG_wrapper ( gasMixture x_array )

Calculates the molar mass of a gas mixture using GERG-2008 equation of state.

Parameters

x_array Gas mixture composition in mole percent

Returns: double Molar mass of the mixture in kg/mol

This function serves as a wrapper for the MolarMassGERG calculation. It converts the input array to a vector format before performing the calculation.

See also: MolarMassGERG For the underlying calculation implementation

Definition at line 533 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double Mm = 0;
    MolarMassGERG(x, Mm);
    return Mm;
}

References gasMixture_to_vector(), and MolarMassGERG().

Referenced by EMSCRIPTEN_BINDINGS().

◆ MolarMassGross_wrapper()

double MolarMassGross_wrapper ( gasMixture x_array )

Calculates the gross molar mass of a gas mixture.

This function is a wrapper to MolarMassGross that converts a gas mixture composition from array to vector and calculates its gross molar mass.

Parameters

x_array Gas mixture composition in mole percent

Returns: double Gross molar mass of the mixture in g/mol

See also: MolarMassGross For the underlying calculation implementation

Definition at line 646 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double Mm = 0;
    MolarMassGross(x, Mm);
    return Mm;
}

References gasMixture_to_vector(), and MolarMassGross().

Referenced by EMSCRIPTEN_BINDINGS().

◆ PressureDetail_wrapper()

PressureResult PressureDetail_wrapper	(	double	T,
		double	D,
		gasMixture	x_array )

Wraps the PressureDetail function to calculate pressure and compressibility factor.

Parameters

T	Temperature in Kelvin
D	Density in mol/l
x_array	Gas mixture composition in mole percent

Returns

PressureResult Struct containing:

P: Pressure in kPa
Z: Compressibility factor (dimensionless)

This wrapper function converts the input array to a vector and handles the pressure calculation using PressureDetail, returning the results in a convenient struct.

See also: PressureDetail For the underlying calculation implementation

Definition at line 445 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double P = 0, Z = 0;
    PressureDetail(T, D, x, P, Z);
    PressureResult result = {P, Z};
    return result;
}

References gasMixture_to_vector(), and PressureDetail().

Referenced by EMSCRIPTEN_BINDINGS().

◆ PressureGERG_wrapper()

PressureResult PressureGERG_wrapper	(	double	T,
		double	D,
		gasMixture	x_array )

Calculates pressure and compressibility factor using GERG-2008 equation of state.

Parameters

T	Temperature in K
D	Density in mol/l (or mol/dm³)
x_array	Gas mixture composition in mole percent

Returns

PressureResult Struct containing:

P: Pressure in kPa
Z: Compressibility factor (dimensionless)

This function is a wrapper around the PressureGERG function that handles the conversion between array and vector representations of the gas mixture composition.

See also: PressureGERG For the underlying calculation implementation

Definition at line 556 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double P = 0, Z = 0;
    PressureGERG(T, D, x, P, Z);
 
    PressureResult result = {P, Z};
    return result;
}

References gasMixture_to_vector(), and PressureGERG().

Referenced by EMSCRIPTEN_BINDINGS().

◆ PressureGross_wrapper()

PressureGrossResult PressureGross_wrapper	(	double	T,
		double	D,
		xGrs	xGrs_object,
		double	HCH )

Wrapper function for PressureGross calculation.

This function wraps the PressureGross calculation to provide a simplified interface for computing pressure and compressibility factor for natural gas mixtures.

Parameters

T	Temperature in K
D	Density in mol/l
xGrs_object	Array containing mole fractions of components
HCH	Gross heating value in MJ/m³

Returns

PressureGrossResult struct containing:

P: Pressure in kPa
Z: Compressibility factor
ierr: Error code (0 = success)
herr: Error message

See also: PressureGross For the underlying calculation implementation

Definition at line 673 of file bindings.cpp.

{
    std::vector<double> xGrs = xGrs_to_vector(xGrs_object);
    double P = 0, Z = 0;
    int ierr = 0;
    std::string herr;
 
    PressureGross(T, D, xGrs, HCH, P, Z, ierr, herr);
 
    PressureGrossResult result = {P, Z, ierr, herr};
    return result;
}

References PressureGross(), and xGrs_to_vector().

Referenced by EMSCRIPTEN_BINDINGS().

◆ PropertiesDetail_wrapper()

PropertiesDetailResult PropertiesDetail_wrapper	(	double	T,
		double	D,
		gasMixture	x_array )

Wrapper function to calculate detailed thermodynamic properties of a gas mixture.

Parameters

T	Temperature [K]
D	Density [mol/l]
x_array	Gas mixture composition in mole percent

Returns

PropertiesDetailResult struct containing:

P: Pressure [kPa]
Z: Compressibility factor [-]
dPdD: Pressure derivative with respect to density [(kPa·l)/mol]
d2PdD2: Second pressure derivative with respect to density [(kPa·l²)/mol²]
d2PdTD: Mixed pressure derivative with respect to temperature and density [(kPa·l)/(mol·K)]
dPdT: Pressure derivative with respect to temperature [kPa/K]
U: Internal energy [J/mol]
H: Enthalpy [J/mol]
S: Entropy [J/(mol·K)]
Cv: Isochoric heat capacity [J/(mol·K)]
Cp: Isobaric heat capacity [J/(mol·K)]
W: Speed of sound [m/s]
G: Gibbs energy [J/mol]
JT: Joule-Thomson coefficient [K/kPa]
Kappa: Isentropic exponent [-]
Cf: Critical flow factor [-]

See also: PropertiesDetail For the underlying calculation implementation

Definition at line 507 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double P = 0, Z = 0, dPdD = 0, d2PdD2 = 0, d2PdTD = 0, dPdT = 0;
    double U = 0, H = 0, S = 0, Cv = 0, Cp = 0, W = 0, G = 0, JT = 0, Kappa = 0, Cf = 0;
 
    PropertiesDetail(T, D, x, P, Z, dPdD, d2PdD2, d2PdTD, dPdT,
                     U, H, S, Cv, Cp, W, G, JT, Kappa, Cf);
 
    PropertiesDetailResult result = {P, Z, dPdD, d2PdD2, d2PdTD, dPdT, U, H, S, Cv, Cp, W, G, JT, Kappa, Cf};
 
    return result;
}

References gasMixture_to_vector(), and PropertiesDetail().

Referenced by EMSCRIPTEN_BINDINGS().

◆ PropertiesGERG_wrapper()

PropertiesGERGResult PropertiesGERG_wrapper	(	double	T,
		double	D,
		gasMixture	x_array )

Calculates thermodynamic properties using GERG-2008 equation of state.

Parameters

T	Temperature [K]
D	Density [kg/m³]
x_array	Array of mole fractions [%] of the mixture components

Returns

PropertiesGERGResult struct containing:

P: Pressure [kPa]
Z: Compressibility factor [-]
dPdD: Partial derivative of pressure with respect to density [(kPa)/(kg/m³)]
d2PdD2: Second partial derivative of pressure with respect to density [(kPa)/(kg/m³)²]
d2PdTD: Mixed partial derivative of pressure with respect to temperature and density [(kPa)/(K·kg/m³)]
dPdT: Partial derivative of pressure with respect to temperature [kPa/K]
U: Internal energy [J/kg]
H: Enthalpy [J/kg]
S: Entropy [J/(kg·K)]
Cv: Isochoric heat capacity [J/(kg·K)]
Cp: Isobaric heat capacity [J/(kg·K)]
W: Speed of sound [m/s]
G: Gibbs energy [J/kg]
JT: Joule-Thomson coefficient [K/kPa]
Kappa: Isentropic exponent [-]
A: Helmholtz energy [J/kg]
Cf: Critical flow factor [-]

See also: PropertiesGERG For the underlying calculation implementation

Definition at line 621 of file bindings.cpp.

{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double P = 0, Z = 0, dPdD = 0, d2PdD2 = 0, d2PdTD = 0, dPdT = 0;
    double U = 0, H = 0, S = 0, Cv = 0, Cp = 0, W = 0, G = 0, JT = 0, Kappa = 0, A = 0, Cf = 0;
 
    PropertiesGERG(T, D, x, P, Z, dPdD, d2PdD2, d2PdTD, dPdT,
                   U, H, S, Cv, Cp, W, G, JT, Kappa, A, Cf);
 
    PropertiesGERGResult result = {P, Z, dPdD, d2PdD2, d2PdTD, dPdT, U, H, S, Cv, Cp, W, G, JT, Kappa, A, Cf};
    return result;
}

References gasMixture_to_vector(), and PropertiesGERG().

Referenced by EMSCRIPTEN_BINDINGS().

◆ vector_to_array()

val vector_to_array ( const std::vector< double > & vec )

Converts a C++ vector of doubles to a JavaScript array.

Parameters

vec	The input vector containing double values to convert

Returns: val A JavaScript array containing the values from the input vector

This function takes a C++ vector of doubles and creates a new JavaScript array, copying each element from the vector to the corresponding index in the JavaScript array. The function is typically used for interoperability between C++ and JavaScript/WebAssembly.

Definition at line 401 of file bindings.cpp.

{
    val result = val::array();
    for (size_t i = 0; i < vec.size(); ++i)
    {
        result.set(i, vec[i]);
    }
    return result;
}

◆ vector_to_xGrs()

xGrs vector_to_xGrs ( const std::vector< double > & vec )

Converts a C++ vector to a JavaScript xGrs object.

Parameters

vec	C++ vector containing the xGrs values

Definition at line 359 of file bindings.cpp.

{
    xGrs result;
    result.hydrocarbon = vec[1];
    result.nitrogen = vec[2];
    result.carbon_dioxide = vec[3];
    return result;
}

References xGrs::carbon_dioxide, xGrs::hydrocarbon, and xGrs::nitrogen.

Referenced by GrossHv_wrapper(), GrossInputs_wrapper(), GrossMethod1_wrapper(), and GrossMethod2_wrapper().

◆ xGrs_to_vector()

std::vector< double > xGrs_to_vector ( xGrs js_object )

Converts a JavaScript xGrs Object to a C++ struct.

Parameters

js_object JavaScript xGrs object

Definition at line 344 of file bindings.cpp.

{
    std::vector<double> result(3);
    result[0] = 0;
    result[1] = js_object.hydrocarbon;
    result[2] = js_object.nitrogen;
    result[3] = js_object.carbon_dioxide;
    return result;
}

References xGrs::carbon_dioxide, xGrs::hydrocarbon, and xGrs::nitrogen.

Referenced by Bmix_wrapper(), DensityGross_wrapper(), GrossMethod1_wrapper(), GrossMethod2_wrapper(), and PressureGross_wrapper().

Data Structures

Functions

Detailed Description

Function Documentation

◆ array_to_vector()

◆ Bmix_wrapper()

◆ DensityDetail_wrapper()

◆ DensityGERG_wrapper()

◆ DensityGross_wrapper()

◆ EMSCRIPTEN_BINDINGS()

◆ gasMixture_to_vector()

◆ GrossHv_wrapper()

◆ GrossInputs_wrapper()

◆ GrossMethod1_wrapper()

◆ GrossMethod2_wrapper()

◆ MolarMassDetail_wrapper()

◆ MolarMassGERG_wrapper()

◆ MolarMassGross_wrapper()

◆ PressureDetail_wrapper()

◆ PressureGERG_wrapper()

◆ PressureGross_wrapper()

◆ PropertiesDetail_wrapper()

◆ PropertiesGERG_wrapper()

◆ vector_to_array()

◆ vector_to_xGrs()

◆ xGrs_to_vector()