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/kinetics/Reaction.h"
#include "cantera/thermo/ThermoFactory.h"
#include "cantera/thermo/SurfPhase.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<Kinetics> (single-instance object)
typedef Cabinet<Kinetics> KineticsCabinet;
template<> KineticsCabinet* KineticsCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<Reaction> ReactionCabinet;
template<> ReactionCabinet* ReactionCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ThermoPhase> ThermoPhaseCabinet;
template<> ThermoPhaseCabinet* ThermoPhaseCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t kin_getType(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)
    {
        // getter: size_t Kinetics::nReactions()
        try {
            return 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 || 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)
    {
        // getter: size_t Kinetics::nPhases()
        try {
            return 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 || 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)
    {
        // getter: shared_ptr<ThermoPhase> Kinetics::reactionPhase()
        try {
            auto obj = KineticsCabinet::at(handle)->reactionPhase();
            return ThermoPhaseCabinet::index(*obj, handle);
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t kin_phaseIndex(int32_t handle, const char* ph)
    {
        // method: size_t Kinetics::phaseIndex(const string&)
        try {
            return KineticsCabinet::at(handle)->phaseIndex(ph);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t kin_nTotalSpecies(int32_t handle)
    {
        // getter: size_t Kinetics::nTotalSpecies()
        try {
            return 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)
    {
        // getter: virtual void Kinetics::getFwdRatesOfProgress(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getFwdRatesOfProgress(fwdROP);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getRevRatesOfProgress(int32_t handle, int32_t revROPLen, double* revROP)
    {
        // getter: virtual void Kinetics::getRevRatesOfProgress(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getRevRatesOfProgress(revROP);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetRatesOfProgress(int32_t handle, int32_t netROPLen, double* netROP)
    {
        // getter: virtual void Kinetics::getNetRatesOfProgress(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getNetRatesOfProgress(netROP);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getEquilibriumConstants(int32_t handle, int32_t kcLen, double* kc)
    {
        // getter: virtual void Kinetics::getEquilibriumConstants(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getEquilibriumConstants(kc);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getFwdRateConstants(int32_t handle, int32_t kfwdLen, double* kfwd)
    {
        // getter: virtual void Kinetics::getFwdRateConstants(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            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(double*, bool)
        try {
            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)
    {
        // getter: virtual void Kinetics::getCreationRates(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getCreationRates(cdot);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDestructionRates(int32_t handle, int32_t ddotLen, double* ddot)
    {
        // getter: virtual void Kinetics::getDestructionRates(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDestructionRates(ddot);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getNetProductionRates(int32_t handle, int32_t wdotLen, double* wdot)
    {
        // getter: virtual void Kinetics::getNetProductionRates(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getNetProductionRates(wdot);
            return 0;
        } 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_speciesIndex(int32_t handle, const char* nm)
    {
        // method: size_t Kinetics::kineticsSpeciesIndex(const string&)
        try {
            return KineticsCabinet::at(handle)->kineticsSpeciesIndex(nm);
        } catch (...) {
            return handleAllExceptions(ERR, 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)
    {
        // getter: virtual void Kinetics::getDeltaEnthalpy(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDeltaEnthalpy(deltaH);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaGibbs(int32_t handle, int32_t deltaGLen, double* deltaG)
    {
        // getter: virtual void Kinetics::getDeltaGibbs(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDeltaGibbs(deltaG);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaEntropy(int32_t handle, int32_t deltaSLen, double* deltaS)
    {
        // getter: virtual void Kinetics::getDeltaEntropy(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDeltaEntropy(deltaS);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaSSEnthalpy(int32_t handle, int32_t deltaHLen, double* deltaH)
    {
        // getter: virtual void Kinetics::getDeltaSSEnthalpy(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDeltaSSEnthalpy(deltaH);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaSSGibbs(int32_t handle, int32_t deltaGLen, double* deltaG)
    {
        // getter: virtual void Kinetics::getDeltaSSGibbs(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDeltaSSGibbs(deltaG);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_getDeltaSSEntropy(int32_t handle, int32_t deltaSLen, double* deltaS)
    {
        // getter: virtual void Kinetics::getDeltaSSEntropy(double*)
        try {
            auto& obj = KineticsCabinet::at(handle);
            // no size checking specified
            obj->getDeltaSSEntropy(deltaS);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_del(int32_t handle)
    {
        // no-op
        return 0;
    }
 
    int32_t kin_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return KineticsCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t kin_parentHandle(int32_t handle)
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return KineticsCabinet::parent(handle);
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"