ctthermo.cpp

Go to the documentation of this file.

/**
 *  CTTHERMO - Generated CLib %Cantera interface library.
 *
 *  @file ctthermo.cpp
 *
 *  Generated CLib API for Cantera's ThermoPhase class.
 *
 *  This file was generated by sourcegen. It will be re-generated by the
 *  %Cantera build process. Do not manually edit.
 *
 *  @warning  This module is an experimental part of the %Cantera API and
 *      may be changed without notice.
 */
 
// This file is part of Cantera. See License.txt in the top-level directory or
// at https://cantera.org/license.txt for license and copyright information.
 
#include "clib_utils.h"
#include "cantera_clib/ctthermo.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/thermo/ThermoFactory.h"
#include "cantera/thermo/SurfPhase.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<ThermoPhase> (single-instance object)
typedef Cabinet<ThermoPhase> ThermoPhaseCabinet;
template<> ThermoPhaseCabinet* ThermoPhaseCabinet::s_storage = 0;  // initialized here
 
//! @endcond
 
extern "C" {
 
    int32_t thermo_name(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string Phase::name()
        try {
            string out = ThermoPhaseCabinet::as<Phase>(handle)->name();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setName(int32_t handle, const char* nm)
    {
        // setter: void Phase::setName(const string&)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setName(nm);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_type(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string ThermoPhase::type()
        try {
            string out = ThermoPhaseCabinet::at(handle)->type();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_nElements(int32_t handle)
    {
        // size getter: size_t Phase::nElements()
        try {
            return static_cast<int32_t>(ThermoPhaseCabinet::as<Phase>(handle)->nElements());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t thermo_nSpecies(int32_t handle)
    {
        // size getter: size_t Phase::nSpecies()
        try {
            return static_cast<int32_t>(ThermoPhaseCabinet::as<Phase>(handle)->nSpecies());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double thermo_temperature(int32_t handle)
    {
        // getter: double Phase::temperature()
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->temperature();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_setTemperature(int32_t handle, double temp)
    {
        // setter: virtual void Phase::setTemperature(double)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setTemperature(temp);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_pressure(int32_t handle)
    {
        // getter: virtual double Phase::pressure()
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->pressure();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_setPressure(int32_t handle, double p)
    {
        // setter: virtual void Phase::setPressure(double)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setPressure(p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_density(int32_t handle)
    {
        // getter: virtual double Phase::density()
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->density();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_setDensity(int32_t handle, const double density_)
    {
        // setter: virtual void Phase::setDensity(const double)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setDensity(density_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_molarDensity(int32_t handle)
    {
        // getter: virtual double Phase::molarDensity()
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->molarDensity();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_meanMolecularWeight(int32_t handle)
    {
        // getter: double Phase::meanMolecularWeight()
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->meanMolecularWeight();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_moleFraction(int32_t handle, int32_t k)
    {
        // method: double Phase::moleFraction(size_t)
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->moleFraction(k);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_massFraction(int32_t handle, int32_t k)
    {
        // method: double Phase::massFraction(size_t)
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->massFraction(k);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_getMoleFractions(int32_t handle, int32_t xLen, double* x)
    {
        // array getter: void Phase::getMoleFractions(span<double>)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (static_cast<size_t>(xLen) < obj->nSpecies()) {
                throw ArraySizeError("thermo_getMoleFractions", xLen, obj->nSpecies());
            }
            span<double> x_(x, xLen);
            obj->getMoleFractions(x_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getMassFractions(int32_t handle, int32_t yLen, double* y)
    {
        // array getter: void Phase::getMassFractions(span<double>)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (static_cast<size_t>(yLen) < obj->nSpecies()) {
                throw ArraySizeError("thermo_getMassFractions", yLen, obj->nSpecies());
            }
            span<double> y_(y, yLen);
            obj->getMassFractions(y_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setMoleFractions(int32_t handle, int32_t xLen, const double* x)
    {
        // setter: virtual void Phase::setMoleFractions(span<const double>)
        try {
            span<const double> x_(x, xLen);
            ThermoPhaseCabinet::as<Phase>(handle)->setMoleFractions(x_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setMassFractions(int32_t handle, int32_t yLen, const double* y)
    {
        // setter: virtual void Phase::setMassFractions(span<const double>)
        try {
            span<const double> y_(y, yLen);
            ThermoPhaseCabinet::as<Phase>(handle)->setMassFractions(y_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setMoleFractionsByName(int32_t handle, const char* x)
    {
        // setter: void Phase::setMoleFractionsByName(const string&)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setMoleFractionsByName(x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setMassFractionsByName(int32_t handle, const char* x)
    {
        // setter: void Phase::setMassFractionsByName(const string&)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setMassFractionsByName(x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_atomicWeights(int32_t handle, int32_t bufLen, double* buf)
    {
        // array getter: span<const double> Phase::atomicWeights()
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (static_cast<size_t>(bufLen) < obj->nElements()) {
                throw ArraySizeError("thermo_atomicWeights", bufLen, obj->nElements());
            }
            span<const double> out = obj->atomicWeights();
            std::copy(out.begin(), out.end(), buf);
            return int(out.size());
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getMolecularWeights(int32_t handle, int32_t weightsLen, double* weights)
    {
        // array getter: void Phase::getMolecularWeights(span<double>)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (static_cast<size_t>(weightsLen) < obj->nSpecies()) {
                throw ArraySizeError("thermo_getMolecularWeights", weightsLen, obj->nSpecies());
            }
            span<double> weights_(weights, weightsLen);
            obj->getMolecularWeights(weights_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getCharges(int32_t handle, int32_t chargesLen, double* charges)
    {
        // array getter: void Phase::getCharges(span<double>)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (static_cast<size_t>(chargesLen) < obj->nElements()) {
                throw ArraySizeError("thermo_getCharges", chargesLen, obj->nElements());
            }
            span<double> charges_(charges, chargesLen);
            obj->getCharges(charges_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_elementName(int32_t handle, int32_t m, int32_t bufLen, char* buf)
    {
        // method: string Phase::elementName(size_t)
        try {
            string out = ThermoPhaseCabinet::as<Phase>(handle)->elementName(m);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_speciesName(int32_t handle, int32_t k, int32_t bufLen, char* buf)
    {
        // method: string Phase::speciesName(size_t)
        try {
            string out = ThermoPhaseCabinet::as<Phase>(handle)->speciesName(k);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_elementIndex(int32_t handle, const char* name)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            return static_cast<int32_t>(ThermoPhaseCabinet::as<Phase>(handle)->elementIndex(name, true));
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_speciesIndex(int32_t handle, const char* name)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            return static_cast<int32_t>(ThermoPhaseCabinet::as<Phase>(handle)->speciesIndex(name, true));
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_nAtoms(int32_t handle, int32_t k, int32_t m)
    {
        // method: double Phase::nAtoms(size_t, size_t)
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->nAtoms(k, m);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_addElement(int32_t handle, const char* symbol, double weight, int32_t atomicNumber, double entropy298, int32_t elem_type)
    {
        // size getter: size_t Phase::addElement(const string&, double, int, double, int)
        try {
            return static_cast<int32_t>(ThermoPhaseCabinet::as<Phase>(handle)->addElement(symbol, weight, atomicNumber, entropy298, elem_type));
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double thermo_refPressure(int32_t handle)
    {
        // getter: virtual double ThermoPhase::refPressure()
        try {
            return ThermoPhaseCabinet::at(handle)->refPressure();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_minTemp(int32_t handle, int32_t k)
    {
        // method: virtual double ThermoPhase::minTemp(size_t)
        try {
            return ThermoPhaseCabinet::at(handle)->minTemp(k);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_maxTemp(int32_t handle, int32_t k)
    {
        // method: virtual double ThermoPhase::maxTemp(size_t)
        try {
            return ThermoPhaseCabinet::at(handle)->maxTemp(k);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_enthalpy_mole(int32_t handle)
    {
        // getter: virtual double ThermoPhase::enthalpy_mole()
        try {
            return ThermoPhaseCabinet::at(handle)->enthalpy_mole();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_enthalpy_mass(int32_t handle)
    {
        // getter: double ThermoPhase::enthalpy_mass()
        try {
            return ThermoPhaseCabinet::at(handle)->enthalpy_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_entropy_mole(int32_t handle)
    {
        // getter: virtual double ThermoPhase::entropy_mole()
        try {
            return ThermoPhaseCabinet::at(handle)->entropy_mole();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_entropy_mass(int32_t handle)
    {
        // getter: double ThermoPhase::entropy_mass()
        try {
            return ThermoPhaseCabinet::at(handle)->entropy_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_intEnergy_mole(int32_t handle)
    {
        // getter: virtual double ThermoPhase::intEnergy_mole()
        try {
            return ThermoPhaseCabinet::at(handle)->intEnergy_mole();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_intEnergy_mass(int32_t handle)
    {
        // getter: double ThermoPhase::intEnergy_mass()
        try {
            return ThermoPhaseCabinet::at(handle)->intEnergy_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_gibbs_mole(int32_t handle)
    {
        // getter: virtual double ThermoPhase::gibbs_mole()
        try {
            return ThermoPhaseCabinet::at(handle)->gibbs_mole();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_gibbs_mass(int32_t handle)
    {
        // getter: double ThermoPhase::gibbs_mass()
        try {
            return ThermoPhaseCabinet::at(handle)->gibbs_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_cp_mole(int32_t handle)
    {
        // getter: virtual double ThermoPhase::cp_mole()
        try {
            return ThermoPhaseCabinet::at(handle)->cp_mole();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_cp_mass(int32_t handle)
    {
        // getter: double ThermoPhase::cp_mass()
        try {
            return ThermoPhaseCabinet::at(handle)->cp_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_cv_mole(int32_t handle)
    {
        // getter: virtual double ThermoPhase::cv_mole()
        try {
            return ThermoPhaseCabinet::at(handle)->cv_mole();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_cv_mass(int32_t handle)
    {
        // getter: double ThermoPhase::cv_mass()
        try {
            return ThermoPhaseCabinet::at(handle)->cv_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_getChemPotentials(int32_t handle, int32_t muLen, double* mu)
    {
        // array getter: virtual void ThermoPhase::getChemPotentials(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> mu_(mu, muLen);
            obj->getChemPotentials(mu_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getElectrochemPotentials(int32_t handle, int32_t muLen, double* mu)
    {
        // array getter: void ThermoPhase::getElectrochemPotentials(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> mu_(mu, muLen);
            obj->getElectrochemPotentials(mu_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_electricPotential(int32_t handle)
    {
        // getter: double ThermoPhase::electricPotential()
        try {
            return ThermoPhaseCabinet::at(handle)->electricPotential();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_setElectricPotential(int32_t handle, double v)
    {
        // setter: void ThermoPhase::setElectricPotential(double)
        try {
            ThermoPhaseCabinet::at(handle)->setElectricPotential(v);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_thermalExpansionCoeff(int32_t handle)
    {
        // getter: virtual double ThermoPhase::thermalExpansionCoeff()
        try {
            return ThermoPhaseCabinet::at(handle)->thermalExpansionCoeff();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_isothermalCompressibility(int32_t handle)
    {
        // getter: virtual double ThermoPhase::isothermalCompressibility()
        try {
            return ThermoPhaseCabinet::at(handle)->isothermalCompressibility();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_getPartialMolarEnthalpies(int32_t handle, int32_t hbarLen, double* hbar)
    {
        // array getter: virtual void ThermoPhase::getPartialMolarEnthalpies(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> hbar_(hbar, hbarLen);
            obj->getPartialMolarEnthalpies(hbar_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarEntropies(int32_t handle, int32_t sbarLen, double* sbar)
    {
        // array getter: virtual void ThermoPhase::getPartialMolarEntropies(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> sbar_(sbar, sbarLen);
            obj->getPartialMolarEntropies(sbar_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarIntEnergies(int32_t handle, int32_t ubarLen, double* ubar)
    {
        // array getter: virtual void ThermoPhase::getPartialMolarIntEnergies(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> ubar_(ubar, ubarLen);
            obj->getPartialMolarIntEnergies(ubar_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarCp(int32_t handle, int32_t cpbarLen, double* cpbar)
    {
        // array getter: virtual void ThermoPhase::getPartialMolarCp(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> cpbar_(cpbar, cpbarLen);
            obj->getPartialMolarCp(cpbar_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarVolumes(int32_t handle, int32_t vbarLen, double* vbar)
    {
        // array getter: virtual void ThermoPhase::getPartialMolarVolumes(span<double>)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            span<double> vbar_(vbar, vbarLen);
            obj->getPartialMolarVolumes(vbar_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TPX(int32_t handle, double t, double p, int32_t xLen, const double* x)
    {
        // method: virtual void ThermoPhase::setState_TPX(double, double, span<const double>)
        try {
            span<const double> x_(x, xLen);
            ThermoPhaseCabinet::at(handle)->setState_TPX(t, p, x_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TPX_byName(int32_t handle, double t, double p, const char* x)
    {
        // method: virtual void ThermoPhase::setState_TPX(double, double, const string&)
        try {
            ThermoPhaseCabinet::at(handle)->setState_TPX(t, p, x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TPY(int32_t handle, double t, double p, int32_t yLen, const double* y)
    {
        // method: virtual void ThermoPhase::setState_TPY(double, double, span<const double>)
        try {
            span<const double> y_(y, yLen);
            ThermoPhaseCabinet::at(handle)->setState_TPY(t, p, y_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TPY_byName(int32_t handle, double t, double p, const char* y)
    {
        // method: virtual void ThermoPhase::setState_TPY(double, double, const string&)
        try {
            ThermoPhaseCabinet::at(handle)->setState_TPY(t, p, y);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TP(int32_t handle, double t, double p)
    {
        // method: virtual void ThermoPhase::setState_TP(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_TP(t, p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TD(int32_t handle, double t, double rho)
    {
        // method: void Phase::setState_TD(double, double)
        try {
            ThermoPhaseCabinet::as<Phase>(handle)->setState_TD(t, rho);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_DP(int32_t handle, double rho, double p)
    {
        // method: virtual void ThermoPhase::setState_DP(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_DP(rho, p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_HP(int32_t handle, double h, double p)
    {
        // method: virtual void ThermoPhase::setState_HP(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_HP(h, p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_UV(int32_t handle, double u, double v)
    {
        // method: virtual void ThermoPhase::setState_UV(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_UV(u, v);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_SV(int32_t handle, double s, double v)
    {
        // method: virtual void ThermoPhase::setState_SV(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_SV(s, v);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_SP(int32_t handle, double s, double p)
    {
        // method: virtual void ThermoPhase::setState_SP(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_SP(s, p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_ST(int32_t handle, double s, double t)
    {
        // method: virtual void ThermoPhase::setState_ST(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_ST(s, t);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TV(int32_t handle, double t, double v)
    {
        // method: virtual void ThermoPhase::setState_TV(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_TV(t, v);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_PV(int32_t handle, double p, double v)
    {
        // method: virtual void ThermoPhase::setState_PV(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_PV(p, v);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_UP(int32_t handle, double u, double p)
    {
        // method: virtual void ThermoPhase::setState_UP(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_UP(u, p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_VH(int32_t handle, double v, double h)
    {
        // method: virtual void ThermoPhase::setState_VH(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_VH(v, h);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_TH(int32_t handle, double t, double h)
    {
        // method: virtual void ThermoPhase::setState_TH(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_TH(t, h);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_SH(int32_t handle, double s, double h)
    {
        // method: virtual void ThermoPhase::setState_SH(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_SH(s, h);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_equilibrate(int32_t handle, const char* XY, const char* solver, double rtol, int32_t max_steps, int32_t max_iter, int32_t estimate_equil)
    {
        // method: void ThermoPhase::equilibrate(const string&, const string&, double, int, int, int)
        try {
            ThermoPhaseCabinet::at(handle)->equilibrate(XY, solver, rtol, max_steps, max_iter, estimate_equil);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double thermo_critTemperature(int32_t handle)
    {
        // getter: virtual double ThermoPhase::critTemperature()
        try {
            return ThermoPhaseCabinet::at(handle)->critTemperature();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_critPressure(int32_t handle)
    {
        // getter: virtual double ThermoPhase::critPressure()
        try {
            return ThermoPhaseCabinet::at(handle)->critPressure();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_critDensity(int32_t handle)
    {
        // getter: virtual double ThermoPhase::critDensity()
        try {
            return ThermoPhaseCabinet::at(handle)->critDensity();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_vaporFraction(int32_t handle)
    {
        // getter: virtual double ThermoPhase::vaporFraction()
        try {
            return ThermoPhaseCabinet::at(handle)->vaporFraction();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_satTemperature(int32_t handle, double p)
    {
        // method: virtual double ThermoPhase::satTemperature(double)
        try {
            return ThermoPhaseCabinet::at(handle)->satTemperature(p);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double thermo_satPressure(int32_t handle, double t)
    {
        // method: virtual double ThermoPhase::satPressure(double)
        try {
            return ThermoPhaseCabinet::at(handle)->satPressure(t);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t thermo_setState_Psat(int32_t handle, double p, double x)
    {
        // method: virtual void ThermoPhase::setState_Psat(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_Psat(p, x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setState_Tsat(int32_t handle, double t, double x)
    {
        // method: virtual void ThermoPhase::setState_Tsat(double, double)
        try {
            ThermoPhaseCabinet::at(handle)->setState_Tsat(t, x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t surf_getCoverages(int32_t handle, int32_t thetaLen, double* theta)
    {
        // array getter: void SurfPhase::getCoverages(span<double>)
        try {
            auto obj = ThermoPhaseCabinet::as<SurfPhase>(handle);
            // no size checking specified
            span<double> theta_(theta, thetaLen);
            obj->getCoverages(theta_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t surf_setCoverages(int32_t handle, int32_t thetaLen, const double* theta)
    {
        // setter: void SurfPhase::setCoverages(span<const double>)
        try {
            span<const double> theta_(theta, thetaLen);
            ThermoPhaseCabinet::as<SurfPhase>(handle)->setCoverages(theta_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getConcentrations(int32_t handle, int32_t cLen, double* c)
    {
        // array getter: virtual void Phase::getConcentrations(span<double>)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            // no size checking specified
            span<double> c_(c, cLen);
            obj->getConcentrations(c_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setConcentrations(int32_t handle, int32_t concLen, const double* conc)
    {
        // setter: virtual void Phase::setConcentrations(span<const double>)
        try {
            span<const double> conc_(conc, concLen);
            ThermoPhaseCabinet::as<Phase>(handle)->setConcentrations(conc_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double surf_siteDensity(int32_t handle)
    {
        // getter: double SurfPhase::siteDensity()
        try {
            return ThermoPhaseCabinet::as<SurfPhase>(handle)->siteDensity();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t surf_setSiteDensity(int32_t handle, double n0)
    {
        // setter: void SurfPhase::setSiteDensity(double)
        try {
            ThermoPhaseCabinet::as<SurfPhase>(handle)->setSiteDensity(n0);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t surf_setCoveragesByName(int32_t handle, const char* cov)
    {
        // setter: void SurfPhase::setCoveragesByName(const string&)
        try {
            ThermoPhaseCabinet::as<SurfPhase>(handle)->setCoveragesByName(cov);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_setEquivalenceRatio(int32_t handle, double phi, const char* fuelComp, const char* oxComp)
    {
        // method: void ThermoPhase::setEquivalenceRatio(double, const string&, const string&)
        try {
            ThermoPhaseCabinet::at(handle)->setEquivalenceRatio(phi, fuelComp, oxComp);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_report(int32_t handle, int32_t show_thermo, double threshold, int32_t bufLen, char* buf)
    {
        // method: virtual string ThermoPhase::report(bool, double)
        try {
            bool show_thermo_ = (show_thermo != 0);
            string out = ThermoPhaseCabinet::at(handle)->report(show_thermo_, threshold);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_print(int32_t handle, int32_t showThermo, double threshold)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            bool show = (showThermo != 0);
            writelog(ThermoPhaseCabinet::at(handle)->report(show, threshold));
            return 0;
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_del(int32_t handle)
    {
        // destructor
        try {
            ThermoPhaseCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return ThermoPhaseCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"