ctkin.h

Go to the documentation of this file.

/**
 *  CTKIN - Generated CLib %Cantera interface library.
 *
 *  @file ctkin.h
 *
 *  Generated CLib API for %Cantera's Kinetics 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 CTKIN_H
#define CTKIN_H
 
#include <stdint.h>  // for 32-bit int32_t / 64-bit int64_t
 
#ifdef __cplusplus
extern "C" {
#endif
 
    /**
     *  @defgroup CAPIctkin ctkin Library
     *  Generated CLib API for %Cantera's Kinetics class.
     *
     *  @warning  This library is an experimental part of the %Cantera API and
     *      may be changed or removed without notice.
     *
     *  @ingroup CAPIindex
     */
 
    /**
     *  @addtogroup CAPIctkin
     *  @{
     */
 
    /**
     *  Identifies the Kinetics manager type.
     *
     *  Wraps C++ getter: `virtual string Kinetics::kineticsType()`
     *
     *  @param handle       Handle to queried Kinetics 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 kin_kineticsType(int32_t handle, int32_t bufLen, char* buf);
 
    /**
     *  Number of reactions in the reaction mechanism.
     *
     *  Wraps C++ getter: `size_t Kinetics::nReactions()`
     *
     *  @param handle       Handle to queried Kinetics object.
     */
    int32_t kin_nReactions(int32_t handle);
 
    /**
     *  Return the Reaction object for reaction *i*.
     *
     *  Wraps C++ accessor: `shared_ptr<Reaction> Kinetics::reaction(size_t)`
     *
     *  Uses:
     *  - `size_t Kinetics::nReactions()`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param i            Undocumented.
     *  @returns            Handle to stored Reaction object or -1 for exception handling.
     */
    int32_t kin_reaction(int32_t handle, int32_t i);
 
    /**
     *  The number of phases participating in the reaction mechanism.
     *
     *  Wraps C++ getter: `size_t Kinetics::nPhases()`
     *
     *  @param handle       Handle to queried Kinetics object.
     */
    int32_t kin_nPhases(int32_t handle);
 
    /**
     *  Return pointer to phase associated with Kinetics by index.
     *
     *  Wraps C++ accessor: `shared_ptr<ThermoPhase> Kinetics::phase(size_t)`
     *
     *  Uses:
     *  - `size_t Kinetics::nPhases()`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param n            Index of the ThermoPhase being sought.
     *  @returns            Handle to stored ThermoPhase object or -1 for exception handling.
     */
    int32_t kin_phase(int32_t handle, int32_t n);
 
    /**
     *  Return pointer to phase where the reactions occur.
     *
     *  Wraps C++ accessor: `shared_ptr<ThermoPhase> Kinetics::reactionPhase()`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @returns            Handle to stored ThermoPhase object or -1 for exception handling.
     */
    int32_t kin_reactionPhase(int32_t handle);
 
    /**
     *  Return the phase index of a phase in the list of phases defined within the object.
     *
     *  Wraps C++ method: `custom code`
     *
     *  Uses:
     *  - ` phaseIndex(const string&, bool)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param ph           string name of the phase
     */
    int32_t kin_phaseIndex(int32_t handle, const char* ph);
 
    /**
     *  The total number of species in all phases participating in the kinetics mechanism.
     *
     *  Wraps C++ getter: `size_t Kinetics::nTotalSpecies()`
     *
     *  @param handle       Handle to queried Kinetics object.
     */
    int32_t kin_nTotalSpecies(int32_t handle);
 
    /**
     *  Stoichiometric coefficient of species k as a reactant in reaction i.
     *
     *  Wraps C++ method: `virtual double Kinetics::reactantStoichCoeff(size_t, size_t)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param k            kinetic species index
     *  @param i            reaction index
     */
    double kin_reactantStoichCoeff(int32_t handle, int32_t k, int32_t i);
 
    /**
     *  Stoichiometric coefficient of species k as a product in reaction i.
     *
     *  Wraps C++ method: `virtual double Kinetics::productStoichCoeff(size_t, size_t)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param k            kinetic species index
     *  @param i            reaction index
     */
    double kin_productStoichCoeff(int32_t handle, int32_t k, int32_t i);
 
    /**
     *  Return the forward rates of progress of the reactions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getFwdRatesOfProgress(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] fwdROPLen Length of vector reserved for fwdROP.
     *  @param fwdROP       Output vector containing forward rates of progress of the reactions. Length: nReactions().
     */
    int32_t kin_getFwdRatesOfProgress(int32_t handle, int32_t fwdROPLen, double* fwdROP);
 
    /**
     *  Return the Reverse rates of progress of the reactions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getRevRatesOfProgress(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] revROPLen Length of vector reserved for revROP.
     *  @param revROP       Output vector containing reverse rates of progress of the reactions. Length: nReactions().
     */
    int32_t kin_getRevRatesOfProgress(int32_t handle, int32_t revROPLen, double* revROP);
 
    /**
     *  Net rates of progress.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getNetRatesOfProgress(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] netROPLen Length of vector reserved for netROP.
     *  @param netROP       Output vector of the net ROP. Length: nReactions().
     */
    int32_t kin_getNetRatesOfProgress(int32_t handle, int32_t netROPLen, double* netROP);
 
    /**
     *  Get the vector of equilibrium constants in concentration units.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getEquilibriumConstants(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] kcLen    Length of vector reserved for kc.
     *  @param[out] kc      Vector of equilibrium constants in concentration units; length nReactions().
     */
    int32_t kin_getEquilibriumConstants(int32_t handle, int32_t kcLen, double* kc);
 
    /**
     *  Return the forward rate constants.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getFwdRateConstants(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] kfwdLen  Length of vector reserved for kfwd.
     *  @param kfwd         Output vector containing the forward reaction rate constants. Length: nReactions().
     */
    int32_t kin_getFwdRateConstants(int32_t handle, int32_t kfwdLen, double* kfwd);
 
    /**
     *  Return the reverse rate constants.
     *
     *  Wraps C++ method: `virtual void Kinetics::getRevRateConstants(span<double>, bool)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] krevLen  Length of vector reserved for krev.
     *  @param krev         Output vector of reverse rate constants
     *  @param doIrreversible boolean indicating whether irreversible reactions should be included.
     */
    int32_t kin_getRevRateConstants(int32_t handle, int32_t krevLen, double* krev, int32_t doIrreversible);
 
    /**
     *  Species creation rates [kmol/m^3/s or kmol/m^2/s].
     *
     *  Wraps C++ getter: `virtual void Kinetics::getCreationRates(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] cdotLen  Length of vector reserved for cdot.
     *  @param cdot         Output vector of creation rates. Length: m_kk.
     */
    int32_t kin_getCreationRates(int32_t handle, int32_t cdotLen, double* cdot);
 
    /**
     *  Species destruction rates [kmol/m^3/s or kmol/m^2/s].
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDestructionRates(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] ddotLen  Length of vector reserved for ddot.
     *  @param ddot         Output vector of destruction rates. Length: m_kk.
     */
    int32_t kin_getDestructionRates(int32_t handle, int32_t ddotLen, double* ddot);
 
    /**
     *  Species net production rates [kmol/m^3/s or kmol/m^2/s].
     *
     *  Wraps C++ getter: `virtual void Kinetics::getNetProductionRates(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] wdotLen  Length of vector reserved for wdot.
     *  @param wdot         Output vector of net production rates. Length: m_kk.
     */
    int32_t kin_getNetProductionRates(int32_t handle, int32_t wdotLen, double* wdot);
 
    /**
     *  Calculate derivatives for forward rates-of-progress with respect to temperature at constant pressure, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getFwdRatesOfProgress_ddT(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getFwdRatesOfProgress_ddT(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for forward rates-of-progress with respect to pressure at constant temperature, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getFwdRatesOfProgress_ddP(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getFwdRatesOfProgress_ddP(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for forward rates-of-progress with respect to molar concentration at constant temperature, pressure and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getFwdRatesOfProgress_ddC(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getFwdRatesOfProgress_ddC(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for reverse rates-of-progress with respect to temperature at constant pressure, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getRevRatesOfProgress_ddT(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getRevRatesOfProgress_ddT(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for reverse rates-of-progress with respect to pressure at constant temperature, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getRevRatesOfProgress_ddP(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getRevRatesOfProgress_ddP(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for reverse rates-of-progress with respect to molar concentration at constant temperature, pressure and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getRevRatesOfProgress_ddC(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getRevRatesOfProgress_ddC(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for net rates-of-progress with respect to temperature at constant pressure, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getNetRatesOfProgress_ddT(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getNetRatesOfProgress_ddT(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for net rates-of-progress with respect to pressure at constant temperature, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getNetRatesOfProgress_ddP(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getNetRatesOfProgress_ddP(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for net rates-of-progress with respect to molar concentration at constant temperature, pressure and mole fractions.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getNetRatesOfProgress_ddC(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dropLen  Length of vector reserved for drop.
     *  @param[out] drop    Output vector of derivatives. Length: nReactions().
     */
    int32_t kin_getNetRatesOfProgress_ddC(int32_t handle, int32_t dropLen, double* drop);
 
    /**
     *  Calculate derivatives for species creation rates with respect to temperature at constant pressure, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getCreationRates_ddT(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getCreationRates_ddT(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species creation rates with respect to pressure at constant temperature, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getCreationRates_ddP(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getCreationRates_ddP(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species creation rates with respect to molar concentration at constant temperature, pressure and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getCreationRates_ddC(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getCreationRates_ddC(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species destruction rates with respect to temperature at constant pressure, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getDestructionRates_ddT(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getDestructionRates_ddT(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species destruction rates with respect to pressure at constant temperature, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getDestructionRates_ddP(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getDestructionRates_ddP(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species destruction rates with respect to molar concentration at constant temperature, pressure and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getDestructionRates_ddC(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getDestructionRates_ddC(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species net production rates with respect to temperature at constant pressure, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getNetProductionRates_ddT(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getNetProductionRates_ddT(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species net production rates with respect to pressure at constant temperature, molar concentration and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getNetProductionRates_ddP(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getNetProductionRates_ddP(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Calculate derivatives for species net production rates with respect to molar concentration at constant temperature, pressure and mole fractions.
     *
     *  Wraps C++ getter: `void Kinetics::getNetProductionRates_ddC(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] dwdotLen Length of vector reserved for dwdot.
     *  @param[out] dwdot   Output vector of derivatives. Length: m_kk.
     */
    int32_t kin_getNetProductionRates_ddC(int32_t handle, int32_t dwdotLen, double* dwdot);
 
    /**
     *  Dense composition Jacobian d(net production rate)/dX, column-major (n x n).
     *
     *  Wraps C++ method: `custom code`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param bufLen       Length of the reserved array; must be at least nTotalSpecies squared.
     *  @param buf          Output buffer, filled column-major with the dense Jacobian.
     */
    int32_t kin_getNetProductionRates_ddX(int32_t handle, int32_t bufLen, double* buf);
 
    /**
     *  Dense reaction composition Jacobian d(net rate of progress)/dX, column-major.
     *
     *  Wraps C++ method: `custom code`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param bufLen       Length of the reserved array; must be at least nReactions times nTotalSpecies.
     *  @param buf          Output buffer, filled column-major with the dense Jacobian.
     */
    int32_t kin_getNetRatesOfProgress_ddX(int32_t handle, int32_t bufLen, double* buf);
 
    /**
     *  The current value of the multiplier for reaction i.
     *
     *  Wraps C++ method: `double Kinetics::multiplier(size_t)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param i            index of the reaction
     */
    double kin_multiplier(int32_t handle, int32_t i);
 
    /**
     *  Set the multiplier for reaction i to f.
     *
     *  Wraps C++ method: `virtual void Kinetics::setMultiplier(size_t, double)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param i            index of the reaction
     *  @param f            value of the multiplier.
     */
    int32_t kin_setMultiplier(int32_t handle, int32_t i, double f);
 
    /**
     *  True if reaction i has been declared to be reversible.
     *
     *  Wraps C++ method: `bool Kinetics::isReversible(size_t)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param i            reaction index
     */
    int32_t kin_isReversible(int32_t handle, int32_t i);
 
    /**
     *  Return the index of a species within the phases participating in this kinetic mechanism.
     *
     *  Wraps C++ method: `custom code`
     *
     *  Uses:
     *  - ` kineticsSpeciesIndex(const string&, bool)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param nm           name of the species
     */
    int32_t kin_kineticsSpeciesIndex(int32_t handle, const char* nm);
 
    /**
     *  Advance the surface coverages in time.
     *
     *  Wraps C++ setter: `void InterfaceKinetics::advanceCoverages(double)`
     *
     *  @param handle       Handle to queried InterfaceKinetics object.
     *  @param tstep        Time value to advance the surface coverages
     */
    int32_t kin_advanceCoverages(int32_t handle, double tstep);
 
    /**
     *  Return the vector of values for the reactions change in enthalpy.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDeltaEnthalpy(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] deltaHLen Length of vector reserved for deltaH.
     *  @param deltaH       Output vector of deltaH's for reactions Length: nReactions().
     */
    int32_t kin_getDeltaEnthalpy(int32_t handle, int32_t deltaHLen, double* deltaH);
 
    /**
     *  Return the vector of values for the reaction Gibbs free energy change.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDeltaGibbs(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] deltaGLen Length of vector reserved for deltaG.
     *  @param deltaG       Output vector of deltaG's for reactions Length: nReactions().
     */
    int32_t kin_getDeltaGibbs(int32_t handle, int32_t deltaGLen, double* deltaG);
 
    /**
     *  Return the vector of values for the reactions change in entropy.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDeltaEntropy(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] deltaSLen Length of vector reserved for deltaS.
     *  @param deltaS       Output vector of deltaS's for reactions Length: nReactions().
     */
    int32_t kin_getDeltaEntropy(int32_t handle, int32_t deltaSLen, double* deltaS);
 
    /**
     *  Return the vector of values for the change in the standard state enthalpies of reaction.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDeltaSSEnthalpy(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] deltaHLen Length of vector reserved for deltaH.
     *  @param deltaH       Output vector of ss deltaH's for reactions Length: nReactions().
     */
    int32_t kin_getDeltaSSEnthalpy(int32_t handle, int32_t deltaHLen, double* deltaH);
 
    /**
     *  Return the vector of values for the reaction standard state Gibbs free energy change.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDeltaSSGibbs(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] deltaGLen Length of vector reserved for deltaG.
     *  @param deltaG       Output vector of ss deltaG's for reactions Length: nReactions().
     */
    int32_t kin_getDeltaSSGibbs(int32_t handle, int32_t deltaGLen, double* deltaG);
 
    /**
     *  Return the vector of values for the change in the standard state entropies for each reaction.
     *
     *  Wraps C++ getter: `virtual void Kinetics::getDeltaSSEntropy(span<double>)`
     *
     *  @param handle       Handle to queried Kinetics object.
     *  @param[in] deltaSLen Length of vector reserved for deltaS.
     *  @param deltaS       Output vector of ss deltaS's for reactions Length: nReactions().
     */
    int32_t kin_getDeltaSSEntropy(int32_t handle, int32_t deltaSLen, double* deltaS);
 
    /**
     *  Delete Kinetics object.
     *
     *  Wraps C++ destructor: `undefined`
     *
     *  @param handle       Handle to Kinetics object.
     *  @returns            Zero for success and -1 for exception handling.
     */
    int32_t kin_del(int32_t handle);
 
    /**
     *  Return size of Kinetics storage.
     *
     *  Wraps C++ reserved CLib function: `custom code`
     *
     *  @returns            Size or -1 for exception handling.
     */
    int32_t kin_cabinetSize();
 
    /**
     *  @}
     */
 
#ifdef __cplusplus
}
#endif
 
#endif // CTKIN_H