ct.cpp

Go to the documentation of this file.

/**
 *  CT - Generated CLib %Cantera interface library.
 *
 *  @file ct.cpp
 *
 *  The main library of the generated CLib API contains Cantera service functions.
 *
 *  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/ct.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/base/global.h"
#include "cantera/base/ExternalLogger.h"
#include "cantera/zeroD/ConnectorFactory.h"
#include "cantera/zeroD/flowControllers.h"
#include "cantera/zeroD/Wall.h"
#include "cantera/oneD/DomainFactory.h"
#include "cantera/numerics/Func1Factory.h"
#include "cantera/kinetics/KineticsFactory.h"
#include "cantera/kinetics/InterfaceKinetics.h"
#include "cantera/equil/MultiPhase.h"
#include "cantera/thermo/ThermoPhase.h"
#include "cantera/oneD/Sim1D.h"
#include "cantera/kinetics/ReactionPath.h"
#include "cantera/zeroD/ReactorFactory.h"
#include "cantera/zeroD/FlowReactor.h"
#include "cantera/zeroD/ReactorNet.h"
#include "cantera/kinetics/Reaction.h"
#include "cantera/base/Solution.h"
#include "cantera/thermo/ThermoFactory.h"
#include "cantera/thermo/SurfPhase.h"
#include "cantera/transport/TransportFactory.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
typedef Cabinet<ConnectorNode> ConnectorNodeCabinet;
template<> ConnectorNodeCabinet* ConnectorNodeCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Domain1D> Domain1DCabinet;
template<> Domain1DCabinet* Domain1DCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Func1> Func1Cabinet;
template<> Func1Cabinet* Func1Cabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Kinetics> KineticsCabinet;
template<> KineticsCabinet* KineticsCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<MultiPhase> MultiPhaseCabinet;
template<> MultiPhaseCabinet* MultiPhaseCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Sim1D> Sim1DCabinet;
template<> Sim1DCabinet* Sim1DCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ReactionPathDiagram> ReactionPathDiagramCabinet;
template<> ReactionPathDiagramCabinet* ReactionPathDiagramCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ReactorBase> ReactorBaseCabinet;
template<> ReactorBaseCabinet* ReactorBaseCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ReactorNet> ReactorNetCabinet;
template<> ReactorNetCabinet* ReactorNetCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Reaction> ReactionCabinet;
template<> ReactionCabinet* ReactionCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Solution> SolutionCabinet;
template<> SolutionCabinet* SolutionCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<ThermoPhase> ThermoPhaseCabinet;
template<> ThermoPhaseCabinet* ThermoPhaseCabinet::s_storage;  // initialized elsewhere
 
typedef Cabinet<Transport> TransportCabinet;
template<> TransportCabinet* TransportCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t ct_version(int32_t bufLen, char* buf)
    {
        // function: string version()
        try {
            string out = version();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_gitCommit(int32_t bufLen, char* buf)
    {
        // function: string gitCommit()
        try {
            string out = gitCommit();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_addDataDirectory(const char* dir)
    {
        // function: void addDirectory(const string&)
        try {
            addDirectory(dir);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_getDataDirectories(const char* sep, int32_t bufLen, char* buf)
    {
        // function: string getDataDirectories(const string&)
        try {
            string out = getDataDirectories(sep);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_findInputFile(const char* name, int32_t bufLen, char* buf)
    {
        // function: string findInputFile(const string&)
        try {
            string out = findInputFile(name);
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_suppress_deprecation_warnings()
    {
        // function: void suppress_deprecation_warnings()
        try {
            suppress_deprecation_warnings();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_make_deprecation_warnings_fatal()
    {
        // function: void make_deprecation_warnings_fatal()
        try {
            make_deprecation_warnings_fatal();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_suppress_warnings()
    {
        // function: void suppress_warnings()
        try {
            suppress_warnings();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_warnings_suppressed()
    {
        // function: bool warnings_suppressed()
        try {
            bool out = warnings_suppressed();
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_make_warnings_fatal()
    {
        // function: void make_warnings_fatal()
        try {
            make_warnings_fatal();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_suppress_thermo_warnings(int32_t suppress)
    {
        // function: void suppress_thermo_warnings(bool)
        try {
            bool suppress_ = (suppress != 0);
            suppress_thermo_warnings(suppress_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_use_legacy_rate_constants(int32_t legacy)
    {
        // function: void use_legacy_rate_constants(bool)
        try {
            bool legacy_ = (legacy != 0);
            use_legacy_rate_constants(legacy_);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_appdelete()
    {
        // function: void appdelete()
        try {
            appdelete();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    const double ct_Avogadro()
    {
        // variable (getter): variable getter: Avogadro
        try {
            return Avogadro;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_Boltzmann()
    {
        // variable (getter): variable getter: Boltzmann
        try {
            return Boltzmann;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_Planck()
    {
        // variable (getter): variable getter: Planck
        try {
            return Planck;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_ElectronCharge()
    {
        // variable (getter): variable getter: ElectronCharge
        try {
            return ElectronCharge;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_lightSpeed()
    {
        // variable (getter): variable getter: lightSpeed
        try {
            return lightSpeed;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_OneAtm()
    {
        // variable (getter): variable getter: OneAtm
        try {
            return OneAtm;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_OneBar()
    {
        // variable (getter): variable getter: OneBar
        try {
            return OneBar;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_fineStructureConstant()
    {
        // variable (getter): variable getter: fineStructureConstant
        try {
            return fineStructureConstant;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_ElectronMass()
    {
        // variable (getter): variable getter: ElectronMass
        try {
            return ElectronMass;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_GasConstant()
    {
        // variable (getter): variable getter: GasConstant
        try {
            return GasConstant;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_StefanBoltz()
    {
        // variable (getter): variable getter: StefanBoltz
        try {
            return StefanBoltz;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_Faraday()
    {
        // variable (getter): variable getter: Faraday
        try {
            return Faraday;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_permeability_0()
    {
        // variable (getter): variable getter: permeability_0
        try {
            return permeability_0;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    const double ct_epsilon_0()
    {
        // variable (getter): variable getter: epsilon_0
        try {
            return epsilon_0;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t ct_getCanteraError(int32_t bufLen, char* buf)
    {
        // function: custom code
        try {
            // *************** begin custom code ***************
            string err = Application::Instance()->lastErrorMessage();
            copyString(err, buf, bufLen);
            return static_cast<int32_t>(err.size());
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_setLogCallback(LogCallback writer)
    {
        // function: custom code
        try {
            // *************** begin custom code ***************
            auto logwriter = make_unique<ExternalLogger>(writer);
            setLogger(std::move(logwriter));
            return 0;
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_writeLog(const char* msg)
    {
        // function: void writelog_direct(const string&)
        try {
            writelog_direct(msg);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_clearStorage()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            ConnectorNodeCabinet::clear();
            Domain1DCabinet::clear();
            Func1Cabinet::clear();
            KineticsCabinet::clear();
            MultiPhaseCabinet::clear();
            Sim1DCabinet::clear();
            ReactionPathDiagramCabinet::clear();
            ReactorBaseCabinet::clear();
            ReactorNetCabinet::clear();
            ReactionCabinet::clear();
            SolutionCabinet::clear();
            ThermoPhaseCabinet::clear();
            TransportCabinet::clear();
            return 0;
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t ct_resetStorage()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            ConnectorNodeCabinet::reset();
            Domain1DCabinet::reset();
            Func1Cabinet::reset();
            KineticsCabinet::reset();
            MultiPhaseCabinet::reset();
            Sim1DCabinet::reset();
            ReactionPathDiagramCabinet::reset();
            ReactorBaseCabinet::reset();
            ReactorNetCabinet::reset();
            ReactionCabinet::reset();
            SolutionCabinet::reset();
            ThermoPhaseCabinet::reset();
            TransportCabinet::reset();
            return 0;
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"