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/Flow1D.h"
#include "cantera/oneD/Boundary1D.h"
#include "cantera/transport/TransportFactory.h"
#include "cantera/base/Solution.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<Flow1D> Flow1DCabinet;
template<> Flow1DCabinet* Flow1DCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Boundary1D> Boundary1DCabinet;
template<> Boundary1DCabinet* Boundary1DCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Transport> TransportCabinet;
template<> TransportCabinet* TransportCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Solution> SolutionCabinet;
template<> SolutionCabinet* SolutionCabinet::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_index(int32_t handle, int32_t n, int32_t j)
    {
        // method: size_t Domain1D::index(size_t, size_t)
        try {
            return Domain1DCabinet::at(handle)->index(n, j);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_nComponents(int32_t handle)
    {
        // getter: size_t Domain1D::nComponents()
        try {
            return Domain1DCabinet::at(handle)->nComponents();
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t domain_nPoints(int32_t handle)
    {
        // getter: size_t Domain1D::nPoints()
        try {
            return 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)
    {
        // method: virtual size_t Domain1D::componentIndex(const string&)
        try {
            return Domain1DCabinet::at(handle)->componentIndex(name);
        } catch (...) {
            return handleAllExceptions(ERR, 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)
    {
        // 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_setMoleFractions(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);
        }
    }
 
    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_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, double* zfixed, int32_t tfixedLen, double* tfixed)
    {
        // method: void Flow1D::setFixedTempProfile(vector<double>&, vector<double>&)
        try {
            vector<double> zfixed_(zfixed, zfixed + zfixedLen);
            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 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_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);
        }
    }
 
    int32_t domain_parentHandle(int32_t handle)
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return Domain1DCabinet::parent(handle);
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"