ctmix.h

Go to the documentation of this file.

/**
 *  CTMIX - Generated CLib %Cantera interface library.
 *
 *  @file ctmix.h
 *
 *  Generated CLib API for %Cantera's MultiPhase 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 CTMIX_H
#define CTMIX_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
    /**
     *  @defgroup CAPIctmix ctmix Library
     *  Generated CLib API for %Cantera's MultiPhase class.
     *
     *  @warning  This library is an experimental part of the %Cantera API and
     *      may be changed or removed without notice.
     *
     *  @ingroup CAPIindex
     */
 
    /**
     *  @addtogroup CAPIctmix
     *  @{
     */
 
    /**
     *  Instantiate MultiPhase object using default constructor.
     *
     *  Wraps C++ constructor: `undefined`
     *
     *  @returns            Object handle if successful and -1 for exception handling.
     */
    int32_t mix_new();
 
    /**
     *  Add a phase to the mixture.
     *
     *  Wraps C++ method: `void MultiPhase::addPhase(shared_ptr<ThermoPhase>, double)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param p            Integer handle to ThermoPhase object. pointer to the phase object
     *  @param moles        total number of moles of all species in this phase
     */
    int32_t mix_addPhase(int32_t handle, int32_t p, double moles);
 
    /**
     *  Process phases and build atomic composition array.
     *
     *  Wraps C++ method: `void MultiPhase::init()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    int32_t mix_init(int32_t handle);
 
    /**
     *  Set the states of the phase objects to the locally-stored state within this MultiPhase object.
     *
     *  Wraps C++ method: `void MultiPhase::updatePhases()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    int32_t mix_updatePhases(int32_t handle);
 
    /**
     *  Number of elements.
     *
     *  Wraps C++ getter: `size_t MultiPhase::nElements()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    int32_t mix_nElements(int32_t handle);
 
    /**
     *  Returns the index of the element with name
     *
     *  Wraps C++ method: `size_t MultiPhase::elementIndex(const string&)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param name         String name of the global element
     */
    int32_t mix_elementIndex(int32_t handle, const char* name);
 
    /**
     *  Number of species, summed over all phases.
     *
     *  Wraps C++ getter: `size_t MultiPhase::nSpecies()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    int32_t mix_nSpecies(int32_t handle);
 
    /**
     *  Return the global index of the species belonging to phase number
     *
     *  Wraps C++ method: `size_t MultiPhase::speciesIndex(size_t, size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param k            local index of the species within the phase
     *  @param p            index of the phase
     */
    int32_t mix_speciesIndex(int32_t handle, int32_t k, int32_t p);
 
    /**
     *  Temperature [K].
     *
     *  Wraps C++ getter: `double MultiPhase::temperature()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_temperature(int32_t handle);
 
    /**
     *  Set the temperature [K].
     *
     *  Wraps C++ setter: `void MultiPhase::setTemperature(const double)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param T            value of the temperature (Kelvin)
     */
    int32_t mix_setTemperature(int32_t handle, const double T);
 
    /**
     *  Minimum temperature for which all solution phases have valid thermo data.
     *
     *  Wraps C++ getter: `double MultiPhase::minTemp()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_minTemp(int32_t handle);
 
    /**
     *  Maximum temperature for which all solution phases have valid thermo data.
     *
     *  Wraps C++ getter: `double MultiPhase::maxTemp()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_maxTemp(int32_t handle);
 
    /**
     *  Total charge summed over all phases (Coulombs).
     *
     *  Wraps C++ getter: `double MultiPhase::charge()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_charge(int32_t handle);
 
    /**
     *  Charge (Coulombs) of phase with index
     *
     *  Wraps C++ method: `double MultiPhase::phaseCharge(size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param p            index of the phase for which the charge is desired.
     */
    double mix_phaseCharge(int32_t handle, int32_t p);
 
    /**
     *  Pressure [Pa].
     *
     *  Wraps C++ getter: `double MultiPhase::pressure()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_pressure(int32_t handle);
 
    /**
     *  Set the pressure [Pa].
     *
     *  Wraps C++ setter: `void MultiPhase::setPressure(double)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param P            Set the pressure in the MultiPhase object (Pa)
     */
    int32_t mix_setPressure(int32_t handle, double P);
 
    /**
     *  Returns the Number of atoms of global element
     *
     *  Wraps C++ method: `double MultiPhase::nAtoms(const size_t, const size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param kGlob        global species index
     *  @param mGlob        global element index
     */
    double mix_nAtoms(int32_t handle, const int32_t kGlob, const int32_t mGlob);
 
    /**
     *  Number of phases.
     *
     *  Wraps C++ getter: `size_t MultiPhase::nPhases()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    int32_t mix_nPhases(int32_t handle);
 
    /**
     *  Return the number of moles in phase n.
     *
     *  Wraps C++ method: `double MultiPhase::phaseMoles(const size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param n            Index of the phase.
     */
    double mix_phaseMoles(int32_t handle, const int32_t n);
 
    /**
     *  Set the number of moles of phase with index n.
     *
     *  Wraps C++ method: `void MultiPhase::setPhaseMoles(const size_t, const double)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param n            Index of the phase
     *  @param moles        Number of moles in the phase (kmol)
     */
    int32_t mix_setPhaseMoles(int32_t handle, const int32_t n, const double moles);
 
    /**
     *  Sets all of the global species mole numbers.
     *
     *  Wraps C++ setter: `void MultiPhase::setMoles(const double*)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param[in] nLen     Length of array reserved for n.
     *  @param n            Vector of doubles of length nSpecies() containing the global mole numbers (kmol).
     */
    int32_t mix_setMoles(int32_t handle, int32_t nLen, const double* n);
 
    /**
     *  Set the moles via a string containing their names.
     *
     *  Wraps C++ setter: `void MultiPhase::setMolesByName(const string&)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param x            string x in the form of a composition map where values are the moles of the species.
     */
    int32_t mix_setMolesByName(int32_t handle, const char* x);
 
    /**
     *  Returns the moles of global species
     *
     *  Wraps C++ method: `double MultiPhase::speciesMoles(size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param kGlob        Global species index k
     */
    double mix_speciesMoles(int32_t handle, int32_t kGlob);
 
    /**
     *  Total moles of global element
     *
     *  Wraps C++ method: `double MultiPhase::elementMoles(size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param m            Index of the global element
     */
    double mix_elementMoles(int32_t handle, int32_t m);
 
    /**
     *  Equilibrate a ThermoPhase object.
     *
     *  Wraps C++ method: `void MultiPhase::equilibrate(const string&, const string&, double, int, int, int)`
     *
     *  @param handle       Handle to queried MultiPhase 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 mix_equilibrate(int32_t handle, const char* XY, const char* solver, double rtol, int32_t max_steps, int32_t max_iter, int32_t estimate_equil);
 
    /**
     *  Returns a vector of Chemical potentials.
     *
     *  Wraps C++ getter: `void MultiPhase::getChemPotentials(double*)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param[in] muLen    Length of array reserved for mu.
     *  @param mu           Chemical potential vector. Length = num global species. Units = J/kmol.
     */
    int32_t mix_getChemPotentials(int32_t handle, int32_t muLen, double* mu);
 
    /**
     *  The enthalpy of the mixture [J].
     *
     *  Wraps C++ getter: `double MultiPhase::enthalpy()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_enthalpy(int32_t handle);
 
    /**
     *  The entropy of the mixture [J/K].
     *
     *  Wraps C++ getter: `double MultiPhase::entropy()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_entropy(int32_t handle);
 
    /**
     *  The Gibbs function of the mixture [J].
     *
     *  Wraps C++ getter: `double MultiPhase::gibbs()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_gibbs(int32_t handle);
 
    /**
     *  Heat capacity at constant pressure [J/K].
     *
     *  Wraps C++ getter: `double MultiPhase::cp()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_cp(int32_t handle);
 
    /**
     *  The total mixture volume [m^3].
     *
     *  Wraps C++ getter: `double MultiPhase::volume()`
     *
     *  @param handle       Handle to queried MultiPhase object.
     */
    double mix_volume(int32_t handle);
 
    /**
     *  Returns the phase index of the Kth "global" species.
     *
     *  Wraps C++ method: `size_t MultiPhase::speciesPhaseIndex(const size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param kGlob        Global species index.
     */
    int32_t mix_speciesPhaseIndex(int32_t handle, const int32_t kGlob);
 
    /**
     *  Returns the mole fraction of global species k.
     *
     *  Wraps C++ method: `double MultiPhase::moleFraction(const size_t)`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @param kGlob        Index of the global species.
     */
    double mix_moleFraction(int32_t handle, const int32_t kGlob);
 
    /**
     *  Delete MultiPhase object.
     *
     *  Wraps C++ destructor: `undefined`
     *
     *  @param handle       Handle to MultiPhase object.
     *  @returns            Zero for success and -1 for exception handling.
     */
    int32_t mix_del(int32_t handle);
 
    /**
     *  Return size of MultiPhase storage.
     *
     *  Wraps C++ reserved CLib function: `custom code`
     *
     *  @returns            Size or -1 for exception handling.
     */
    int32_t mix_cabinetSize();
 
    /**
     *  Return handle to parent of MultiPhase object.
     *
     *  Wraps C++ reserved CLib function: `custom code`
     *
     *  @param handle       Handle to queried MultiPhase object.
     *  @returns            Parent handle or -1 for exception handling.
     */
    int32_t mix_parentHandle(int32_t handle);
 
    /**
     *  @}
     */
 
#ifdef __cplusplus
}
#endif
 
#endif // CTMIX_H