ctkin.cpp

Go to the documentation of this file.

/**
 *  CTKIN - Generated CLib %Cantera interface library.
 *
 *  @file ctkin.cpp
 *
 *  Generated CLib API for Cantera's Kinetics 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/ctkin.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/kinetics/KineticsFactory.h"
#include "cantera/kinetics/InterfaceKinetics.h"
#include "cantera/thermo/ThermoFactory.h"
#include "cantera/thermo/SurfPhase.h"
#include "cantera/kinetics/Reaction.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<Kinetics> (single-instance object)
typedef Cabinet<Kinetics> KineticsCabinet;
template<> KineticsCabinet* KineticsCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<ThermoPhase> ThermoPhaseCabinet;
template<> ThermoPhaseCabinet* ThermoPhaseCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Reaction> ReactionCabinet;
template<> ReactionCabinet* ReactionCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t kin_kineticsType(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: virtual string Kinetics::kineticsType()
        try {
            string out = KineticsCabinet::at(handle)->kineticsType();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_nReactions(int32_t handle)
    {
        // size getter: size_t Kinetics::nReactions()
        try {
            return static_cast<int32_t>(KineticsCabinet::at(handle)->nReactions());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t kin_reaction(int32_t handle, int32_t i)
    {
        // accessor: shared_ptr<Reaction> Kinetics::reaction(size_t)
        try {
            if (i < 0 || static_cast<size_t>(i) >= KineticsCabinet::at(handle)->nReactions()) {
                throw IndexError("kin_reaction", "", i, KineticsCabinet::at(handle)->nReactions());
            }
            return ReactionCabinet::add(KineticsCabinet::at(handle)->reaction(i));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t kin_nPhases(int32_t handle)
    {
        // size getter: size_t Kinetics::nPhases()
        try {
            return static_cast<int32_t>(KineticsCabinet::at(handle)->nPhases());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t kin_phase(int32_t handle, int32_t n)
    {
        // accessor: shared_ptr<ThermoPhase> Kinetics::phase(size_t)
        try {
            if (n < 0 || static_cast<size_t>(n) >= KineticsCabinet::at(handle)->nPhases()) {
                throw IndexError("kin_phase", "", n, KineticsCabinet::at(handle)->nPhases());
            }
            return ThermoPhaseCabinet::add(KineticsCabinet::at(handle)->phase(n));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t kin_reactionPhase(int32_t handle)
    {
        // accessor: shared_ptr<ThermoPhase> Kinetics::reactionPhase()
        try {
            return ThermoPhaseCabinet::add(KineticsCabinet::at(handle)->reactionPhase());
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t kin_phaseIndex(int32_t handle, const char* ph)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            return static_cast<int32_t>(KineticsCabinet::at(handle)->phaseIndex(ph, true));
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_nTotalSpecies(int32_t handle)
    {
        // size getter: size_t Kinetics::nTotalSpecies()
        try {
            return static_cast<int32_t>(KineticsCabinet::at(handle)->nTotalSpecies());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double kin_reactantStoichCoeff(int32_t handle, int32_t k, int32_t i)
    {
        // method: virtual double Kinetics::reactantStoichCoeff(size_t, size_t)
        try {
            return KineticsCabinet::at(handle)->reactantStoichCoeff(k, i);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double kin_productStoichCoeff(int32_t handle, int32_t k, int32_t i)
    {
        // method: virtual double Kinetics::productStoichCoeff(size_t, size_t)
        try {
            return KineticsCabinet::at(handle)->productStoichCoeff(k, i);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t kin_getFwdRatesOfProgress(int32_t handle, int32_t fwdROPLen, double* fwdROP)
    {
        // array getter: virtual void Kinetics::getFwdRatesOfProgress(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> fwdROP_(fwdROP, fwdROPLen);
            obj->getFwdRatesOfProgress(fwdROP_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getRevRatesOfProgress(int32_t handle, int32_t revROPLen, double* revROP)
    {
        // array getter: virtual void Kinetics::getRevRatesOfProgress(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> revROP_(revROP, revROPLen);
            obj->getRevRatesOfProgress(revROP_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetRatesOfProgress(int32_t handle, int32_t netROPLen, double* netROP)
    {
        // array getter: virtual void Kinetics::getNetRatesOfProgress(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> netROP_(netROP, netROPLen);
            obj->getNetRatesOfProgress(netROP_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getEquilibriumConstants(int32_t handle, int32_t kcLen, double* kc)
    {
        // array getter: virtual void Kinetics::getEquilibriumConstants(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> kc_(kc, kcLen);
            obj->getEquilibriumConstants(kc_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getFwdRateConstants(int32_t handle, int32_t kfwdLen, double* kfwd)
    {
        // array getter: virtual void Kinetics::getFwdRateConstants(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> kfwd_(kfwd, kfwdLen);
            obj->getFwdRateConstants(kfwd_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getRevRateConstants(int32_t handle, int32_t krevLen, double* krev, int32_t doIrreversible)
    {
        // method: virtual void Kinetics::getRevRateConstants(span<double>, bool)
        try {
            span<double> krev_(krev, krevLen);
            bool doIrreversible_ = (doIrreversible != 0);
            KineticsCabinet::at(handle)->getRevRateConstants(krev_, doIrreversible_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getCreationRates(int32_t handle, int32_t cdotLen, double* cdot)
    {
        // array getter: virtual void Kinetics::getCreationRates(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> cdot_(cdot, cdotLen);
            obj->getCreationRates(cdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDestructionRates(int32_t handle, int32_t ddotLen, double* ddot)
    {
        // array getter: virtual void Kinetics::getDestructionRates(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> ddot_(ddot, ddotLen);
            obj->getDestructionRates(ddot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetProductionRates(int32_t handle, int32_t wdotLen, double* wdot)
    {
        // array getter: virtual void Kinetics::getNetProductionRates(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> wdot_(wdot, wdotLen);
            obj->getNetProductionRates(wdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getFwdRatesOfProgress_ddT(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getFwdRatesOfProgress_ddT(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getFwdRatesOfProgress_ddT(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getFwdRatesOfProgress_ddP(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getFwdRatesOfProgress_ddP(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getFwdRatesOfProgress_ddP(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getFwdRatesOfProgress_ddC(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getFwdRatesOfProgress_ddC(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getFwdRatesOfProgress_ddC(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getRevRatesOfProgress_ddT(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getRevRatesOfProgress_ddT(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getRevRatesOfProgress_ddT(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getRevRatesOfProgress_ddP(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getRevRatesOfProgress_ddP(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getRevRatesOfProgress_ddP(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getRevRatesOfProgress_ddC(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getRevRatesOfProgress_ddC(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getRevRatesOfProgress_ddC(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetRatesOfProgress_ddT(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getNetRatesOfProgress_ddT(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getNetRatesOfProgress_ddT(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetRatesOfProgress_ddP(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getNetRatesOfProgress_ddP(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getNetRatesOfProgress_ddP(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetRatesOfProgress_ddC(int32_t handle, int32_t dropLen, double* drop)
    {
        // array getter: virtual void Kinetics::getNetRatesOfProgress_ddC(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> drop_(drop, dropLen);
            obj->getNetRatesOfProgress_ddC(drop_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getCreationRates_ddT(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getCreationRates_ddT(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getCreationRates_ddT(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getCreationRates_ddP(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getCreationRates_ddP(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getCreationRates_ddP(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getCreationRates_ddC(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getCreationRates_ddC(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getCreationRates_ddC(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDestructionRates_ddT(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getDestructionRates_ddT(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getDestructionRates_ddT(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDestructionRates_ddP(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getDestructionRates_ddP(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getDestructionRates_ddP(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDestructionRates_ddC(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getDestructionRates_ddC(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getDestructionRates_ddC(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetProductionRates_ddT(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getNetProductionRates_ddT(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getNetProductionRates_ddT(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetProductionRates_ddP(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getNetProductionRates_ddP(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getNetProductionRates_ddP(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetProductionRates_ddC(int32_t handle, int32_t dwdotLen, double* dwdot)
    {
        // array getter: void Kinetics::getNetProductionRates_ddC(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> dwdot_(dwdot, dwdotLen);
            obj->getNetProductionRates_ddC(dwdot_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetProductionRates_ddX(int32_t handle, int32_t bufLen, double* buf)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            auto& obj = KineticsCabinet::at(handle);
            auto mat = obj->netProductionRates_ddX();
            int32_t rows = static_cast<int32_t>(mat.rows());
            int32_t cols = static_cast<int32_t>(mat.cols());
            int32_t need = rows * cols;
            if (bufLen < need) {
                throw CanteraError("kin_getNetProductionRates_ddX", "bufLen is too small");
            }
            for (int32_t idx = 0; idx < need; ++idx) {
                buf[idx] = 0.0;
            }
            for (int k = 0; k < mat.outerSize(); ++k) {
                for (Eigen::SparseMatrix<double>::InnerIterator it(mat, k); it; ++it) {
                    buf[it.col() * rows + it.row()] = it.value();
                }
            }
            return 0;
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetRatesOfProgress_ddX(int32_t handle, int32_t bufLen, double* buf)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            auto& obj = KineticsCabinet::at(handle);
            auto mat = obj->netRatesOfProgress_ddX();
            int32_t rows = static_cast<int32_t>(mat.rows());
            int32_t cols = static_cast<int32_t>(mat.cols());
            int32_t need = rows * cols;
            if (bufLen < need) {
                throw CanteraError("kin_getNetRatesOfProgress_ddX", "bufLen is too small");
            }
            for (int32_t idx = 0; idx < need; ++idx) {
                buf[idx] = 0.0;
            }
            for (int k = 0; k < mat.outerSize(); ++k) {
                for (Eigen::SparseMatrix<double>::InnerIterator it(mat, k); it; ++it) {
                    buf[it.col() * rows + it.row()] = it.value();
                }
            }
            return 0;
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double kin_multiplier(int32_t handle, int32_t i)
    {
        // method: double Kinetics::multiplier(size_t)
        try {
            return KineticsCabinet::at(handle)->multiplier(i);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t kin_setMultiplier(int32_t handle, int32_t i, double f)
    {
        // method: virtual void Kinetics::setMultiplier(size_t, double)
        try {
            KineticsCabinet::at(handle)->setMultiplier(i, f);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_isReversible(int32_t handle, int32_t i)
    {
        // method: bool Kinetics::isReversible(size_t)
        try {
            bool out = KineticsCabinet::at(handle)->isReversible(i);
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_kineticsSpeciesIndex(int32_t handle, const char* nm)
    {
        // method: custom code
        try {
            // *************** begin custom code ***************
            return static_cast<int32_t>(KineticsCabinet::at(handle)->kineticsSpeciesIndex(nm, true));
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_advanceCoverages(int32_t handle, double tstep)
    {
        // setter: void InterfaceKinetics::advanceCoverages(double)
        try {
            KineticsCabinet::as<InterfaceKinetics>(handle)->advanceCoverages(tstep);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaEnthalpy(int32_t handle, int32_t deltaHLen, double* deltaH)
    {
        // array getter: virtual void Kinetics::getDeltaEnthalpy(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> deltaH_(deltaH, deltaHLen);
            obj->getDeltaEnthalpy(deltaH_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaGibbs(int32_t handle, int32_t deltaGLen, double* deltaG)
    {
        // array getter: virtual void Kinetics::getDeltaGibbs(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> deltaG_(deltaG, deltaGLen);
            obj->getDeltaGibbs(deltaG_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaEntropy(int32_t handle, int32_t deltaSLen, double* deltaS)
    {
        // array getter: virtual void Kinetics::getDeltaEntropy(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> deltaS_(deltaS, deltaSLen);
            obj->getDeltaEntropy(deltaS_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaSSEnthalpy(int32_t handle, int32_t deltaHLen, double* deltaH)
    {
        // array getter: virtual void Kinetics::getDeltaSSEnthalpy(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> deltaH_(deltaH, deltaHLen);
            obj->getDeltaSSEnthalpy(deltaH_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaSSGibbs(int32_t handle, int32_t deltaGLen, double* deltaG)
    {
        // array getter: virtual void Kinetics::getDeltaSSGibbs(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> deltaG_(deltaG, deltaGLen);
            obj->getDeltaSSGibbs(deltaG_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaSSEntropy(int32_t handle, int32_t deltaSLen, double* deltaS)
    {
        // array getter: virtual void Kinetics::getDeltaSSEntropy(span<double>)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            span<double> deltaS_(deltaS, deltaSLen);
            obj->getDeltaSSEntropy(deltaS_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_del(int32_t handle)
    {
        // destructor
        try {
            KineticsCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return KineticsCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"