330 lines
7.5 KiB
C++
330 lines
7.5 KiB
C++
/**
|
|
* @file ctkinetics_methods.cpp
|
|
*
|
|
*/
|
|
static PyObject*
|
|
kin_newFromXML(PyObject* self, PyObject* args)
|
|
{
|
|
int mxml, iphase, neighbor1, neighbor2, neighbor3, neighbor4;
|
|
if (!PyArg_ParseTuple(args, "iiiiii:newFromXML", &mxml,
|
|
&iphase, &neighbor1, &neighbor2, &neighbor3, &neighbor4)) {
|
|
return NULL;
|
|
}
|
|
int n = int(newKineticsFromXML(mxml, iphase, neighbor1, neighbor2,
|
|
neighbor3, neighbor4));
|
|
if (n < 0) {
|
|
return reportError(n);
|
|
}
|
|
return Py_BuildValue("i",n);
|
|
}
|
|
|
|
static PyObject*
|
|
kin_delete(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
if (!PyArg_ParseTuple(args, "i:kin_delete", &kin)) {
|
|
return NULL;
|
|
}
|
|
delKinetics(kin);
|
|
return Py_BuildValue("i",0);
|
|
}
|
|
|
|
static PyObject*
|
|
kin_phase(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, n;
|
|
if (!PyArg_ParseTuple(args, "ii:kin_phase", &kin, &n)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_phase(kin, n));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_nspecies(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
if (!PyArg_ParseTuple(args, "i:kin_nspecies", &kin)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_nSpecies(kin));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_rstoichcoeff(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, i, k;
|
|
if (!PyArg_ParseTuple(args, "iii:kin_rstoichcoeff", &kin, &k, &i)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("d",kin_reactantStoichCoeff(kin, k, i));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_pstoichcoeff(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, i, k;
|
|
if (!PyArg_ParseTuple(args, "iii:kin_pstoichcoeff", &kin, &k, &i)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("d",kin_productStoichCoeff(kin, k, i));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_nrxns(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
if (!PyArg_ParseTuple(args, "i:kin_nreactions", &kin)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_nReactions(kin));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_nPhases(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
if (!PyArg_ParseTuple(args, "i:kin_nPhases", &kin)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_nPhases(kin));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_phaseIndex(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
char* ph;
|
|
if (!PyArg_ParseTuple(args, "is:kin_phaseIndex", &kin, &ph)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_phaseIndex(kin, ph));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_reactionPhaseIndex(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
if (!PyArg_ParseTuple(args, "i:kin_reactionPhaseIndex", &kin)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_reactionPhaseIndex(kin));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_isrev(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, i;
|
|
if (!PyArg_ParseTuple(args, "ii:kin_isrev", &kin, &i)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_isReversible(kin,i));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_rxntype(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, i;
|
|
if (!PyArg_ParseTuple(args, "ii:kin_rxntype", &kin, &i)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_reactionType(kin,i));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_multiplier(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, i;
|
|
if (!PyArg_ParseTuple(args, "ii:kin_multiplier", &kin, &i)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("d",kin_multiplier(kin,i));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_setMultiplier(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, i;
|
|
double v;
|
|
if (!PyArg_ParseTuple(args, "iid:kin_setMultiplier", &kin, &i, &v)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_setMultiplier(kin,i,v));
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
kin_type(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
if (!PyArg_ParseTuple(args, "i:kin_type", &kin)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_type(kin));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_start(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, p;
|
|
if (!PyArg_ParseTuple(args, "ii:kin_start", &kin, &p)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_start(kin,p));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_speciesIndex(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
char* nm, *ph;
|
|
if (!PyArg_ParseTuple(args, "iss:kin_speciesIndex", &kin, &nm, &ph)) {
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue("i",kin_speciesIndex(kin,nm,ph));
|
|
}
|
|
|
|
static PyObject*
|
|
kin_advanceCoverages(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
double dt;
|
|
if (!PyArg_ParseTuple(args, "id:kin_advanceCoverages", &kin, &dt)) {
|
|
return NULL;
|
|
}
|
|
int iok = kin_advanceCoverages(kin, dt);
|
|
if (iok < 0) {
|
|
return reportCanteraError();
|
|
}
|
|
return Py_BuildValue("i",0);
|
|
}
|
|
|
|
static PyObject*
|
|
kin_getarray(PyObject* self, PyObject* args)
|
|
{
|
|
int kin;
|
|
int job;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii:kin_getarray", &kin, &job)) {
|
|
return NULL;
|
|
}
|
|
|
|
// array attributes
|
|
int iok = -22;
|
|
size_t nrxns = kin_nReactions(kin);
|
|
size_t nsp = kin_nSpecies(kin);
|
|
size_t ix;
|
|
if (job < 45 || job >= 90) {
|
|
ix = nrxns;
|
|
} else {
|
|
ix = nsp;
|
|
}
|
|
|
|
#ifdef HAS_NUMPY
|
|
npy_intp nix = ix;
|
|
PyArrayObject* x = (PyArrayObject*)PyArray_SimpleNew(1, &nix, PyArray_DOUBLE);
|
|
#else
|
|
int nix = int(ix);
|
|
PyArrayObject* x =
|
|
(PyArrayObject*)PyArray_FromDims(1, &nix, PyArray_DOUBLE);
|
|
#endif
|
|
double* xd = (double*)x->data;
|
|
|
|
switch (job) {
|
|
case 10:
|
|
iok = kin_getFwdRatesOfProgress(kin, nrxns, xd);
|
|
break;
|
|
case 20:
|
|
iok = kin_getRevRatesOfProgress(kin, nrxns, xd);
|
|
break;
|
|
case 30:
|
|
iok = kin_getNetRatesOfProgress(kin, nrxns, xd);
|
|
break;
|
|
case 32:
|
|
iok = kin_getActivationEnergies(kin, nrxns, xd);
|
|
break;
|
|
case 34:
|
|
iok = kin_getFwdRateConstants(kin, nrxns, xd);
|
|
break;
|
|
case 35:
|
|
iok = kin_getRevRateConstants(kin, 1, nrxns, xd);
|
|
break;
|
|
case 36:
|
|
iok = kin_getRevRateConstants(kin, 0, nrxns, xd);
|
|
break;
|
|
case 40:
|
|
iok = kin_getEquilibriumConstants(kin, nrxns, xd);
|
|
break;
|
|
case 50:
|
|
iok = kin_getCreationRates(kin, nsp, xd);
|
|
break;
|
|
case 60:
|
|
iok = kin_getDestructionRates(kin, nsp, xd);
|
|
break;
|
|
case 70:
|
|
iok = kin_getNetProductionRates(kin, nsp, xd);
|
|
break;
|
|
case 80:
|
|
iok = kin_getSourceTerms(kin, nsp, xd);
|
|
break;
|
|
case 90:
|
|
iok = kin_getDelta(kin, 0, nrxns, xd);
|
|
break;
|
|
case 91:
|
|
iok = kin_getDelta(kin, 1, nrxns, xd);
|
|
break;
|
|
case 92:
|
|
iok = kin_getDelta(kin, 2, nrxns, xd);
|
|
break;
|
|
case 93:
|
|
iok = kin_getDelta(kin, 3, nrxns, xd);
|
|
break;
|
|
case 94:
|
|
iok = kin_getDelta(kin, 4, nrxns, xd);
|
|
break;
|
|
case 95:
|
|
iok = kin_getDelta(kin, 5, nrxns, xd);
|
|
break;
|
|
default:
|
|
;
|
|
}
|
|
if (iok >= 0) {
|
|
return PyArray_Return(x);
|
|
} else {
|
|
return reportError(iok);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// string attributes
|
|
static PyObject*
|
|
kin_getstring(PyObject* self, PyObject* args)
|
|
{
|
|
int kin, job, i, iok = -3;
|
|
int buflen;
|
|
char* output_buf = 0;
|
|
if (!PyArg_ParseTuple(args, "iii:kin_getstring", &kin, &job, &i)) {
|
|
return NULL;
|
|
}
|
|
switch (job) {
|
|
case 1:
|
|
buflen = 80;
|
|
output_buf = new char[buflen];
|
|
iok = kin_getReactionString(kin, i, buflen, output_buf);
|
|
break;
|
|
default:
|
|
iok = -10;
|
|
}
|
|
if (iok >= 0) {
|
|
PyObject* str = Py_BuildValue("s",output_buf);
|
|
delete output_buf;
|
|
return str;
|
|
}
|
|
delete output_buf;
|
|
if (iok == -1) {
|
|
return reportCanteraError();
|
|
} else {
|
|
PyErr_SetString(ErrorObject,"Unknown string attribute");
|
|
return NULL;
|
|
}
|
|
}
|