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)
    {
        // getter: size_t Phase::nElements()
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->nElements();
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t thermo_nSpecies(int32_t handle)
    {
        // getter: size_t Phase::nSpecies()
        try {
            return 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)
    {
        // getter: void Phase::getMoleFractions(double* const)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (xLen < obj->nSpecies()) {
                throw ArraySizeError("thermo_getMoleFractions", xLen, obj->nSpecies());
            }
            obj->getMoleFractions(x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getMassFractions(int32_t handle, int32_t yLen, double* y)
    {
        // getter: void Phase::getMassFractions(double* const)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (yLen < obj->nSpecies()) {
                throw ArraySizeError("thermo_getMassFractions", yLen, obj->nSpecies());
            }
            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(const double* const)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (xLen != obj->nSpecies()) {
                throw ArraySizeError("thermo_setMoleFractions", xLen, obj->nSpecies());
            }
            obj->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(const double* const)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (yLen != obj->nSpecies()) {
                throw ArraySizeError("thermo_setMassFractions", yLen, obj->nSpecies());
            }
            obj->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)
    {
        // getter: const vector<double>& Phase::atomicWeights()
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (bufLen < obj->nElements()) {
                throw ArraySizeError("thermo_atomicWeights", bufLen, obj->nElements());
            }
            const vector<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)
    {
        // getter: void Phase::getMolecularWeights(double*)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (weightsLen < obj->nSpecies()) {
                throw ArraySizeError("thermo_getMolecularWeights", weightsLen, obj->nSpecies());
            }
            obj->getMolecularWeights(weights);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getCharges(int32_t handle, int32_t chargesLen, double* charges)
    {
        // getter: void Phase::getCharges(double*)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            if (chargesLen < obj->nElements()) {
                throw ArraySizeError("thermo_getCharges", chargesLen, obj->nElements());
            }
            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: size_t Phase::elementIndex(const string&)
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->elementIndex(name);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t thermo_speciesIndex(int32_t handle, const char* name)
    {
        // method: size_t Phase::speciesIndex(const string&)
        try {
            return ThermoPhaseCabinet::as<Phase>(handle)->speciesIndex(name);
        } catch (...) {
            return handleAllExceptions(ERR, 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)
    {
        // method: size_t Phase::addElement(const string&, double, int, double, int)
        try {
            return 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)
    {
        // getter: virtual void ThermoPhase::getChemPotentials(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            obj->getChemPotentials(mu);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getElectrochemPotentials(int32_t handle, int32_t muLen, double* mu)
    {
        // getter: void ThermoPhase::getElectrochemPotentials(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            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)
    {
        // getter: virtual void ThermoPhase::getPartialMolarEnthalpies(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            obj->getPartialMolarEnthalpies(hbar);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarEntropies(int32_t handle, int32_t sbarLen, double* sbar)
    {
        // getter: virtual void ThermoPhase::getPartialMolarEntropies(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            obj->getPartialMolarEntropies(sbar);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarIntEnergies(int32_t handle, int32_t ubarLen, double* ubar)
    {
        // getter: virtual void ThermoPhase::getPartialMolarIntEnergies(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            obj->getPartialMolarIntEnergies(ubar);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarCp(int32_t handle, int32_t cpbarLen, double* cpbar)
    {
        // getter: virtual void ThermoPhase::getPartialMolarCp(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            obj->getPartialMolarCp(cpbar);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getPartialMolarVolumes(int32_t handle, int32_t vbarLen, double* vbar)
    {
        // getter: virtual void ThermoPhase::getPartialMolarVolumes(double*)
        try {
            auto& obj = ThermoPhaseCabinet::at(handle);
            // no size checking specified
            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, const double*)
        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, const double*)
        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)
    {
        // getter: void SurfPhase::getCoverages(double*)
        try {
            auto obj = ThermoPhaseCabinet::as<SurfPhase>(handle);
            // no size checking specified
            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(const double*)
        try {
            auto obj = ThermoPhaseCabinet::as<SurfPhase>(handle);
            // no size checking specified
            obj->setCoverages(theta);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_getConcentrations(int32_t handle, int32_t cLen, double* c)
    {
        // getter: virtual void Phase::getConcentrations(double* const)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            // no size checking specified
            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(const double* const)
        try {
            auto obj = ThermoPhaseCabinet::as<Phase>(handle);
            // no size checking specified
            obj->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_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)
    {
        // no-op
        return 0;
    }
 
    int32_t thermo_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return ThermoPhaseCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t thermo_parentHandle(int32_t handle)
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return ThermoPhaseCabinet::parent(handle);
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"