294 lines
7 KiB
C++
Executable file
294 lines
7 KiB
C++
Executable file
/**
|
|
* @file ctthermo.cpp
|
|
* Cantera Python Interface
|
|
*
|
|
*/
|
|
|
|
// turn off warnings about long names under Windows
|
|
#ifdef WIN32
|
|
#pragma warning(disable:4786)
|
|
#pragma warning(disable:4503)
|
|
#endif
|
|
|
|
#include "Python.h"
|
|
#include "Numeric/arrayobject.h"
|
|
#include "ct.h"
|
|
#include <string>
|
|
//#include <vector>
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
|
|
// constants defined in the module
|
|
static PyObject *ErrorObject;
|
|
|
|
// local includes
|
|
#include "pyutils.h"
|
|
|
|
static PyObject *
|
|
ct_newThermoFromXML(PyObject *self, PyObject *args)
|
|
{
|
|
int mxml;
|
|
//char* id;
|
|
if (!PyArg_ParseTuple(args, "i:ct_newThermoFromXML", &mxml))
|
|
return NULL;
|
|
int n = newThermoFromXML(mxml);
|
|
if (n < 0) return reportCanteraError();
|
|
//int p = th_phase(n);
|
|
return Py_BuildValue("i",n);
|
|
}
|
|
|
|
static PyObject*
|
|
thermo_delete(PyObject *self, PyObject *args)
|
|
{
|
|
int th;
|
|
if (!PyArg_ParseTuple(args, "i:thermo_delete", &th))
|
|
return NULL;
|
|
delThermo(th);
|
|
return Py_BuildValue("i",0);
|
|
}
|
|
|
|
static PyObject*
|
|
thermo_index(PyObject *self, PyObject *args) {
|
|
char* id;
|
|
if (!PyArg_ParseTuple(args, "s:index", &id)) return NULL;
|
|
return Py_BuildValue("i",th_thermoIndex(id));
|
|
}
|
|
|
|
static PyObject*
|
|
thermo_refpressure(PyObject *self, PyObject *args) {
|
|
int th;
|
|
if (!PyArg_ParseTuple(args, "i:refpressure", &th)) return NULL;
|
|
return Py_BuildValue("d",th_refPressure(th));
|
|
}
|
|
|
|
static PyObject*
|
|
thermo_mintemp(PyObject *self, PyObject *args) {
|
|
int th, k;
|
|
if (!PyArg_ParseTuple(args, "ii:mintemp", &th, &k)) return NULL;
|
|
return Py_BuildValue("d",th_minTemp(th,k));
|
|
}
|
|
|
|
static PyObject*
|
|
thermo_maxtemp(PyObject *self, PyObject *args) {
|
|
int th, k;
|
|
if (!PyArg_ParseTuple(args, "ii:maxtemp", &th, &k)) return NULL;
|
|
return Py_BuildValue("d",th_maxTemp(th,k));
|
|
}
|
|
|
|
// static PyObject*
|
|
// thermo_geteos(PyObject *self, PyObject *args) {
|
|
// char *fname, *id;
|
|
// if (!PyArg_ParseTuple(args, "ss:geteos", &fname, &id)) return NULL;
|
|
// return Py_BuildValue("i",get_eos(fname, id));
|
|
// }
|
|
|
|
static PyObject*
|
|
thermo_import(PyObject *self, PyObject *args) {
|
|
int n, mxml;
|
|
char* id;
|
|
if (!PyArg_ParseTuple(args, "iis:import", &n, &mxml, &id)) return NULL;
|
|
int iok = import_phase(n, mxml, id);
|
|
if (iok < 0) return reportError(iok);
|
|
return Py_BuildValue("i",0);
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
thermo_getfp(PyObject *self, PyObject *args)
|
|
{
|
|
double vv;
|
|
bool ok = true;
|
|
int th;
|
|
int job;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii:thermo_getfp", &th, &job))
|
|
return NULL;
|
|
|
|
// floating-point attributes
|
|
switch (job) {
|
|
case 1:
|
|
vv = th_enthalpy_mole(th); break;
|
|
case 2:
|
|
vv = th_intEnergy_mole(th); break;
|
|
case 3:
|
|
vv = th_entropy_mole(th); break;
|
|
case 4:
|
|
vv = th_gibbs_mole(th); break;
|
|
case 5:
|
|
vv = th_cp_mole(th); break;
|
|
case 6:
|
|
vv = th_cv_mole(th); break;
|
|
case 7:
|
|
vv = th_pressure(th); break;
|
|
case 8:
|
|
vv = th_enthalpy_mass(th); break;
|
|
case 9:
|
|
vv = th_intEnergy_mass(th); break;
|
|
case 10:
|
|
vv = th_entropy_mass(th); break;
|
|
case 11:
|
|
vv = th_gibbs_mass(th); break;
|
|
case 12:
|
|
vv = th_cp_mass(th); break;
|
|
case 13:
|
|
vv = th_cv_mass(th); break;
|
|
default:
|
|
ok = false;
|
|
}
|
|
if (ok) {
|
|
if (vv == -999.999) {
|
|
return reportCanteraError();
|
|
}
|
|
return Py_BuildValue("d",vv);
|
|
}
|
|
else {
|
|
PyErr_SetString(ErrorObject,"Unknown floating-point attribute");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static PyObject*
|
|
thermo_setfp(PyObject *self, PyObject *args)
|
|
{
|
|
double v1, v2;
|
|
int iok = -2;
|
|
int th;
|
|
int job;
|
|
|
|
if (!PyArg_ParseTuple(args, "iidd:thermo_setfp", &th, &job, &v1, &v2))
|
|
return NULL;
|
|
|
|
//vector_fp v(2);
|
|
double* v = new double[2];
|
|
v[0] = v1; v[1] = v2;
|
|
|
|
// set floating-point attributes
|
|
switch (job) {
|
|
case 1:
|
|
iok = th_setPressure(th, v1); break;
|
|
case 2:
|
|
iok = th_set_HP(th, v); break;
|
|
case 3:
|
|
iok = th_set_UV(th, v); break;
|
|
case 4:
|
|
iok = th_set_SV(th, v); break;
|
|
case 5:
|
|
iok = th_set_SP(th, v); break;
|
|
default:
|
|
iok = -10;
|
|
}
|
|
delete v;
|
|
if (iok >= 0)
|
|
return Py_BuildValue("i",iok);
|
|
if (iok == -1) return reportCanteraError();
|
|
else {
|
|
PyErr_SetString(ErrorObject,"Error in thermo_setfp");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
thermo_getarray(PyObject *self, PyObject *args)
|
|
{
|
|
int th;
|
|
int job;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii:thermo_getarray", &th, &job))
|
|
return NULL;
|
|
|
|
int nsp = th_nSpecies(th);
|
|
|
|
// array attributes
|
|
int iok = -22;
|
|
PyArrayObject* x =
|
|
(PyArrayObject*)PyArray_FromDims(1, &nsp, PyArray_DOUBLE);
|
|
double* xd = (double*)x->data;
|
|
switch (job) {
|
|
case 20:
|
|
iok = th_chemPotentials(th,nsp,xd);
|
|
break;
|
|
case 23:
|
|
iok = th_getEnthalpies_RT(th,nsp,xd);
|
|
break;
|
|
case 24:
|
|
iok = th_getEntropies_R(th,nsp,xd);
|
|
break;
|
|
case 25:
|
|
iok = th_getCp_R(th,nsp,xd);
|
|
break;
|
|
|
|
default:
|
|
;
|
|
}
|
|
if (iok >= 0) {
|
|
return PyArray_Return(x);
|
|
}
|
|
else {
|
|
PyErr_SetString(ErrorObject,"Unknown array attribute");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
thermo_equil(PyObject *self, PyObject *args)
|
|
{
|
|
int iok = -2;
|
|
int th;
|
|
int XY;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii:thermo_equil", &th, &XY))
|
|
return NULL;
|
|
|
|
iok = th_equil(th, XY);
|
|
if (iok >= 0)
|
|
return Py_BuildValue("i",iok);
|
|
if (iok == -1) return reportCanteraError();
|
|
else {
|
|
PyErr_SetString(ErrorObject,"Error in thermo_equil");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* List of functions defined in the module */
|
|
|
|
static PyMethodDef ct_methods[] = {
|
|
{"ThermoFromXML", ct_newThermoFromXML, METH_VARARGS},
|
|
{"delete", thermo_delete, METH_VARARGS},
|
|
{"mintemp", thermo_mintemp, METH_VARARGS},
|
|
{"maxtemp", thermo_maxtemp, METH_VARARGS},
|
|
{"thermoIndex", thermo_index, METH_VARARGS},
|
|
{"refpressure", thermo_refpressure, METH_VARARGS},
|
|
{"getfp", thermo_getfp, METH_VARARGS},
|
|
{"setfp", thermo_setfp, METH_VARARGS},
|
|
{"getarray", thermo_getarray, METH_VARARGS},
|
|
{"equil", thermo_equil, METH_VARARGS},
|
|
{"import_xml", thermo_import, METH_VARARGS},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
extern "C" {
|
|
|
|
/* Initialization function for the module (*must* be called initctthermo) */
|
|
|
|
DL_EXPORT(void) initctthermo(void)
|
|
{
|
|
PyObject *m, *d;
|
|
|
|
/* Initialize the type of the new type object here; doing it here
|
|
* is required for portability to Windows without requiring C++. */
|
|
|
|
/* Create the module and add the functions */
|
|
m = Py_InitModule("ctthermo", ct_methods);
|
|
import_array();
|
|
|
|
/* Add some symbolic constants to the module */
|
|
d = PyModule_GetDict(m);
|
|
ErrorObject = PyErr_NewException("cantera.error", NULL, NULL);
|
|
PyDict_SetItemString(d, "error", ErrorObject);
|
|
}
|
|
|
|
}
|