ctreactor.cpp

Go to the documentation of this file.

/**
 *  CTREACTOR - Generated CLib %Cantera interface library.
 *
 *  @file ctreactor.cpp
 *
 *  Generated CLib API for Cantera's ReactorBase 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/ctreactor.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/zeroD/ReactorFactory.h"
#include "cantera/zeroD/FlowReactor.h"
#include "cantera/base/Solution.h"
#include "cantera/zeroD/ReactorSurface.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<ReactorBase> (single-instance object)
typedef Cabinet<ReactorBase> ReactorBaseCabinet;
template<> ReactorBaseCabinet* ReactorBaseCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<Solution> SolutionCabinet;
template<> SolutionCabinet* SolutionCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ReactorSurface> ReactorSurfaceCabinet;
template<> ReactorSurfaceCabinet* ReactorSurfaceCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t reactor_new(const char* model, int32_t phase, int32_t clone, const char* name)
    {
        // constructor: shared_ptr<ReactorBase> newReactorBase(const string&, shared_ptr<Solution>, bool, const string&)
        try {
            bool clone_ = (clone != 0);
            return ReactorBaseCabinet::add(newReactorBase(model, SolutionCabinet::at(phase), clone_, name));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t reactor_newSurface(int32_t phase, int32_t reactorsLen, const int32_t* reactors, int32_t clone, const char* name)
    {
        // constructor: shared_ptr<ReactorSurface> newReactorSurface(shared_ptr<Solution>, const vector<shared_ptr<ReactorBase>>&, bool, const string&)
        try {
            vector<shared_ptr<ReactorBase>> reactors_;
            for (int i = 0; i < reactorsLen; i++) {
                reactors_.push_back(ReactorBaseCabinet::at(reactors[i]));
            }
            bool clone_ = (clone != 0);
            return ReactorBaseCabinet::add(newReactorSurface(SolutionCabinet::at(phase), reactors_, clone_, name));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t reactor_type(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: virtual string ReactorBase::type()
        try {
            string out = ReactorBaseCabinet::at(handle)->type();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_name(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string ReactorBase::name()
        try {
            string out = ReactorBaseCabinet::at(handle)->name();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_setName(int32_t handle, const char* name)
    {
        // setter: void ReactorBase::setName(const string&)
        try {
            ReactorBaseCabinet::at(handle)->setName(name);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_phase(int32_t handle)
    {
        // accessor: shared_ptr<Solution> ReactorBase::phase()
        try {
            return SolutionCabinet::add(ReactorBaseCabinet::at(handle)->phase());
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t reactor_setInitialVolume(int32_t handle, double vol)
    {
        // setter: virtual void ReactorBase::setInitialVolume(double)
        try {
            ReactorBaseCabinet::at(handle)->setInitialVolume(vol);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double reactor_area(int32_t handle)
    {
        // getter: virtual double ReactorBase::area()
        try {
            return ReactorBaseCabinet::at(handle)->area();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t reactor_setArea(int32_t handle, double a)
    {
        // setter: virtual void ReactorBase::setArea(double)
        try {
            ReactorBaseCabinet::at(handle)->setArea(a);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_chemistryEnabled(int32_t handle)
    {
        // getter: virtual bool ReactorBase::chemistryEnabled()
        try {
            bool out = ReactorBaseCabinet::at(handle)->chemistryEnabled();
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_setChemistryEnabled(int32_t handle, int32_t cflag)
    {
        // setter: virtual void ReactorBase::setChemistryEnabled(bool)
        try {
            bool cflag_ = (cflag != 0);
            ReactorBaseCabinet::at(handle)->setChemistryEnabled(cflag_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_energyEnabled(int32_t handle)
    {
        // getter: virtual bool ReactorBase::energyEnabled()
        try {
            bool out = ReactorBaseCabinet::at(handle)->energyEnabled();
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_setEnergyEnabled(int32_t handle, int32_t eflag)
    {
        // setter: virtual void ReactorBase::setEnergyEnabled(bool)
        try {
            bool eflag_ = (eflag != 0);
            ReactorBaseCabinet::at(handle)->setEnergyEnabled(eflag_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double reactor_mass(int32_t handle)
    {
        // getter: double ReactorBase::mass()
        try {
            return ReactorBaseCabinet::at(handle)->mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactor_volume(int32_t handle)
    {
        // getter: double ReactorBase::volume()
        try {
            return ReactorBaseCabinet::at(handle)->volume();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactor_density(int32_t handle)
    {
        // getter: double ReactorBase::density()
        try {
            return ReactorBaseCabinet::at(handle)->density();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactor_temperature(int32_t handle)
    {
        // getter: double ReactorBase::temperature()
        try {
            return ReactorBaseCabinet::at(handle)->temperature();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactor_enthalpy_mass(int32_t handle)
    {
        // getter: double ReactorBase::enthalpy_mass()
        try {
            return ReactorBaseCabinet::at(handle)->enthalpy_mass();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactor_pressure(int32_t handle)
    {
        // getter: double ReactorBase::pressure()
        try {
            return ReactorBaseCabinet::at(handle)->pressure();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactor_massFraction(int32_t handle, int32_t k)
    {
        // method: double ReactorBase::massFraction(size_t)
        try {
            return ReactorBaseCabinet::at(handle)->massFraction(k);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t reactor_massFractions(int32_t handle, int32_t bufLen, double* buf)
    {
        // getter: const double* ReactorBase::massFractions()
        try {
            auto out = ReactorBaseCabinet::at(handle)->massFractions();
            std::copy(out, out + bufLen, buf);
            return bufLen;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_nSensParams(int32_t handle)
    {
        // size getter: virtual size_t ReactorBase::nSensParams()
        try {
            return static_cast<int32_t>(ReactorBaseCabinet::at(handle)->nSensParams());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t reactor_addSensitivityReaction(int32_t handle, int32_t rxn)
    {
        // setter: virtual void ReactorBase::addSensitivityReaction(size_t)
        try {
            ReactorBaseCabinet::at(handle)->addSensitivityReaction(rxn);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double reactor_massFlowRate(int32_t handle)
    {
        // getter: double FlowReactor::massFlowRate()
        try {
            return ReactorBaseCabinet::as<FlowReactor>(handle)->massFlowRate();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t reactor_setMassFlowRate(int32_t handle, double mdot)
    {
        // setter: void FlowReactor::setMassFlowRate(double)
        try {
            ReactorBaseCabinet::as<FlowReactor>(handle)->setMassFlowRate(mdot);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_del(int32_t handle)
    {
        // destructor
        try {
            ReactorBaseCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactor_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return ReactorBaseCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"