ctthermo.h

Go to the documentation of this file.

/**
 *  CTTHERMO - Generated CLib %Cantera interface library.
 *
 *  @file ctthermo.h
 *
 *  Generated CLib API for %Cantera's ThermoPhase class.
 *
 *  This library of functions is designed to encapsulate %Cantera functionality
 *  and make it available for use in languages and applications other than C++.
 *  A set of library functions is provided that are declared "extern C". All
 *  %Cantera objects are stored and referenced by integers - no pointers are
 *  passed to or from the calling application.
 *
 *  This file was generated by sourcegen. It will be re-generated by the
 *  %Cantera build process. Do not manually edit.
 *
 *  @warning  This library 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.
 
#ifndef CTTHERMO_H
#define CTTHERMO_H
 
#include <stdint.h>  // for 32-bit int32_t / 64-bit int64_t
 
#ifdef __cplusplus
extern "C" {
#endif
 
    /**
     *  @defgroup CAPIctthermo ctthermo Library
     *  Generated CLib API for %Cantera's ThermoPhase class.
     *
     *  @warning  This library is an experimental part of the %Cantera API and
     *      may be changed or removed without notice.
     *
     *  @ingroup CAPIindex
     */
 
    /**
     *  @addtogroup CAPIctthermo
     *  @{
     */
 
    /**
     *  Return the name of the phase.
     *
     *  Wraps C++ getter: `string Phase::name()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] bufLen   Length of reserved array.
     *  @param[out] buf     Returned string value.
     *  @returns            Actual length of string including string-terminating null byte, \0, or -1 for exception handling.
     */
    int32_t thermo_name(int32_t handle, int32_t bufLen, char* buf);
 
    /**
     *  Sets the string name for the phase.
     *
     *  Wraps C++ setter: `void Phase::setName(const string&)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param nm           String name of the phase
     */
    int32_t thermo_setName(int32_t handle, const char* nm);
 
    /**
     *  String indicating the thermodynamic model implemented.
     *
     *  Wraps C++ getter: `string ThermoPhase::type()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] bufLen   Length of reserved array.
     *  @param[out] buf     Returned string value.
     *  @returns            Actual length of string including string-terminating null byte, \0, or -1 for exception handling.
     */
    int32_t thermo_type(int32_t handle, int32_t bufLen, char* buf);
 
    /**
     *  Number of elements.
     *
     *  Wraps C++ getter: `size_t Phase::nElements()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    int32_t thermo_nElements(int32_t handle);
 
    /**
     *  Returns the number of species in the phase.
     *
     *  Wraps C++ getter: `size_t Phase::nSpecies()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    int32_t thermo_nSpecies(int32_t handle);
 
    /**
     *  Temperature (K).
     *
     *  Wraps C++ getter: `double Phase::temperature()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    double thermo_temperature(int32_t handle);
 
    /**
     *  Set the internally stored temperature of the phase (K).
     *
     *  Wraps C++ setter: `virtual void Phase::setTemperature(double)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param temp         Temperature in Kelvin
     */
    int32_t thermo_setTemperature(int32_t handle, double temp);
 
    /**
     *  Return the thermodynamic pressure (Pa).
     *
     *  Wraps C++ getter: `virtual double Phase::pressure()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    double thermo_pressure(int32_t handle);
 
    /**
     *  Set the internally stored pressure (Pa) at constant temperature and composition.
     *
     *  Wraps C++ setter: `virtual void Phase::setPressure(double)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param p            input Pressure (Pa)
     */
    int32_t thermo_setPressure(int32_t handle, double p);
 
    /**
     *  Density (kg/m^3).
     *
     *  Wraps C++ getter: `virtual double Phase::density()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    double thermo_density(int32_t handle);
 
    /**
     *  Set the internally stored density (kg/m^3) of the phase.
     *
     *  Wraps C++ setter: `virtual void Phase::setDensity(const double)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] density_ density (kg/m^3).
     */
    int32_t thermo_setDensity(int32_t handle, const double density_);
 
    /**
     *  Molar density (kmol/m^3).
     *
     *  Wraps C++ getter: `virtual double Phase::molarDensity()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    double thermo_molarDensity(int32_t handle);
 
    /**
     *  The mean molecular weight. Units: (kg/kmol)
     *
     *  Wraps C++ getter: `double Phase::meanMolecularWeight()`
     *
     *  @param handle       Handle to queried Phase object.
     */
    double thermo_meanMolecularWeight(int32_t handle);
 
    /**
     *  Return the mole fraction of a single species.
     *
     *  Wraps C++ method: `double Phase::moleFraction(size_t)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param k            species index
     */
    double thermo_moleFraction(int32_t handle, int32_t k);
 
    /**
     *  Return the mass fraction of a single species.
     *
     *  Wraps C++ method: `double Phase::massFraction(size_t)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param k            species index
     */
    double thermo_massFraction(int32_t handle, int32_t k);
 
    /**
     *  Get the species mole fraction vector.
     *
     *  Wraps C++ getter: `void Phase::getMoleFractions(double* const)`
     *
     *  Uses:
     *  - `size_t Phase::nSpecies()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] xLen     Length of array reserved for x.
     *  @param x            On return, x contains the mole fractions. Must have a length greater than or equal to the number of species.
     */
    int32_t thermo_getMoleFractions(int32_t handle, int32_t xLen, double* x);
 
    /**
     *  Get the species mass fractions.
     *
     *  Wraps C++ getter: `void Phase::getMassFractions(double* const)`
     *
     *  Uses:
     *  - `size_t Phase::nSpecies()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] yLen     Length of array reserved for y.
     *  @param[out] y       Array of mass fractions, length nSpecies()
     */
    int32_t thermo_getMassFractions(int32_t handle, int32_t yLen, double* y);
 
    /**
     *  Set the mole fractions to the specified values.
     *
     *  Wraps C++ setter: `virtual void Phase::setMoleFractions(const double* const)`
     *
     *  Uses:
     *  - `size_t Phase::nSpecies()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] xLen     Length of array reserved for x.
     *  @param x            Array of unnormalized mole fraction values (input). Must have a length greater than or equal to the number of species, m_kk.
     */
    int32_t thermo_setMoleFractions(int32_t handle, int32_t xLen, const double* x);
 
    /**
     *  Set the mass fractions to the specified values and normalize them.
     *
     *  Wraps C++ setter: `virtual void Phase::setMassFractions(const double* const)`
     *
     *  Uses:
     *  - `size_t Phase::nSpecies()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] yLen     Length of array reserved for y.
     *  @param[in] y        Array of unnormalized mass fraction values. Length must be greater than or equal to the number of species. The Phase object will normalize this vector before storing its contents.
     */
    int32_t thermo_setMassFractions(int32_t handle, int32_t yLen, const double* y);
 
    /**
     *  Set the mole fractions of a group of species by name.
     *
     *  Wraps C++ setter: `void Phase::setMoleFractionsByName(const string&)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param x            string x in the form of a composition map
     */
    int32_t thermo_setMoleFractionsByName(int32_t handle, const char* x);
 
    /**
     *  Set the species mass fractions by name.
     *
     *  Wraps C++ setter: `void Phase::setMassFractionsByName(const string&)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param x            String containing a composition map
     */
    int32_t thermo_setMassFractionsByName(int32_t handle, const char* x);
 
    /**
     *  Return a read-only reference to the vector of atomic weights.
     *
     *  Wraps C++ getter: `const vector<double>& Phase::atomicWeights()`
     *
     *  Uses:
     *  - `size_t Phase::nElements()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] bufLen   Length of reserved array.
     *  @param[out] buf     Returned array value.
     *  @returns            Actual length of value array or -1 for exception handling.
     */
    int32_t thermo_atomicWeights(int32_t handle, int32_t bufLen, double* buf);
 
    /**
     *  Copy the vector of molecular weights into array weights.
     *
     *  Wraps C++ getter: `void Phase::getMolecularWeights(double*)`
     *
     *  Uses:
     *  - `size_t Phase::nSpecies()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] weightsLen Length of array reserved for weights.
     *  @param weights      Output array of molecular weights (kg/kmol)
     */
    int32_t thermo_getMolecularWeights(int32_t handle, int32_t weightsLen, double* weights);
 
    /**
     *  Copy the vector of species charges into array charges.
     *
     *  Wraps C++ getter: `void Phase::getCharges(double*)`
     *
     *  Uses:
     *  - `size_t Phase::nElements()`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] chargesLen Length of array reserved for charges.
     *  @param charges      Output array of species charges (elem. charge)
     */
    int32_t thermo_getCharges(int32_t handle, int32_t chargesLen, double* charges);
 
    /**
     *  Name of the element with index m.
     *
     *  Wraps C++ method: `string Phase::elementName(size_t)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param m            Element index.
     *  @param[in] bufLen   Length of reserved array.
     *  @param[out] buf     Returned string value.
     *  @returns            Actual length of string including string-terminating null byte, \0, or -1 for exception handling.
     */
    int32_t thermo_elementName(int32_t handle, int32_t m, int32_t bufLen, char* buf);
 
    /**
     *  Name of the species with index k.
     *
     *  Wraps C++ method: `string Phase::speciesName(size_t)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param k            index of the species
     *  @param[in] bufLen   Length of reserved array.
     *  @param[out] buf     Returned string value.
     *  @returns            Actual length of string including string-terminating null byte, \0, or -1 for exception handling.
     */
    int32_t thermo_speciesName(int32_t handle, int32_t k, int32_t bufLen, char* buf);
 
    /**
     *  Return the index of element named 'name'.
     *
     *  Wraps C++ method: `custom code`
     *
     *  Uses:
     *  - ` elementIndex(const string&, bool)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param name         Name of the element
     */
    int32_t thermo_elementIndex(int32_t handle, const char* name);
 
    /**
     *  Returns the index of a species named 'name' within the Phase object.
     *
     *  Wraps C++ method: `custom code`
     *
     *  Uses:
     *  - ` speciesIndex(const string&, bool)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param name         String name of the species. It may also be in the form phaseName:speciesName
     */
    int32_t thermo_speciesIndex(int32_t handle, const char* name);
 
    /**
     *  Number of atoms of element `m` in species `k`.
     *
     *  Wraps C++ method: `double Phase::nAtoms(size_t, size_t)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param k            species index
     *  @param m            element index
     */
    double thermo_nAtoms(int32_t handle, int32_t k, int32_t m);
 
    /**
     *  Add an element.
     *
     *  Wraps C++ method: `size_t Phase::addElement(const string&, double, int, double, int)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param symbol       Atomic symbol string.
     *  @param weight       Atomic mass in amu.
     *  @param atomicNumber Atomic number of the element (unitless)
     *  @param entropy298   Entropy of the element at 298 K and 1 bar in its most stable form. The default is the value ENTROPY298_UNKNOWN, which is interpreted as an unknown, and if used will cause Cantera to throw an error.
     *  @param elem_type    Specifies the type of the element constraint equation. This defaults to CT_ELEM_TYPE_ABSPOS, that is, an element.
     */
    int32_t thermo_addElement(int32_t handle, const char* symbol, double weight, int32_t atomicNumber, double entropy298, int32_t elem_type);
 
    /**
     *  Returns the reference pressure in Pa.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::refPressure()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_refPressure(int32_t handle);
 
    /**
     *  Minimum temperature for which the thermodynamic data for the species or phase are valid.
     *
     *  Wraps C++ method: `virtual double ThermoPhase::minTemp(size_t)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param k            index of the species. Default is -1, which will return the max of the min value over all species.
     */
    double thermo_minTemp(int32_t handle, int32_t k);
 
    /**
     *  Maximum temperature for which the thermodynamic data for the species are valid.
     *
     *  Wraps C++ method: `virtual double ThermoPhase::maxTemp(size_t)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param k            index of the species. Default is -1, which will return the min of the max value over all species.
     */
    double thermo_maxTemp(int32_t handle, int32_t k);
 
    /**
     *  Molar enthalpy. Units: J/kmol.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::enthalpy_mole()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_enthalpy_mole(int32_t handle);
 
    /**
     *  Specific enthalpy. Units: J/kg.
     *
     *  Wraps C++ getter: `double ThermoPhase::enthalpy_mass()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_enthalpy_mass(int32_t handle);
 
    /**
     *  Molar entropy. Units: J/kmol/K.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::entropy_mole()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_entropy_mole(int32_t handle);
 
    /**
     *  Specific entropy. Units: J/kg/K.
     *
     *  Wraps C++ getter: `double ThermoPhase::entropy_mass()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_entropy_mass(int32_t handle);
 
    /**
     *  Molar internal energy. Units: J/kmol.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::intEnergy_mole()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_intEnergy_mole(int32_t handle);
 
    /**
     *  Specific internal energy. Units: J/kg.
     *
     *  Wraps C++ getter: `double ThermoPhase::intEnergy_mass()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_intEnergy_mass(int32_t handle);
 
    /**
     *  Molar Gibbs function. Units: J/kmol.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::gibbs_mole()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_gibbs_mole(int32_t handle);
 
    /**
     *  Specific Gibbs function. Units: J/kg.
     *
     *  Wraps C++ getter: `double ThermoPhase::gibbs_mass()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_gibbs_mass(int32_t handle);
 
    /**
     *  Molar heat capacity at constant pressure. Units: J/kmol/K.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::cp_mole()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_cp_mole(int32_t handle);
 
    /**
     *  Specific heat at constant pressure. Units: J/kg/K.
     *
     *  Wraps C++ getter: `double ThermoPhase::cp_mass()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_cp_mass(int32_t handle);
 
    /**
     *  Molar heat capacity at constant volume. Units: J/kmol/K.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::cv_mole()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_cv_mole(int32_t handle);
 
    /**
     *  Specific heat at constant volume. Units: J/kg/K.
     *
     *  Wraps C++ getter: `double ThermoPhase::cv_mass()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_cv_mass(int32_t handle);
 
    /**
     *  Get the species chemical potentials. Units: J/kmol.
     *
     *  Wraps C++ getter: `virtual void ThermoPhase::getChemPotentials(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] muLen    Length of array reserved for mu.
     *  @param mu           Output vector of species chemical potentials. Length: m_kk. Units: J/kmol
     */
    int32_t thermo_getChemPotentials(int32_t handle, int32_t muLen, double* mu);
 
    /**
     *  Get the species electrochemical potentials.
     *
     *  Wraps C++ getter: `void ThermoPhase::getElectrochemPotentials(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] muLen    Length of array reserved for mu.
     *  @param mu           Output vector of species electrochemical potentials. Length: m_kk. Units: J/kmol
     */
    int32_t thermo_getElectrochemPotentials(int32_t handle, int32_t muLen, double* mu);
 
    /**
     *  Returns the electric potential of this phase (V).
     *
     *  Wraps C++ getter: `double ThermoPhase::electricPotential()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_electricPotential(int32_t handle);
 
    /**
     *  Set the electric potential of this phase (V).
     *
     *  Wraps C++ setter: `void ThermoPhase::setElectricPotential(double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param v            Input value of the electric potential in Volts
     */
    int32_t thermo_setElectricPotential(int32_t handle, double v);
 
    /**
     *  Return the volumetric thermal expansion coefficient. Units: 1/K.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::thermalExpansionCoeff()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_thermalExpansionCoeff(int32_t handle);
 
    /**
     *  Returns the isothermal compressibility. Units: 1/Pa.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::isothermalCompressibility()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_isothermalCompressibility(int32_t handle);
 
    /**
     *  Returns an array of partial molar enthalpies for the species in the mixture.
     *
     *  Wraps C++ getter: `virtual void ThermoPhase::getPartialMolarEnthalpies(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] hbarLen  Length of array reserved for hbar.
     *  @param hbar         Output vector of species partial molar enthalpies. Length: m_kk. units are J/kmol.
     */
    int32_t thermo_getPartialMolarEnthalpies(int32_t handle, int32_t hbarLen, double* hbar);
 
    /**
     *  Returns an array of partial molar entropies of the species in the solution.
     *
     *  Wraps C++ getter: `virtual void ThermoPhase::getPartialMolarEntropies(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] sbarLen  Length of array reserved for sbar.
     *  @param sbar         Output vector of species partial molar entropies. Length = m_kk. units are J/kmol/K.
     */
    int32_t thermo_getPartialMolarEntropies(int32_t handle, int32_t sbarLen, double* sbar);
 
    /**
     *  Return an array of partial molar internal energies for the species in the mixture.
     *
     *  Wraps C++ getter: `virtual void ThermoPhase::getPartialMolarIntEnergies(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] ubarLen  Length of array reserved for ubar.
     *  @param ubar         Output vector of species partial molar internal energies. Length = m_kk. units are J/kmol.
     */
    int32_t thermo_getPartialMolarIntEnergies(int32_t handle, int32_t ubarLen, double* ubar);
 
    /**
     *  Return an array of partial molar heat capacities for the species in the mixture.
     *
     *  Wraps C++ getter: `virtual void ThermoPhase::getPartialMolarCp(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] cpbarLen Length of array reserved for cpbar.
     *  @param cpbar        Output vector of species partial molar heat capacities at constant pressure. Length = m_kk. units are J/kmol/K.
     */
    int32_t thermo_getPartialMolarCp(int32_t handle, int32_t cpbarLen, double* cpbar);
 
    /**
     *  Return an array of partial molar volumes for the species in the mixture.
     *
     *  Wraps C++ getter: `virtual void ThermoPhase::getPartialMolarVolumes(double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param[in] vbarLen  Length of array reserved for vbar.
     *  @param vbar         Output vector of species partial molar volumes. Length = m_kk. units are m^3/kmol.
     */
    int32_t thermo_getPartialMolarVolumes(int32_t handle, int32_t vbarLen, double* vbar);
 
    /**
     *  Set the temperature (K), pressure (Pa), and mole fractions.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TPX(double, double, const double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (K)
     *  @param p            Pressure (Pa)
     *  @param[in] xLen     Length of array reserved for x.
     *  @param x            Vector of mole fractions. Length is equal to m_kk.
     */
    int32_t thermo_setState_TPX(int32_t handle, double t, double p, int32_t xLen, const double* x);
 
    /**
     *  Set the temperature (K), pressure (Pa), and mole fractions.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TPX(double, double, const string&)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (K)
     *  @param p            Pressure (Pa)
     *  @param x            String containing a composition map of the mole fractions. Species not in the composition map are assumed to have zero mole fraction
     */
    int32_t thermo_setState_TPX_byName(int32_t handle, double t, double p, const char* x);
 
    /**
     *  Set the internally stored temperature (K), pressure (Pa), and mass fractions of the phase.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TPY(double, double, const double*)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (K)
     *  @param p            Pressure (Pa)
     *  @param[in] yLen     Length of array reserved for y.
     *  @param y            Vector of mass fractions. Length is equal to m_kk.
     */
    int32_t thermo_setState_TPY(int32_t handle, double t, double p, int32_t yLen, const double* y);
 
    /**
     *  Set the internally stored temperature (K), pressure (Pa), and mass fractions of the phase.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TPY(double, double, const string&)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (K)
     *  @param p            Pressure (Pa)
     *  @param y            String containing a composition map of the mass fractions. Species not in the composition map are assumed to have zero mass fraction
     */
    int32_t thermo_setState_TPY_byName(int32_t handle, double t, double p, const char* y);
 
    /**
     *  Set the temperature (K) and pressure (Pa)
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TP(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (K)
     *  @param p            Pressure (Pa)
     */
    int32_t thermo_setState_TP(int32_t handle, double t, double p);
 
    /**
     *  Set the internally stored temperature (K) and density (kg/m^3)
     *
     *  Wraps C++ method: `void Phase::setState_TD(double, double)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param t            Temperature in kelvin
     *  @param rho          Density (kg/m^3)
     */
    int32_t thermo_setState_TD(int32_t handle, double t, double rho);
 
    /**
     *  Set the density (kg/m**3) and pressure (Pa) at constant composition.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_DP(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param rho          Density (kg/m^3)
     *  @param p            Pressure (Pa)
     */
    int32_t thermo_setState_DP(int32_t handle, double rho, double p);
 
    /**
     *  Set the internally stored specific enthalpy (J/kg) and pressure (Pa) of the phase.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_HP(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param h            Specific enthalpy (J/kg)
     *  @param p            Pressure (Pa)
     */
    int32_t thermo_setState_HP(int32_t handle, double h, double p);
 
    /**
     *  Set the specific internal energy (J/kg) and specific volume (m^3/kg).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_UV(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param u            specific internal energy (J/kg)
     *  @param v            specific volume (m^3/kg).
     */
    int32_t thermo_setState_UV(int32_t handle, double u, double v);
 
    /**
     *  Set the specific entropy (J/kg/K) and specific volume (m^3/kg).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_SV(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param s            specific entropy (J/kg/K)
     *  @param v            specific volume (m^3/kg).
     */
    int32_t thermo_setState_SV(int32_t handle, double s, double v);
 
    /**
     *  Set the specific entropy (J/kg/K) and pressure (Pa).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_SP(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param s            specific entropy (J/kg/K)
     *  @param p            specific pressure (Pa).
     */
    int32_t thermo_setState_SP(int32_t handle, double s, double p);
 
    /**
     *  Set the specific entropy (J/kg/K) and temperature (K).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_ST(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param s            specific entropy (J/kg/K)
     *  @param t            temperature (K)
     */
    int32_t thermo_setState_ST(int32_t handle, double s, double t);
 
    /**
     *  Set the temperature (K) and specific volume (m^3/kg).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TV(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            temperature (K)
     *  @param v            specific volume (m^3/kg)
     */
    int32_t thermo_setState_TV(int32_t handle, double t, double v);
 
    /**
     *  Set the pressure (Pa) and specific volume (m^3/kg).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_PV(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param p            pressure (Pa)
     *  @param v            specific volume (m^3/kg)
     */
    int32_t thermo_setState_PV(int32_t handle, double p, double v);
 
    /**
     *  Set the specific internal energy (J/kg) and pressure (Pa).
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_UP(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param u            specific internal energy (J/kg)
     *  @param p            pressure (Pa)
     */
    int32_t thermo_setState_UP(int32_t handle, double u, double p);
 
    /**
     *  Set the specific volume (m^3/kg) and the specific enthalpy (J/kg)
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_VH(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param v            specific volume (m^3/kg)
     *  @param h            specific enthalpy (J/kg)
     */
    int32_t thermo_setState_VH(int32_t handle, double v, double h);
 
    /**
     *  Set the temperature (K) and the specific enthalpy (J/kg)
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_TH(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            temperature (K)
     *  @param h            specific enthalpy (J/kg)
     */
    int32_t thermo_setState_TH(int32_t handle, double t, double h);
 
    /**
     *  Set the specific entropy (J/kg/K) and the specific enthalpy (J/kg)
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_SH(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param s            specific entropy (J/kg/K)
     *  @param h            specific enthalpy (J/kg)
     */
    int32_t thermo_setState_SH(int32_t handle, double s, double h);
 
    /**
     *  Equilibrate a ThermoPhase object.
     *
     *  Wraps C++ method: `void ThermoPhase::equilibrate(const string&, const string&, double, int, int, int)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param XY           String representation of what two properties are being held constant
     *  @param solver       Name of the solver to be used to equilibrate the phase. If solver = 'element_potential', the ChemEquil element potential solver will be used. If solver = 'vcs', the VCS solver will be used. If solver = 'gibbs', the MultiPhaseEquil solver will be used. If solver = 'auto', the solvers will be tried in order if the initial solver(s) fail.
     *  @param rtol         Relative tolerance
     *  @param max_steps    Maximum number of steps to take to find the solution
     *  @param max_iter     For the 'gibbs' and 'vcs' solvers, this is the maximum number of outer temperature or pressure iterations to take when T and/or P is not held fixed.
     *  @param estimate_equil For MultiPhaseEquil solver, an integer indicating whether the solver should estimate its own initial condition. If 0, the initial mole fraction vector in the ThermoPhase object is used as the initial condition. If 1, the initial mole fraction vector is used if the element abundances are satisfied. If -1, the initial mole fraction vector is thrown out, and an estimate is formulated.
     */
    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);
 
    /**
     *  Critical temperature (K).
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::critTemperature()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_critTemperature(int32_t handle);
 
    /**
     *  Critical pressure (Pa).
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::critPressure()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_critPressure(int32_t handle);
 
    /**
     *  Critical density (kg/m3).
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::critDensity()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_critDensity(int32_t handle);
 
    /**
     *  Return the fraction of vapor at the current conditions.
     *
     *  Wraps C++ getter: `virtual double ThermoPhase::vaporFraction()`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     */
    double thermo_vaporFraction(int32_t handle);
 
    /**
     *  Return the saturation temperature given the pressure.
     *
     *  Wraps C++ method: `virtual double ThermoPhase::satTemperature(double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param p            Pressure (Pa)
     */
    double thermo_satTemperature(int32_t handle, double p);
 
    /**
     *  Return the saturation pressure given the temperature.
     *
     *  Wraps C++ method: `virtual double ThermoPhase::satPressure(double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (Kelvin)
     */
    double thermo_satPressure(int32_t handle, double t);
 
    /**
     *  Set the state to a saturated system at a particular pressure.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_Psat(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param p            Pressure (Pa)
     *  @param x            Fraction of vapor
     */
    int32_t thermo_setState_Psat(int32_t handle, double p, double x);
 
    /**
     *  Set the state to a saturated system at a particular temperature.
     *
     *  Wraps C++ method: `virtual void ThermoPhase::setState_Tsat(double, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param t            Temperature (kelvin)
     *  @param x            Fraction of vapor
     */
    int32_t thermo_setState_Tsat(int32_t handle, double t, double x);
 
    /**
     *  Return a vector of surface coverages.
     *
     *  Wraps C++ getter: `void SurfPhase::getCoverages(double*)`
     *
     *  @param handle       Handle to queried SurfPhase object.
     *  @param[in] thetaLen Length of array reserved for theta.
     *  @param theta        Array theta must be at least as long as the number of species.
     */
    int32_t surf_getCoverages(int32_t handle, int32_t thetaLen, double* theta);
 
    /**
     *  Set the surface site fractions to a specified state.
     *
     *  Wraps C++ setter: `void SurfPhase::setCoverages(const double*)`
     *
     *  @param handle       Handle to queried SurfPhase object.
     *  @param[in] thetaLen Length of array reserved for theta.
     *  @param theta        This is the surface site fraction for the kth species in the surface phase. This is a dimensionless quantity.
     */
    int32_t surf_setCoverages(int32_t handle, int32_t thetaLen, const double* theta);
 
    /**
     *  Get the species concentrations (kmol/m^3).
     *
     *  Wraps C++ getter: `virtual void Phase::getConcentrations(double* const)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] cLen     Length of array reserved for c.
     *  @param[out] c       The vector of species concentrations. Units are kmol/m^3. The length of the vector must be greater than or equal to the number of species within the phase.
     */
    int32_t thermo_getConcentrations(int32_t handle, int32_t cLen, double* c);
 
    /**
     *  Set the concentrations to the specified values within the phase.
     *
     *  Wraps C++ setter: `virtual void Phase::setConcentrations(const double* const)`
     *
     *  @param handle       Handle to queried Phase object.
     *  @param[in] concLen  Length of array reserved for conc.
     *  @param[in] conc     Array of concentrations in dimensional units. For bulk phases c[k] is the concentration of the kth species in kmol/m3. For surface phases, c[k] is the concentration in kmol/m2. The length of the vector is the number of species in the phase.
     */
    int32_t thermo_setConcentrations(int32_t handle, int32_t concLen, const double* conc);
 
    /**
     *  Returns the site density.
     *
     *  Wraps C++ getter: `double SurfPhase::siteDensity()`
     *
     *  @param handle       Handle to queried SurfPhase object.
     */
    double surf_siteDensity(int32_t handle);
 
    /**
     *  Set the site density of the surface phase (kmol m-2)
     *
     *  Wraps C++ setter: `void SurfPhase::setSiteDensity(double)`
     *
     *  @param handle       Handle to queried SurfPhase object.
     *  @param n0           Site density of the surface phase (kmol m-2)
     */
    int32_t surf_setSiteDensity(int32_t handle, double n0);
 
    /**
     *  Set the coverages from a string of colon-separated name:value pairs.
     *
     *  Wraps C++ setter: `void SurfPhase::setCoveragesByName(const string&)`
     *
     *  @param handle       Handle to queried SurfPhase object.
     *  @param cov          String containing colon-separated name:value pairs
     */
    int32_t surf_setCoveragesByName(int32_t handle, const char* cov);
 
    /**
     *  Set the mixture composition according to the equivalence ratio.
     *
     *  Wraps C++ method: `void ThermoPhase::setEquivalenceRatio(double, const string&, const string&)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param phi          equivalence ratio
     *  @param fuelComp     composition of the fuel
     *  @param oxComp       composition of the oxidizer
     */
    int32_t thermo_setEquivalenceRatio(int32_t handle, double phi, const char* fuelComp, const char* oxComp);
 
    /**
     *  returns a summary of the state of the phase as a string
     *
     *  Wraps C++ method: `virtual string ThermoPhase::report(bool, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param show_thermo  If true, extra information is printed out about the thermodynamic state of the system.
     *  @param threshold    Show information about species with mole fractions greater than *threshold*.
     *  @param[in] bufLen   Length of reserved array.
     *  @param[out] buf     Returned string value.
     *  @returns            Actual length of string including string-terminating null byte, \0, or -1 for exception handling.
     */
    int32_t thermo_report(int32_t handle, int32_t show_thermo, double threshold, int32_t bufLen, char* buf);
 
    /**
     *  Print a summary of the state of the phase to the logger.
     *
     *  Wraps C++ method: `custom code`
     *
     *  Uses:
     *  - `virtual string ThermoPhase::report(bool, double)`
     *
     *  @param handle       Handle to queried ThermoPhase object.
     *  @param showThermo   If true, extra information is printed out about the thermodynamic state of the system.
     *  @param threshold    Show information about species with mole fractions greater than
     *  @returns            Zero for success or -1 for exception handling.
     */
    int32_t thermo_print(int32_t handle, int32_t showThermo, double threshold);
 
    /**
     *  Delete ThermoPhase object.
     *
     *  Wraps C++ destructor: `undefined`
     *
     *  @param handle       Handle to ThermoPhase object.
     *  @returns            Zero for success and -1 for exception handling.
     */
    int32_t thermo_del(int32_t handle);
 
    /**
     *  Return size of ThermoPhase storage.
     *
     *  Wraps C++ reserved CLib function: `custom code`
     *
     *  @returns            Size or -1 for exception handling.
     */
    int32_t thermo_cabinetSize();
 
    /**
     *  @}
     */
 
#ifdef __cplusplus
}
#endif
 
#endif // CTTHERMO_H