ctmix.cpp

Go to the documentation of this file.

/**
 *  CTMIX - Generated CLib %Cantera interface library.
 *
 *  @file ctmix.cpp
 *
 *  Generated CLib API for Cantera's MultiPhase 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/ctmix.h"
 
#include "cantera/equil/MultiPhase.h"
#include "cantera/thermo/ThermoPhase.h"
#include "cantera/thermo/ThermoFactory.h"
#include "cantera/thermo/SurfPhase.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<MultiPhase> (single-instance object)
typedef Cabinet<MultiPhase> MultiPhaseCabinet;
template<> MultiPhaseCabinet* MultiPhaseCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<ThermoPhase> ThermoPhaseCabinet;
template<> ThermoPhaseCabinet* ThermoPhaseCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t mix_new()
    {
        // constructor: default constructor for MultiPhase
        try {
            return MultiPhaseCabinet::add(make_shared<MultiPhase>());
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_addPhase(int32_t handle, int32_t p, double moles)
    {
        // method: void MultiPhase::addPhase(shared_ptr<ThermoPhase>, double)
        try {
            MultiPhaseCabinet::at(handle)->addPhase(ThermoPhaseCabinet::at(p), moles);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_init(int32_t handle)
    {
        // method: void MultiPhase::init()
        try {
            MultiPhaseCabinet::at(handle)->init();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_updatePhases(int32_t handle)
    {
        // method: void MultiPhase::updatePhases()
        try {
            MultiPhaseCabinet::at(handle)->updatePhases();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_nElements(int32_t handle)
    {
        // getter: size_t MultiPhase::nElements()
        try {
            return MultiPhaseCabinet::at(handle)->nElements();
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t mix_elementIndex(int32_t handle, const char* name)
    {
        // method: size_t MultiPhase::elementIndex(const string&)
        try {
            return MultiPhaseCabinet::at(handle)->elementIndex(name);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t mix_nSpecies(int32_t handle)
    {
        // getter: size_t MultiPhase::nSpecies()
        try {
            return MultiPhaseCabinet::at(handle)->nSpecies();
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t mix_speciesIndex(int32_t handle, int32_t k, int32_t p)
    {
        // method: size_t MultiPhase::speciesIndex(size_t, size_t)
        try {
            return MultiPhaseCabinet::at(handle)->speciesIndex(k, p);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double mix_temperature(int32_t handle)
    {
        // getter: double MultiPhase::temperature()
        try {
            return MultiPhaseCabinet::at(handle)->temperature();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_setTemperature(int32_t handle, const double T)
    {
        // setter: void MultiPhase::setTemperature(const double)
        try {
            MultiPhaseCabinet::at(handle)->setTemperature(T);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double mix_minTemp(int32_t handle)
    {
        // getter: double MultiPhase::minTemp()
        try {
            return MultiPhaseCabinet::at(handle)->minTemp();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_maxTemp(int32_t handle)
    {
        // getter: double MultiPhase::maxTemp()
        try {
            return MultiPhaseCabinet::at(handle)->maxTemp();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_charge(int32_t handle)
    {
        // getter: double MultiPhase::charge()
        try {
            return MultiPhaseCabinet::at(handle)->charge();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_phaseCharge(int32_t handle, int32_t p)
    {
        // method: double MultiPhase::phaseCharge(size_t)
        try {
            return MultiPhaseCabinet::at(handle)->phaseCharge(p);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_pressure(int32_t handle)
    {
        // getter: double MultiPhase::pressure()
        try {
            return MultiPhaseCabinet::at(handle)->pressure();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_setPressure(int32_t handle, double P)
    {
        // setter: void MultiPhase::setPressure(double)
        try {
            MultiPhaseCabinet::at(handle)->setPressure(P);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double mix_nAtoms(int32_t handle, const int32_t kGlob, const int32_t mGlob)
    {
        // method: double MultiPhase::nAtoms(const size_t, const size_t)
        try {
            return MultiPhaseCabinet::at(handle)->nAtoms(kGlob, mGlob);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_nPhases(int32_t handle)
    {
        // getter: size_t MultiPhase::nPhases()
        try {
            return MultiPhaseCabinet::at(handle)->nPhases();
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double mix_phaseMoles(int32_t handle, const int32_t n)
    {
        // method: double MultiPhase::phaseMoles(const size_t)
        try {
            return MultiPhaseCabinet::at(handle)->phaseMoles(n);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_setPhaseMoles(int32_t handle, const int32_t n, const double moles)
    {
        // method: void MultiPhase::setPhaseMoles(const size_t, const double)
        try {
            MultiPhaseCabinet::at(handle)->setPhaseMoles(n, moles);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_setMoles(int32_t handle, int32_t nLen, const double* n)
    {
        // setter: void MultiPhase::setMoles(const double*)
        try {
            auto& obj = MultiPhaseCabinet::at(handle);
            // no size checking specified
            obj->setMoles(n);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_setMolesByName(int32_t handle, const char* x)
    {
        // setter: void MultiPhase::setMolesByName(const string&)
        try {
            MultiPhaseCabinet::at(handle)->setMolesByName(x);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double mix_speciesMoles(int32_t handle, int32_t kGlob)
    {
        // method: double MultiPhase::speciesMoles(size_t)
        try {
            return MultiPhaseCabinet::at(handle)->speciesMoles(kGlob);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_elementMoles(int32_t handle, int32_t m)
    {
        // method: double MultiPhase::elementMoles(size_t)
        try {
            return MultiPhaseCabinet::at(handle)->elementMoles(m);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_equilibrate(int32_t handle, const char* XY, const char* solver, double rtol, int32_t max_steps, int32_t max_iter, int32_t estimate_equil)
    {
        // method: void MultiPhase::equilibrate(const string&, const string&, double, int, int, int)
        try {
            MultiPhaseCabinet::at(handle)->equilibrate(XY, solver, rtol, max_steps, max_iter, estimate_equil);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_getChemPotentials(int32_t handle, int32_t muLen, double* mu)
    {
        // getter: void MultiPhase::getChemPotentials(double*)
        try {
            auto& obj = MultiPhaseCabinet::at(handle);
            // no size checking specified
            obj->getChemPotentials(mu);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double mix_enthalpy(int32_t handle)
    {
        // getter: double MultiPhase::enthalpy()
        try {
            return MultiPhaseCabinet::at(handle)->enthalpy();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_entropy(int32_t handle)
    {
        // getter: double MultiPhase::entropy()
        try {
            return MultiPhaseCabinet::at(handle)->entropy();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_gibbs(int32_t handle)
    {
        // getter: double MultiPhase::gibbs()
        try {
            return MultiPhaseCabinet::at(handle)->gibbs();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_cp(int32_t handle)
    {
        // getter: double MultiPhase::cp()
        try {
            return MultiPhaseCabinet::at(handle)->cp();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    double mix_volume(int32_t handle)
    {
        // getter: double MultiPhase::volume()
        try {
            return MultiPhaseCabinet::at(handle)->volume();
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_speciesPhaseIndex(int32_t handle, const int32_t kGlob)
    {
        // method: size_t MultiPhase::speciesPhaseIndex(const size_t)
        try {
            return MultiPhaseCabinet::at(handle)->speciesPhaseIndex(kGlob);
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double mix_moleFraction(int32_t handle, const int32_t kGlob)
    {
        // method: double MultiPhase::moleFraction(const size_t)
        try {
            return MultiPhaseCabinet::at(handle)->moleFraction(kGlob);
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t mix_del(int32_t handle)
    {
        // destructor
        try {
            MultiPhaseCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return MultiPhaseCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t mix_parentHandle(int32_t handle)
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return MultiPhaseCabinet::parent(handle);
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"