ctdomain.cpp

Go to the documentation of this file.

/**
 *  CTDOMAIN - Generated CLib %Cantera interface library.
 *
 *  @file ctdomain.cpp
 *
 *  Generated CLib API for Cantera's Domain1D 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/ctdomain.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/oneD/DomainFactory.h"
#include "cantera/oneD/Boundary1D.h"
#include "cantera/oneD/Flow1D.h"
#include "cantera/base/Solution.h"
#include "cantera/transport/TransportFactory.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<Domain1D> (single-instance object)
typedef Cabinet<Domain1D> Domain1DCabinet;
template<> Domain1DCabinet* Domain1DCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<Boundary1D> Boundary1DCabinet;
template<> Boundary1DCabinet* Boundary1DCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Flow1D> Flow1DCabinet;
template<> Flow1DCabinet* Flow1DCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Solution> SolutionCabinet;
template<> SolutionCabinet* SolutionCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Transport> TransportCabinet;
template<> TransportCabinet* TransportCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t domain_newFlow1D(const char* domainType, int32_t solution, const char* id)
    {
        // constructor: shared_ptr<Flow1D> newFlow1D(const string&, shared_ptr<Solution>, const string&)
        try {
            return Domain1DCabinet::add(newFlow1D(domainType, SolutionCabinet::at(solution), id));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t domain_newBoundary1D(const char* domainType, int32_t solution, const char* id)
    {
        // constructor: shared_ptr<Boundary1D> newBoundary1D(const string&, shared_ptr<Solution>, const string&)
        try {
            return Domain1DCabinet::add(newBoundary1D(domainType, SolutionCabinet::at(solution), id));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t domain_type(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string Domain1D::type()
        try {
            string out = Domain1DCabinet::at(handle)->type();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_domainIndex(int32_t handle)
    {
        // size getter: size_t Domain1D::domainIndex()
        try {
            return static_cast<int32_t>(Domain1DCabinet::at(handle)->domainIndex());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_index(int32_t handle, int32_t n, int32_t j)
    {
        // size getter: size_t Domain1D::index(size_t, size_t)
        try {
            return static_cast<int32_t>(Domain1DCabinet::at(handle)->index(n, j));
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_nComponents(int32_t handle)
    {
        // size getter: size_t Domain1D::nComponents()
        try {
            return static_cast<int32_t>(Domain1DCabinet::at(handle)->nComponents());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_nPoints(int32_t handle)
    {
        // size getter: size_t Domain1D::nPoints()
        try {
            return static_cast<int32_t>(Domain1DCabinet::at(handle)->nPoints());
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_componentName(int32_t handle, int32_t n, int32_t bufLen, char* buf)
    {
        // method: virtual string Domain1D::componentName(size_t)
        try {
            string out = Domain1DCabinet::at(handle)->componentName(n);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_componentIndex(int32_t handle, const char* name)
    {
        // size getter: virtual size_t Domain1D::componentIndex(const string&)
        try {
            return static_cast<int32_t>(Domain1DCabinet::at(handle)->componentIndex(name));
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_phase(int32_t handle)
    {
        // accessor: shared_ptr<Solution> Domain1D::phase()
        try {
            return SolutionCabinet::add(Domain1DCabinet::at(handle)->phase());
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t domain_updateState(int32_t handle, int32_t loc)
    {
        // setter: virtual void Domain1D::updateState(size_t)
        try {
            Domain1DCabinet::at(handle)->updateState(loc);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double domain_value(int32_t handle, const char* component)
    {
        // method: virtual double Domain1D::value(const string&)
        try {
            return Domain1DCabinet::at(handle)->value(component);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t domain_setValue(int32_t handle, const char* component, double value)
    {
        // method: virtual void Domain1D::setValue(const string&, double)
        try {
            Domain1DCabinet::at(handle)->setValue(component, value);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_values(int32_t handle, const char* component, int32_t bufLen, double* buf)
    {
        // method: vector<double> Domain1D::values(const string&)
        try {
            vector<double> out = Domain1DCabinet::at(handle)->values(component);
            std::copy(out.begin(), out.end(), buf);
            return int(out.size());
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_getValues(int32_t handle, const char* component, int32_t valuesLen, double* values)
    {
        // method: virtual void Domain1D::getValues(const string&, vector<double>&)
        try {
            vector<double> values_(valuesLen);
            Domain1DCabinet::at(handle)->getValues(component, values_);
            std::copy(values_.begin(), values_.end(), values);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setValues(int32_t handle, const char* component, int32_t valuesLen, const double* values)
    {
        // method: virtual void Domain1D::setValues(const string&, const vector<double>&)
        try {
            const vector<double> values_(values, values + valuesLen);
            Domain1DCabinet::at(handle)->setValues(component, values_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_residuals(int32_t handle, const char* component, int32_t bufLen, double* buf)
    {
        // method: vector<double> Domain1D::residuals(const string&)
        try {
            vector<double> out = Domain1DCabinet::at(handle)->residuals(component);
            std::copy(out.begin(), out.end(), buf);
            return int(out.size());
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setProfile(int32_t handle, const char* component, int32_t posLen, const double* pos, int32_t valuesLen, const double* values)
    {
        // method: virtual void Domain1D::setProfile(const string&, const vector<double>&, const vector<double>&)
        try {
            const vector<double> pos_(pos, pos + posLen);
            const vector<double> values_(values, values + valuesLen);
            Domain1DCabinet::at(handle)->setProfile(component, pos_, values_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setFlatProfile(int32_t handle, const char* component, double value)
    {
        // method: virtual void Domain1D::setFlatProfile(const string&, double)
        try {
            Domain1DCabinet::at(handle)->setFlatProfile(component, value);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setBounds(int32_t handle, int32_t n, double lower, double upper)
    {
        // method: void Domain1D::setBounds(size_t, double, double)
        try {
            Domain1DCabinet::at(handle)->setBounds(n, lower, upper);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double domain_lowerBound(int32_t handle, int32_t n)
    {
        // method: double Domain1D::lowerBound(size_t)
        try {
            return Domain1DCabinet::at(handle)->lowerBound(n);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double domain_upperBound(int32_t handle, int32_t n)
    {
        // method: double Domain1D::upperBound(size_t)
        try {
            return Domain1DCabinet::at(handle)->upperBound(n);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t domain_setSteadyTolerances(int32_t handle, double rtol, double atol, int32_t n)
    {
        // method: void Domain1D::setSteadyTolerances(double, double, size_t)
        try {
            Domain1DCabinet::at(handle)->setSteadyTolerances(rtol, atol, n);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setTransientTolerances(int32_t handle, double rtol, double atol, int32_t n)
    {
        // method: void Domain1D::setTransientTolerances(double, double, size_t)
        try {
            Domain1DCabinet::at(handle)->setTransientTolerances(rtol, atol, n);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double domain_rtol(int32_t handle, int32_t n)
    {
        // method: double Domain1D::rtol(size_t)
        try {
            return Domain1DCabinet::at(handle)->rtol(n);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double domain_atol(int32_t handle, int32_t n)
    {
        // method: double Domain1D::atol(size_t)
        try {
            return Domain1DCabinet::at(handle)->atol(n);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t domain_setupGrid(int32_t handle, int32_t gridLen, const double* grid)
    {
        // setter: void Domain1D::setupGrid(const vector<double>&)
        try {
            const vector<double> grid_(grid, grid + gridLen);
            Domain1DCabinet::at(handle)->setupGrid(grid_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setupUniformGrid(int32_t handle, int32_t points, double length, double start)
    {
        // method: void Domain1D::setupUniformGrid(size_t, double, double)
        try {
            Domain1DCabinet::at(handle)->setupUniformGrid(points, length, start);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setID(int32_t handle, const char* s)
    {
        // setter: void Domain1D::setID(const string&)
        try {
            Domain1DCabinet::at(handle)->setID(s);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_grid(int32_t handle, int32_t bufLen, double* buf)
    {
        // array getter: vector<double>& Domain1D::grid()
        try {
            auto& obj = Domain1DCabinet::at(handle);
            // no size checking specified
            vector<double>& out = obj->grid();
            std::copy(out.begin(), out.end(), buf);
            return int(out.size());
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t bdry_setMdot(int32_t handle, double mdot)
    {
        // setter: virtual void Boundary1D::setMdot(double)
        try {
            Domain1DCabinet::as<Boundary1D>(handle)->setMdot(mdot);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t bdry_setTemperature(int32_t handle, double t)
    {
        // setter: virtual void Boundary1D::setTemperature(double)
        try {
            Domain1DCabinet::as<Boundary1D>(handle)->setTemperature(t);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t bdry_setSpreadRate(int32_t handle, double V0)
    {
        // setter: virtual void Boundary1D::setSpreadRate(double)
        try {
            Domain1DCabinet::as<Boundary1D>(handle)->setSpreadRate(V0);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t bdry_setMoleFractionsByName(int32_t handle, const char* xin)
    {
        // setter: virtual void Boundary1D::setMoleFractions(const string&)
        try {
            Domain1DCabinet::as<Boundary1D>(handle)->setMoleFractions(xin);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t bdry_setMoleFractions(int32_t handle, int32_t xinLen, const double* xin)
    {
        // array setter: virtual void Boundary1D::setMoleFractions(const double*)
        try {
            auto obj = Domain1DCabinet::as<Boundary1D>(handle);
            // no size checking specified
            obj->setMoleFractions(xin);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double bdry_mdot(int32_t handle)
    {
        // getter: virtual double Boundary1D::mdot()
        try {
            return Domain1DCabinet::as<Boundary1D>(handle)->mdot();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double bdry_temperature(int32_t handle)
    {
        // getter: virtual double Boundary1D::temperature()
        try {
            return Domain1DCabinet::as<Boundary1D>(handle)->temperature();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double bdry_spreadRate(int32_t handle)
    {
        // getter: virtual double Boundary1D::spreadRate()
        try {
            return Domain1DCabinet::as<Boundary1D>(handle)->spreadRate();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double bdry_massFraction(int32_t handle, int32_t k)
    {
        // method: virtual double Boundary1D::massFraction(size_t)
        try {
            return Domain1DCabinet::as<Boundary1D>(handle)->massFraction(k);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t domain_setTransport(int32_t handle, int32_t trans)
    {
        // setter: virtual void Domain1D::setTransport(shared_ptr<Transport>)
        try {
            Domain1DCabinet::at(handle)->setTransport(TransportCabinet::at(trans));
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_transportModel(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string Flow1D::transportModel()
        try {
            string out = Domain1DCabinet::as<Flow1D>(handle)->transportModel();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setTransportModel(int32_t handle, const char* model)
    {
        // setter: virtual void Domain1D::setTransportModel(const string&)
        try {
            Domain1DCabinet::at(handle)->setTransportModel(model);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_enableSoret(int32_t handle, int32_t withSoret)
    {
        // setter: void Flow1D::enableSoret(bool)
        try {
            bool withSoret_ = (withSoret != 0);
            Domain1DCabinet::as<Flow1D>(handle)->enableSoret(withSoret_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_setPressure(int32_t handle, double p)
    {
        // setter: void Flow1D::setPressure(double)
        try {
            Domain1DCabinet::as<Flow1D>(handle)->setPressure(p);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double flow_pressure(int32_t handle)
    {
        // getter: double Flow1D::pressure()
        try {
            return Domain1DCabinet::as<Flow1D>(handle)->pressure();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t flow_setFixedTempProfile(int32_t handle, int32_t zfixedLen, const double* zfixed, int32_t tfixedLen, const double* tfixed)
    {
        // method: void Flow1D::setFixedTempProfile(const vector<double>&, const vector<double>&)
        try {
            const vector<double> zfixed_(zfixed, zfixed + zfixedLen);
            const vector<double> tfixed_(tfixed, tfixed + tfixedLen);
            Domain1DCabinet::as<Flow1D>(handle)->setFixedTempProfile(zfixed_, tfixed_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_solveEnergyEqn(int32_t handle, int32_t j)
    {
        // setter: void Flow1D::solveEnergyEqn(size_t)
        try {
            Domain1DCabinet::as<Flow1D>(handle)->solveEnergyEqn(j);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_allOfEnergyEnabled(int32_t handle)
    {
        // getter: bool Flow1D::allOfEnergyEnabled()
        try {
            bool out = Domain1DCabinet::as<Flow1D>(handle)->allOfEnergyEnabled();
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_noneOfEnergyEnabled(int32_t handle)
    {
        // getter: bool Flow1D::noneOfEnergyEnabled()
        try {
            bool out = Domain1DCabinet::as<Flow1D>(handle)->noneOfEnergyEnabled();
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t flow_setEnergyEnabled(int32_t handle, int32_t flag)
    {
        // setter: void Flow1D::setEnergyEnabled(bool)
        try {
            bool flag_ = (flag != 0);
            Domain1DCabinet::as<Flow1D>(handle)->setEnergyEnabled(flag_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t reactingsurf_enableCoverageEquations(int32_t handle, int32_t docov)
    {
        // setter: void ReactingSurf1D::enableCoverageEquations(bool)
        try {
            bool docov_ = (docov != 0);
            Domain1DCabinet::as<ReactingSurf1D>(handle)->enableCoverageEquations(docov_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_getRefineCriteria(int32_t handle, int32_t bufLen, double* buf)
    {
        // array getter: vector<double> Domain1D::getRefineCriteria()
        try {
            auto& obj = Domain1DCabinet::at(handle);
            // no size checking specified
            vector<double> out = obj->getRefineCriteria();
            std::copy(out.begin(), out.end(), buf);
            return int(out.size());
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_setRefineCriteria(int32_t handle, double ratio, double slope, double curve, double prune)
    {
        // method: void Domain1D::setRefineCriteria(double, double, double, double)
        try {
            Domain1DCabinet::at(handle)->setRefineCriteria(ratio, slope, curve, prune);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_info(int32_t handle, int32_t rows, int32_t width, int32_t bufLen, char* buf)
    {
        // method: string Domain1D::_info(int, int)
        try {
            string out = Domain1DCabinet::at(handle)->_info(rows, width);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_del(int32_t handle)
    {
        // destructor
        try {
            Domain1DCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t domain_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return Domain1DCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"