ctonedim.cpp

Go to the documentation of this file.

/**
 *  CTONEDIM - Generated CLib %Cantera interface library.
 *
 *  @file ctonedim.cpp
 *
 *  Generated CLib API for Cantera's Sim1D 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/ctonedim.h"
 
#include "cantera/oneD/Sim1D.h"
#include "cantera/oneD/DomainFactory.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<Sim1D> (single-instance object)
typedef Cabinet<Sim1D> Sim1DCabinet;
template<> Sim1DCabinet* Sim1DCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<Domain1D> Domain1DCabinet;
template<> Domain1DCabinet* Domain1DCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t sim1D_newSim1D(int32_t domainsLen, int32_t* domains)
    {
        // constructor: shared_ptr<Sim1D> newSim1D(vector<shared_ptr<Domain1D>>&)
        try {
            vector<shared_ptr<Domain1D>> domains_;
            for (int i = 0; i < domainsLen; i++) {
                domains_.push_back(Domain1DCabinet::at(domains[i]));
            }
            return Sim1DCabinet::add(newSim1D(domains_));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sim1D_setValue(int32_t handle, int32_t dom, int32_t comp, int32_t localPoint, double value)
    {
        // method: void Sim1D::setValue(size_t, size_t, size_t, double)
        try {
            Sim1DCabinet::at(handle)->setValue(dom, comp, localPoint, value);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setProfile(int32_t handle, int32_t dom, int32_t comp, int32_t posLen, const double* pos, int32_t valuesLen, const double* values)
    {
        // method: void Sim1D::setProfile(size_t, size_t, const vector<double>&, const vector<double>&)
        try {
            const vector<double> pos_(pos, pos + posLen);
            const vector<double> values_(values, values + valuesLen);
            Sim1DCabinet::at(handle)->setProfile(dom, comp, pos_, values_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setFlatProfile(int32_t handle, int32_t dom, int32_t comp, double v)
    {
        // method: void Sim1D::setFlatProfile(size_t, size_t, double)
        try {
            Sim1DCabinet::at(handle)->setFlatProfile(dom, comp, v);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setInitialGuess(int32_t handle, const char* component, int32_t locsLen, double* locs, int32_t valsLen, double* vals)
    {
        // method: void Sim1D::setInitialGuess(const string&, vector<double>&, vector<double>&)
        try {
            vector<double> locs_(locs, locs + locsLen);
            vector<double> vals_(vals, vals + valsLen);
            Sim1DCabinet::at(handle)->setInitialGuess(component, locs_, vals_);
            std::copy(locs_.begin(), locs_.end(), locs);
            std::copy(vals_.begin(), vals_.end(), vals);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_show(int32_t handle)
    {
        // method: void Sim1D::show()
        try {
            Sim1DCabinet::at(handle)->show();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setTimeStep(int32_t handle, double stepSize, int32_t tStepsLen, const int32_t* tSteps)
    {
        // method: void SteadyStateSystem::setTimeStep(double, const vector<int>&)
        try {
            const vector<int> tSteps_(tSteps, tSteps + tStepsLen);
            Sim1DCabinet::as<SteadyStateSystem>(handle)->setTimeStep(stepSize, tSteps_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_getInitialSoln(int32_t handle)
    {
        // method: void Sim1D::getInitialSoln()
        try {
            Sim1DCabinet::at(handle)->getInitialSoln();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_solve(int32_t handle, int32_t loglevel, int32_t refine_grid)
    {
        // method: void Sim1D::solve(int, bool)
        try {
            bool refine_grid_ = (refine_grid != 0);
            Sim1DCabinet::at(handle)->solve(loglevel, refine_grid_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_refine(int32_t handle, int32_t loglevel)
    {
        // method: int Sim1D::refine(int)
        try {
            return Sim1DCabinet::at(handle)->refine(loglevel);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t sim1D_setRefineCriteria(int32_t handle, int32_t dom, double ratio, double slope, double curve, double prune)
    {
        // method: void Sim1D::setRefineCriteria(int, double, double, double, double)
        try {
            Sim1DCabinet::at(handle)->setRefineCriteria(dom, ratio, slope, curve, prune);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setGridMin(int32_t handle, int32_t dom, double gridmin)
    {
        // method: void Sim1D::setGridMin(int, double)
        try {
            Sim1DCabinet::at(handle)->setGridMin(dom, gridmin);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_save(int32_t handle, const char* fname, const char* name, const char* desc, int32_t overwrite)
    {
        // method: void Sim1D::save(const string&, const string&, const string&, bool)
        try {
            bool overwrite_ = (overwrite != 0);
            Sim1DCabinet::at(handle)->save(fname, name, desc, overwrite_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_restore(int32_t handle, const char* fname, const char* name)
    {
        // method: void Sim1D::_restore(const string&, const string&)
        try {
            Sim1DCabinet::at(handle)->_restore(fname, name);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_writeStats(int32_t handle, int32_t printTime)
    {
        // setter: void OneDim::writeStats(int)
        try {
            Sim1DCabinet::as<OneDim>(handle)->writeStats(printTime);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_domainIndex(int32_t handle, const char* name)
    {
        // size getter: size_t OneDim::domainIndex(const string&)
        try {
            return static_cast<int32_t>(Sim1DCabinet::as<OneDim>(handle)->domainIndex(name));
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double sim1D_value(int32_t handle, int32_t dom, int32_t comp, int32_t localPoint)
    {
        // method: double Sim1D::value(size_t, size_t, size_t)
        try {
            return Sim1DCabinet::at(handle)->value(dom, comp, localPoint);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double sim1D_workValue(int32_t handle, int32_t dom, int32_t comp, int32_t localPoint)
    {
        // method: double Sim1D::workValue(size_t, size_t, size_t)
        try {
            return Sim1DCabinet::at(handle)->workValue(dom, comp, localPoint);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t sim1D_eval(int32_t handle, int32_t xLen, double* x, int32_t rLen, double* r, double rdt, int32_t count)
    {
        // method: void Sim1D::eval(double*, double*, double, int)
        try {
            Sim1DCabinet::at(handle)->eval(x, r, rdt, count);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setMaxJacAge(int32_t handle, int32_t ss_age, int32_t ts_age)
    {
        // method: void SteadyStateSystem::setJacAge(int, int)
        try {
            Sim1DCabinet::as<SteadyStateSystem>(handle)->setJacAge(ss_age, ts_age);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_setFixedTemperature(int32_t handle, double t)
    {
        // method: int Sim1D::setFixedTemperature(double)
        try {
            return Sim1DCabinet::at(handle)->setFixedTemperature(t);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t sim1D_del(int32_t handle)
    {
        // destructor
        try {
            Sim1DCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sim1D_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return Sim1DCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"