cantera/Cantera/clib/src/ctmultiphase.cpp

/**
 * @file ctmultiphase.cpp
 */
#define CANTERA_USE_INTERNAL
#include "ctmultiphase.h"

// Cantera includes
#include "kernel/equil.h"
#include "kernel/MultiPhase.h"
#include "kernel/MultiPhaseEquil.h"
#include "kernel/vcs_MultiPhaseEquil.h"

#include "Cabinet.h"
#include "Storage.h"

using namespace std;
using namespace Cantera;

typedef MultiPhase  mix_t;

template<> Cabinet<mix_t>*    Cabinet<mix_t>::__storage = 0;

inline mix_t* _mix(int i) {
    return Cabinet<mix_t>::cabinet()->item(i);
}

inline ThermoPhase* _th(int n) {
    return Storage::__storage->__thtable[n];
}

static bool checkSpecies(int i, size_t k) {
    try {
        if (k >= _mix(i)->nSpecies())
            throw CanteraError("checkSpecies",
                "illegal species index ("+int2str(int(k))+") ");
        return true;
    }
    catch (CanteraError) {
        return false;
    }
}

static bool checkElement(int i, size_t m) {
    try {
        if (m >= _mix(i)->nElements())
            throw CanteraError("checkElement",
                "illegal element index ("+int2str(int(m))+") ");
        return true;
    }
    catch (CanteraError) {
        return false;
    }
}

static bool checkPhase(int i, int n) {
    try {
        if (n < 0 || n >= int(_mix(i)->nPhases())) 
            throw CanteraError("checkPhase",
                "illegal phase index ("+int2str(n)+") ");
        return true;
    }
    catch (CanteraError) {
        return false;
    }
}

namespace Cantera {
    int _equilflag(const char* xy);
}

extern "C" {  

    int DLL_EXPORT mix_new() {
        mix_t* m = new MultiPhase;
        return Cabinet<mix_t>::cabinet()->add(m);
    }

    int DLL_EXPORT mix_del(int i) {
        Cabinet<mix_t>::cabinet()->del(i);
        return 0;
    }

    int DLL_EXPORT mix_copy(int i) {
        return Cabinet<mix_t>::cabinet()->newCopy(i);
    }

    int DLL_EXPORT mix_assign(int i, int j) {
        return Cabinet<mix_t>::cabinet()->assign(i,j);
    }

    int DLL_EXPORT mix_addPhase(int i, int j, double moles) {
        _mix(i)->addPhase(_th(j), moles);
        return 0;
    }

    int DLL_EXPORT mix_init(int i) {
        _mix(i)->init();
        return 0;
    }

    size_t DLL_EXPORT mix_nElements(int i) {
        return _mix(i)->nElements();
     }

    size_t DLL_EXPORT mix_elementIndex(int i, char* name) {
        return _mix(i)->elementIndex(string(name));
    }

    size_t DLL_EXPORT mix_nSpecies(int i) {
        return _mix(i)->nSpecies();
    }

    size_t DLL_EXPORT mix_speciesIndex(int i, int k, int p) {
        return _mix(i)->speciesIndex(k, p);
    }

    doublereal DLL_EXPORT mix_nAtoms(int i, int k, int m) {
        bool ok = (checkSpecies(i,k) && checkElement(i,m));
        if (ok) 
            return _mix(i)->nAtoms(k,m);
        else
            return DERR;
    }

    size_t DLL_EXPORT mix_nPhases(int i) {
        return _mix(i)->nPhases();
    }

    doublereal DLL_EXPORT mix_phaseMoles(int i, int n) {
        if (!checkPhase(i, n)) return DERR;
        return _mix(i)->phaseMoles(n);
    }

    int DLL_EXPORT mix_setPhaseMoles(int i, int n, double v) {
        if (!checkPhase(i, n)) return ERR;
        if (v < 0.0) return -1;
        _mix(i)->setPhaseMoles(n, v);
        return 0;
    }

    int DLL_EXPORT mix_setMoles(int i, size_t nlen, double* n) {
        try {
            if (nlen < _mix(i)->nSpecies()) 
                throw CanteraError("setMoles","array size too small.");
            _mix(i)->setMoles(n);
            return 0;
        }
        catch (CanteraError) {
            return ERR;
        }
    }


    int DLL_EXPORT mix_setMolesByName(int i, char* n) {
        try {
            _mix(i)->setMolesByName(string(n));
            return 0;
        }
        catch (CanteraError) { return -1; }
    }

    int DLL_EXPORT mix_setTemperature(int i, double t) {
        if (t < 0.0) return -1;
        _mix(i)->setTemperature(t);
        return 0;
    }

    doublereal DLL_EXPORT mix_temperature(int i) {
        return _mix(i)->temperature();
    }

    doublereal DLL_EXPORT mix_minTemp(int i) {
        return _mix(i)->minTemp();
    }

    doublereal DLL_EXPORT mix_maxTemp(int i) {
        return _mix(i)->maxTemp();
    }

    doublereal DLL_EXPORT mix_charge(int i) {
        return _mix(i)->charge();
    }

    doublereal DLL_EXPORT mix_phaseCharge(int i, int p) {
        if (!checkPhase(i,p)) return DERR;
        return _mix(i)->phaseCharge(p);
    }

    int DLL_EXPORT mix_setPressure(int i, double p) {
        if (p < 0.0) return -1;
        _mix(i)->setPressure(p);
        return 0;
    }

    doublereal DLL_EXPORT mix_pressure(int i) {
        return _mix(i)->pressure();
    }

    doublereal DLL_EXPORT mix_speciesMoles(int i, int k) {
        if (!checkSpecies(i,k)) return DERR;
        return _mix(i)->speciesMoles(k);
    }

    doublereal DLL_EXPORT mix_elementMoles(int i, int m) {
        if (!checkElement(i,m)) return DERR;
        return _mix(i)->elementMoles(m);
    }

    
  doublereal DLL_EXPORT mix_equilibrate(int i, char* XY,
					doublereal rtol, int maxsteps, 
					int maxiter, int loglevel) { 
    try {
      return equilibrate(*_mix(i), XY, 
			 rtol, maxsteps, maxiter, loglevel);
    }
    catch (CanteraError) {
      return DERR;
    }
  }


  doublereal DLL_EXPORT mix_vcs_equilibrate(int i, char* XY, int estimateEquil,
					    int printLvl, int solver,
					    doublereal rtol, int maxsteps,
					    int maxiter, int loglevel) { 
    try {
#ifdef WITH_VCSNONIDEAL
      int retn = vcs_equilibrate(*_mix(i), XY, estimateEquil, printLvl, solver,
				 rtol, maxsteps, maxiter, loglevel);
#else
      int retn = -1;
      throw CanteraError("mix_vcs_equilibrate", 
      "The VCS NonIdeal equilibrium solver isn't compiled in\n"
      " To use this feature add export WITH_VCS_NONIDEAL='y' to the preconfig file");
#endif
      return (double) retn;
    }
    catch (CanteraError) {
      return DERR;
    }
  }

    int DLL_EXPORT mix_getChemPotentials(int i, size_t lenmu, double* mu) {
        try {
            if (lenmu < _mix(i)->nSpecies()) 
                throw CanteraError("getChemPotentials","array too small");
            _mix(i)->getChemPotentials(mu);
            return 0;
        }
        catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT mix_getValidChemPotentials(int i, double bad_mu, 
        int standard, size_t lenmu, double* mu) {
        bool st = (standard == 1);
        try {
            if (lenmu < _mix(i)->nSpecies()) 
                throw CanteraError("getChemPotentials","array too small");
            _mix(i)->getValidChemPotentials(bad_mu, mu, st);
            return 0;
        }
        catch (CanteraError) {
            return -1;
        }
    }

    double DLL_EXPORT mix_enthalpy(int i)  {
        return _mix(i)->enthalpy();
    }

    double DLL_EXPORT mix_entropy(int i)  {
        return _mix(i)->entropy();
    }
        

    double DLL_EXPORT mix_gibbs(int i) {
        return _mix(i)->gibbs();
    }

    double DLL_EXPORT mix_cp(int i) {
        return _mix(i)->cp();
    }

    double DLL_EXPORT mix_volume(int i) {
        return _mix(i)->volume();
    }

    size_t DLL_EXPORT mix_speciesPhaseIndex(int i, int k) {
        return _mix(i)->speciesPhaseIndex(k);
    }

    double DLL_EXPORT mix_moleFraction(int i, int k) {
        return _mix(i)->moleFraction(k);
    }

}