ctreactornet.cpp

Go to the documentation of this file.

/**
 *  CTREACTORNET - Generated CLib %Cantera interface library.
 *
 *  @file ctreactornet.cpp
 *
 *  Generated CLib API for Cantera's ReactorNet 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/ctreactornet.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/zeroD/ReactorNet.h"
#include "cantera/zeroD/ReactorFactory.h"
#include "cantera/zeroD/FlowReactor.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<ReactorNet> (single-instance object)
typedef Cabinet<ReactorNet> ReactorNetCabinet;
template<> ReactorNetCabinet* ReactorNetCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<ReactorBase> ReactorBaseCabinet;
template<> ReactorBaseCabinet* ReactorBaseCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t reactornet_new(int32_t reactorsLen, int32_t* reactors)
    {
        // constructor: shared_ptr<ReactorNet> newReactorNet(span<shared_ptr<ReactorBase>>)
        try {
            vector<shared_ptr<ReactorBase>> reactors_;
            for (int i = 0; i < reactorsLen; i++) {
                reactors_.push_back(ReactorBaseCabinet::at(reactors[i]));
            }
            return ReactorNetCabinet::add(newReactorNet(reactors_));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t reactornet_setInitialTime(int32_t handle, double time)
    {
        // setter: void ReactorNet::setInitialTime(double)
        try {
            ReactorNetCabinet::at(handle)->setInitialTime(time);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_setMaxTimeStep(int32_t handle, double maxstep)
    {
        // setter: void ReactorNet::setMaxTimeStep(double)
        try {
            ReactorNetCabinet::at(handle)->setMaxTimeStep(maxstep);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_setRelativeTolerance(int32_t handle, double rtol)
    {
        // setter: void ReactorNet::setRelativeTolerance(double)
        try {
            ReactorNetCabinet::at(handle)->setRelativeTolerance(rtol);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_setAbsoluteTolerance(int32_t handle, double atol)
    {
        // setter: void ReactorNet::setAbsoluteTolerance(double)
        try {
            ReactorNetCabinet::at(handle)->setAbsoluteTolerance(atol);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_clearAbsoluteTolerance(int32_t handle)
    {
        // method: void ReactorNet::clearAbsoluteTolerance()
        try {
            ReactorNetCabinet::at(handle)->clearAbsoluteTolerance();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_setTolerances(int32_t handle, double rtol, double atol)
    {
        // method: void ReactorNet::setTolerances(double, double)
        try {
            ReactorNetCabinet::at(handle)->setTolerances(rtol, atol);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_setSensitivityTolerances(int32_t handle, double rtol, double atol)
    {
        // method: void ReactorNet::setSensitivityTolerances(double, double)
        try {
            ReactorNetCabinet::at(handle)->setSensitivityTolerances(rtol, atol);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_advance(int32_t handle, double t)
    {
        // setter: void ReactorNet::advance(double)
        try {
            ReactorNetCabinet::at(handle)->advance(t);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double reactornet_step(int32_t handle)
    {
        // getter: double ReactorNet::step()
        try {
            return ReactorNetCabinet::at(handle)->step();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactornet_time(int32_t handle)
    {
        // getter: double ReactorNet::time()
        try {
            return ReactorNetCabinet::at(handle)->time();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactornet_rtol(int32_t handle)
    {
        // getter: double ReactorNet::rtol()
        try {
            return ReactorNetCabinet::at(handle)->rtol();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactornet_atol(int32_t handle)
    {
        // getter: double ReactorNet::atol()
        try {
            return ReactorNetCabinet::at(handle)->atol();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double reactornet_sensitivity(int32_t handle, const char* component, int32_t p, int32_t reactor)
    {
        // method: double ReactorNet::sensitivity(const string&, size_t, int)
        try {
            return ReactorNetCabinet::at(handle)->sensitivity(component, p, reactor);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t reactornet_neq(int32_t handle)
    {
        // size getter: size_t ReactorNet::neq()
        try {
            return static_cast<int32_t>(ReactorNetCabinet::at(handle)->neq());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t reactornet_getState(int32_t handle, int32_t yLen, double* y)
    {
        // array getter: void ReactorNet::getState(span<double>)
        try {
            auto& obj = ReactorNetCabinet::at(handle);
            // no size checking specified
            span<double> y_(y, yLen);
            obj->getState(y_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_componentName(int32_t handle, int32_t i, int32_t bufLen, char* buf)
    {
        // method: string ReactorNet::componentName(size_t)
        try {
            string out = ReactorNetCabinet::at(handle)->componentName(i);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_del(int32_t handle)
    {
        // destructor
        try {
            ReactorNetCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactornet_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return ReactorNetCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"