ctsol.cpp

Go to the documentation of this file.

/**
 *  CTSOL - Generated CLib %Cantera interface library.
 *
 *  @file ctsol.cpp
 *
 *  Generated CLib API for Cantera's Solution 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/ctsol.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/base/Solution.h"
#include "cantera/base/Interface.h"
#include "cantera/transport/TransportFactory.h"
#include "cantera/thermo/ThermoFactory.h"
#include "cantera/thermo/SurfPhase.h"
#include "cantera/kinetics/KineticsFactory.h"
#include "cantera/kinetics/InterfaceKinetics.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<Solution> (single-instance object)
typedef Cabinet<Solution> SolutionCabinet;
template<> SolutionCabinet* SolutionCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<Interface> InterfaceCabinet;
template<> InterfaceCabinet* InterfaceCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Transport> TransportCabinet;
template<> TransportCabinet* TransportCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ThermoPhase> ThermoPhaseCabinet;
template<> ThermoPhaseCabinet* ThermoPhaseCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Kinetics> KineticsCabinet;
template<> KineticsCabinet* KineticsCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t sol_newSolution(const char* infile, const char* name, const char* transport)
    {
        // constructor: shared_ptr<Solution> newSolution(const string&, const string&, const string&)
        try {
            auto obj = newSolution(infile, name, transport);
            int id = SolutionCabinet::add(obj);
            if (obj->thermo()) {
                ThermoPhaseCabinet::add(obj->thermo(), id);
            }
            if (obj->kinetics()) {
                KineticsCabinet::add(obj->kinetics(), id);
            }
            if (obj->transport()) {
                TransportCabinet::add(obj->transport(), id);
            }
            return id;
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sol_newInterface(const char* infile, const char* name, int32_t adjacentLen, const int32_t* adjacent)
    {
        // constructor: shared_ptr<Interface> newInterface(const string&, const string&, const vector<shared_ptr<Solution>>&)
        try {
            vector<shared_ptr<Solution>> adjacent_;
            for (int i = 0; i < adjacentLen; i++) {
                adjacent_.push_back(SolutionCabinet::at(adjacent[i]));
            }
            auto obj = newInterface(infile, name, adjacent_);
            int id = SolutionCabinet::add(obj);
            if (obj->thermo()) {
                ThermoPhaseCabinet::add(obj->thermo(), id);
            }
            if (obj->kinetics()) {
                KineticsCabinet::add(obj->kinetics(), id);
            }
            return id;
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sol_del(int32_t handle)
    {
        // destructor
        try {
            auto obj = SolutionCabinet::at(handle);
            // remove all associated objects in reversed order
            if (obj->transport()) {
                int index = TransportCabinet::index(*(obj->transport()), handle);
                if (index >= 0) {
                    TransportCabinet::del(index);
                }
            }
            if (obj->kinetics()) {
                int index = KineticsCabinet::index(*(obj->kinetics()), handle);
                if (index >= 0) {
                    KineticsCabinet::del(index);
                }
            }
            if (obj->thermo()) {
                int index = ThermoPhaseCabinet::index(*(obj->thermo()), handle);
                if (index >= 0) {
                    ThermoPhaseCabinet::del(index);
                }
            }
            SolutionCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_name(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string Solution::name()
        try {
            string out = SolutionCabinet::at(handle)->name();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_setName(int32_t handle, const char* name)
    {
        // setter: void Solution::setName(const string&)
        try {
            SolutionCabinet::at(handle)->setName(name);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_thermo(int32_t handle)
    {
        // getter: shared_ptr<ThermoPhase> Solution::thermo()
        try {
            auto obj = SolutionCabinet::at(handle)->thermo();
            return ThermoPhaseCabinet::index(*obj, handle);
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sol_kinetics(int32_t handle)
    {
        // getter: shared_ptr<Kinetics> Solution::kinetics()
        try {
            auto obj = SolutionCabinet::at(handle)->kinetics();
            return KineticsCabinet::index(*obj, handle);
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sol_transport(int32_t handle)
    {
        // getter: shared_ptr<Transport> Solution::transport()
        try {
            auto obj = SolutionCabinet::at(handle)->transport();
            return TransportCabinet::index(*obj, handle);
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sol_transportModel(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string Solution::transportModel()
        try {
            string out = SolutionCabinet::at(handle)->transportModel();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_setTransportModel(int32_t handle, const char* model)
    {
        // accessor: void Solution::setTransportModel(const string&)
        try {
            auto obj = SolutionCabinet::at(handle);
            if (obj->transport()) {
                TransportCabinet::del(
                    TransportCabinet::index(*(obj->transport()), handle));
            }
            obj->setTransportModel(model);
            return TransportCabinet::add(obj->transport(), handle);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_nAdjacent(int32_t handle)
    {
        // getter: size_t Solution::nAdjacent()
        try {
            return SolutionCabinet::at(handle)->nAdjacent();
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t sol_adjacent(int32_t handle, int32_t i)
    {
        // accessor: shared_ptr<Solution> Solution::adjacent(size_t)
        try {
            if (i < 0 || i >= SolutionCabinet::at(handle)->nAdjacent()) {
                throw IndexError("sol_adjacent", "", i, SolutionCabinet::at(handle)->nAdjacent());
            }
            auto obj = SolutionCabinet::at(handle)->adjacent(i);
            int id = SolutionCabinet::add(obj);
            if (obj->thermo()) {
                ThermoPhaseCabinet::add(obj->thermo(), id);
            }
            if (obj->kinetics()) {
                KineticsCabinet::add(obj->kinetics(), id);
            }
            if (obj->transport()) {
                TransportCabinet::add(obj->transport(), id);
            }
            return id;
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t sol_adjacentName(int32_t handle, int32_t i, int32_t bufLen, char* buf)
    {
        // method: string Solution::adjacentName(size_t)
        try {
            string out = SolutionCabinet::at(handle)->adjacentName(i);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_source(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: const string Solution::source()
        try {
            string out = SolutionCabinet::at(handle)->source();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t sol_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return SolutionCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"