bindings.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2025 Ronan LE MEILLAT
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#include <emscripten/bind.h>
#include <emscripten/val.h>
#include "Detail.h"
#include "GERG2008.h"
#include "Gross.h"
 
using namespace emscripten;

struct gasMixture
{
    double methane;          
    double nitrogen;         
    double carbon_dioxide;   
    double ethane;           
    double propane;          
    double isobutane;        
    double n_butane;         
    double isopentane;       
    double n_pentane;        
    double n_hexane;         
    double n_heptane;        
    double n_octane;         
    double n_nonane;         
    double n_decane;         
    double hydrogen;         
    double oxygen;           
    double carbon_monoxide;  
    double water;            
    double hydrogen_sulfide; 
    double helium;           
    double argon;            
};

struct PressureResult
{
    double P; 
    double Z; 
};

struct DensityResult
{
    double D;         
    int ierr;         
    std::string herr; 
};

struct PropertiesDetailResult
{
    double P;      
    double Z;      
    double dPdD;   
    double d2PdD2; 
    double d2PdTD; 
    double dPdT;   
    double U;      
    double H;      
    double S;      
    double Cv;     
    double Cp;     
    double W;      
    double G;      
    double JT;     
    double Kappa;  
    double Cf;     
};

struct PropertiesGERGResult
{
    double P;      
    double Z;      
    double dPdD;   
    double d2PdD2; 
    double d2PdTD; 
    double dPdT;   
    double U;      
    double H;      
    double S;      
    double Cv;     
    double Cp;     
    double W;      
    double G;      
    double JT;     
    double Kappa;  
    double A;      
    double Cf;     
};

struct xGrs
{
    double hydrocarbon;    
    double nitrogen;       
    double carbon_dioxide; 
};

struct PressureGrossResult
{
    double P;         
    double Z;         
    int ierr;         
    std::string herr; 
};

struct GrossHvResult
{
    xGrs xGrs;  
    double HN;  
    double HCH; 
};
 
struct GrossInputsResult
{
    xGrs xGrs;        
    double Gr;        
    double HN;        
    double HCH;       
    int ierr;         
    std::string herr; 
};
 
struct BmixResult
{
    double B;         
    double C;         
    int ierr;         
    std::string herr; 
};
 
struct GrossMethod1Result
{
    xGrs xGrs;        
    double Mm;        
    double HCH;       
    double HN;        
    int ierr;         
    std::string herr; 
};
 
struct GrossMethod2Result
{
    xGrs xGrs;        
    double Hv;        
    double Mm;        
    double HCH;       
    double HN;        
    int ierr;         
    std::string herr; 
};
 
// Helper function to convert a JavaScript object to a C++ struct
std::vector<double> gasMixture_to_vector(gasMixture js_object)
{
    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;
}
 
// Helper function to convert a JavaScript xGr object to a C++ struct
std::vector<double> xGrs_to_vector(xGrs js_object)
{
    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;
}
 
// Helper function to convert a vector to a xGrs JavaScript object
xGrs vector_to_xGrs(const std::vector<double> &vec)
{
    xGrs result;
    result.hydrocarbon = vec[1];
    result.nitrogen = vec[2];
    result.carbon_dioxide = vec[3];
    return result;
}
 
// Helper function to convert a JavaScript array to a C++ vector
std::vector<double> array_to_vector(const val &js_array)
{
    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;
}
 
// Helper function to convert a C++ vector to a JavaScript array
val vector_to_array(const std::vector<double> &vec)
{
    val result = val::array();
    for (size_t i = 0; i < vec.size(); ++i)
    {
        result.set(i, vec[i]);
    }
    return result;
}
 
// Detail wrappers
double MolarMassDetail_wrapper(gasMixture x_array)
{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double Mm = 0;
    MolarMassDetail(x, Mm);
    return Mm;
}

PressureResult PressureDetail_wrapper(double T, double D, gasMixture x_array)
{
    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;
}

DensityResult DensityDetail_wrapper(double T, double P, gasMixture x_array)
{
    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;
}

PropertiesDetailResult PropertiesDetail_wrapper(double T, double D, gasMixture x_array)
{
    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;
}
 
// GERG wrappers
double MolarMassGERG_wrapper(gasMixture x_array)
{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double Mm = 0;
    MolarMassGERG(x, Mm);
    return Mm;
}

PressureResult PressureGERG_wrapper(double T, double D, gasMixture x_array)
{
    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;
}

DensityResult DensityGERG_wrapper(int iflag, double T, double P, gasMixture x_array)
{
    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;
}

PropertiesGERGResult PropertiesGERG_wrapper(double T, double D, gasMixture x_array)
{
    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;
}
 
// Gross wrappers
double MolarMassGross_wrapper(gasMixture x_array)
{
    std::vector<double> x = gasMixture_to_vector(x_array);
    double Mm = 0;
    MolarMassGross(x, Mm);
    return Mm;
}

PressureGrossResult PressureGross_wrapper(double T, double D, xGrs xGrs_object, double HCH)
{
    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;
}

DensityResult DensityGross_wrapper(double T, double P, xGrs xGrs_object, double HCH)
{
    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;
}

GrossHvResult GrossHv_wrapper(gasMixture x_array)
{
    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;
}

GrossInputsResult GrossInputs_wrapper(double T, double P, gasMixture x_array)
{
    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;
}

BmixResult Bmix_wrapper(double T, xGrs xGrs_object, double HCH)
{
    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;
}

GrossMethod1Result GrossMethod1_wrapper(double Th, double Td, double Pd, xGrs xGrs_object, double Gr, double Hv)
{
    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;
}

GrossMethod2Result GrossMethod2_wrapper(double Th, double Td, double Pd, xGrs xGrs_object, double Gr)
{
    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;
}

EMSCRIPTEN_BINDINGS(AGA8_module)
{
    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);
}