static PyObject *
py_interpolate(
PyObject *obj,
PyObject *args,
PyObject *kwds)
{
PyArrayObject *xdata = NULL;
PyArrayObject *data = NULL;
PyArrayObject *xout = NULL;
PyArrayObject *out = NULL;
PyArrayObject *oout = NULL;
PyArrayIterObject *dit = NULL;
PyArrayIterObject *oit = NULL;
npy_intp dstride, ostride, xdstride, xostride, size, outsize;
Py_ssize_t newshape[NPY_MAXDIMS];
int axis = NPY_MAXDIMS;
int i, ndim, error;
double *buffer = NULL;
static char *kwlist[] = {"x", "y", "x_new", "axis", "out", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&O&|O&O&", kwlist,
PyConverter_AnyDoubleArray, &xdata,
PyConverter_AnyDoubleArray, &data,
PyConverter_AnyDoubleArray, &xout,
PyArray_AxisConverter, &axis,
PyOutputConverter_AnyDoubleArrayOrNone, &oout))
goto _fail;
/* check axis */
ndim = PyArray_NDIM(data);
if ((axis == NPY_MAXDIMS) || (axis == -1)) {
axis = ndim - 1;
} else if ((axis < 0) || (axis > NPY_MAXDIMS)) {
PyErr_Format(PyExc_ValueError, "invalid axis");
goto _fail;
}
if ((PyArray_NDIM(xdata) != 1) || (PyArray_NDIM(xout) != 1)) {
PyErr_Format(PyExc_ValueError,
"x-arrays must be one dimensional");
goto _fail;
}
size = PyArray_DIM(data, axis);
outsize = PyArray_DIM(xout, 0);
if (size < 3) {
PyErr_Format(PyExc_ValueError, "size along axis is too small");
goto _fail;
}
if (size != PyArray_DIM(xdata, 0)) {
PyErr_Format(PyExc_ValueError,
"size of x-array must match data shape at axis");
goto _fail;
}
for (i = 0; i < ndim; i++) {
newshape[i] = (i == axis) ? outsize : PyArray_DIM(data, i);
}
if (oout == NULL) {
/* create a new output array */
out = (PyArrayObject*)PyArray_SimpleNew(ndim, newshape, NPY_DOUBLE);
if (out == NULL) {
PyErr_Format(PyExc_ValueError, "failed to allocate output array");
goto _fail;
}
} else if (ndim != PyArray_NDIM(oout)) {
PyErr_Format(PyExc_ValueError,
"output and data array dimension mismatch");
goto _fail;
} else {
for (i = 0; i < ndim; i++) {
if (newshape[i] != PyArray_DIM(oout, i)) {
PyErr_Format(PyExc_ValueError, "wrong output shape");
goto _fail;
}
}
out = oout;
}
/* iterate over all but specified axis */
dit = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)data, &axis);
oit = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)out, &axis);
dstride = PyArray_STRIDE(data, axis);
ostride = PyArray_STRIDE(out, axis);
xdstride = PyArray_STRIDE(xdata, 0);
xostride = PyArray_STRIDE(xout, 0);
buffer = (double *)PyMem_Malloc((size * 4 + 4) * sizeof(double));
if (buffer == NULL) {
PyErr_Format(PyExc_ValueError, "failed to allocate output buffer");
goto _fail;
}
while (dit->index < dit->size) {
error = interpolate(
size,
PyArray_DATA(xdata), xdstride,
dit->dataptr, dstride,
outsize,
PyArray_DATA(xout), xostride,
oit->dataptr, ostride,
buffer);
if (error != 0) {
PyErr_Format(PyExc_ValueError, "interpolate() failed");
goto _fail;
}
PyArray_ITER_NEXT(oit);
PyArray_ITER_NEXT(dit);
}
PyMem_Free(buffer);
Py_DECREF(oit);
Py_DECREF(dit);
Py_DECREF(data);
Py_DECREF(xout);
Py_DECREF(xdata);
/* Return output vector if not provided as argument */
if (oout == NULL) {
return PyArray_Return(out);
} else {
Py_INCREF(Py_None);
return Py_None;
}
_fail:
Py_XDECREF(xdata);
Py_XDECREF(xout);
Py_XDECREF(data);
Py_XDECREF(oit);
Py_XDECREF(dit);
if (buffer != NULL)
PyMem_Free(buffer);
if (oout == NULL)
Py_XDECREF(out);
else
Py_XDECREF(oout);
return NULL;
}
PyObject* _calcGrid(PyObject *self, PyObject *args) {
PyArrayObject *pos, *hsml, *mass, *rho, *value, *pyGrid;
int npart, nx, ny, nz, cells;
int dims[3];
double bx, by, bz, cx, cy, cz;
double *data_pos, *data_hsml, *data_mass, *data_rho, *data_value;
double *grid;
int part;
double px, py, pz, h, h2, m, r, v, cpx, cpy, cpz, r2;
int x, y, z0, z1;
int xmin, xmax, ymin, ymax, zmin, zmax, zmid;
double cellsizex, cellsizey, cellsizez;
time_t start;
start = clock();
if (!PyArg_ParseTuple( args, "O!O!O!O!O!iiidddddd:calcGrid( pos, hsml, mass, rho, value, nx, ny, nz, boxx, boxy, boxz, centerx, centery, centerz )", &PyArray_Type, &pos, &PyArray_Type, &hsml, &PyArray_Type, &mass, &PyArray_Type, &rho, &PyArray_Type, &value, &nx, &ny, &nz, &bx, &by, &bz, &cx, &cy, &cz )) {
return 0;
}
if (pos->nd != 2 || pos->dimensions[1] != 3 || pos->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "pos has to be of dimensions [n,3] and type double" );
return 0;
}
if (hsml->nd != 1 || hsml->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "hsml has to be of dimension [n] and type double" );
return 0;
}
if (mass->nd != 1 || mass->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "mass has to be of dimension [n] and type double" );
return 0;
}
if (rho->nd != 1 || rho->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "rho has to be of dimension [n] and type double" );
return 0;
}
if (value->nd != 1 || value->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "value has to be of dimension [n] and type double" );
return 0;
}
npart = pos->dimensions[0];
if (npart != hsml->dimensions[0] || npart != mass->dimensions[0] || npart != rho->dimensions[0] || npart != value->dimensions[0]) {
PyErr_SetString( PyExc_ValueError, "pos, hsml, rho and value have to have the same size in the first dimension" );
return 0;
}
dims[0] = nx;
dims[1] = ny;
dims[2] = nz;
pyGrid = (PyArrayObject *)PyArray_FromDims( 3, dims, PyArray_DOUBLE );
grid = (double*)pyGrid->data;
cells = nx*ny*nz;
memset( grid, 0, cells*sizeof(double) );
cellsizex = bx / nx;
cellsizey = by / ny;
cellsizez = bz / nz;
data_pos = (double*)pos->data;
data_hsml = (double*)hsml->data;
data_mass = (double*)mass->data;
data_rho = (double*)rho->data;
data_value = (double*)value->data;
for (part=0; part<npart; part++) {
px = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
py = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
pz = *data_pos;
data_pos = (double*)((char*)data_pos - 2*pos->strides[1] + pos->strides[0]);
h = *data_hsml;
data_hsml = (double*)((char*)data_hsml + hsml->strides[0]);
h2 = h*h;
m = *data_mass;
data_mass = (double*)((char*)data_mass + mass->strides[0]);
r = *data_rho;
data_rho = (double*)((char*)data_rho + rho->strides[0]);
v = *data_value;
data_value = (double*)((char*)data_value + value->strides[0]);
xmin = max( floor( (px - h - cx + 0.5*bx) / cellsizex ), 0 );
xmax = min( ceil( (px + h - cx + 0.5*bx) / cellsizex ), nx-1 );
ymin = max( floor( (py - h - cy + 0.5*by) / cellsizey ), 0 );
ymax = min( ceil( (py + h - cy + 0.5*by) / cellsizey ), ny-1 );
zmin = max( floor( (pz - h - cz + 0.5*bz) / cellsizez ), 0 );
zmax = min( ceil( (pz + h - cz + 0.5*bz) / cellsizez ), nz-1 );
zmid = floor( 0.5 * (zmin+zmax) + 0.5 );
if (xmin < nx && ymin < ny && xmax >= 0 && ymax >= 0 && zmin < nz && zmax >= 0) {
for (x=xmin; x<=xmax; x++) {
cpx = -0.5*bx + bx*(x+0.5)/nx;
for (y=ymin; y<=ymax; y++) {
cpy = -0.5*by + by*(y+0.5)/ny;
for (z0=zmid; z0>=zmin; z0--) {
cpz = -0.5*bz + bz*(z0+0.5)/nz;
r2 = ( sqr(px-cpx-cx) + sqr(py-cpy-cy) + sqr(pz-cpz-cz) );
if (r2 > h2) break;
grid[(x*ny + y)*nz + z0] += _getkernel( h, r2 ) * m * v / r;
}
for (z1=zmid+1; z1<=zmax; z1++) {
cpz = -0.5*bz + bz*(z1+0.5)/nz;
r2 = ( sqr(px-cpx-cx) + sqr(py-cpy-cy) + sqr(pz-cpz-cz) );
if (r2 > h2) break;
grid[(x*ny + y)*nz + z1] += _getkernel( h, r2 ) * m * v / r;
}
}
}
}
}
printf( "Calculation took %gs\n", ((double)clock()-(double)start)/CLOCKS_PER_SEC );
return PyArray_Return( pyGrid );
}
PyObject* _calcRadialProfile(PyObject *self, PyObject *args) {
PyArrayObject *pos, *data, *pyProfile;
int npart, nshells, mode;
int dims[2];
int *count;
double cx, cy, cz, dr;
double *data_pos, *data_data;
double *profile;
int part, shell;
double px, py, pz, d, rr, v;
time_t start;
start = clock();
mode = 1;
nshells = 200;
dr = 0;
cx = cy = cz = 0;
if (!PyArg_ParseTuple( args, "O!O!|iidddd:calcRadialProfile( pos, data, mode, nshells, dr, centerx, centery, centerz )", &PyArray_Type, &pos, &PyArray_Type, &data, &mode, &nshells, &dr, &cx, &cy, &cz )) {
return 0;
}
if (pos->nd != 2 || pos->dimensions[1] != 3 || pos->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "pos has to be of dimensions [n,3] and type double" );
return 0;
}
if (data->nd != 1 || data->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "data has to be of dimension [n] and type double" );
return 0;
}
npart = pos->dimensions[0];
if (npart != data->dimensions[0]) {
PyErr_SetString( PyExc_ValueError, "pos and data have to have the same size in the first dimension" );
return 0;
}
dims[0] = 2;
dims[1] = nshells;
pyProfile = (PyArrayObject *)PyArray_FromDims( 2, dims, PyArray_DOUBLE );
profile = (double*)pyProfile->data;
memset( profile, 0, 2*nshells*sizeof(double) );
count = (int*)malloc( nshells*sizeof(int) );
memset( count, 0, nshells*sizeof(int) );
if (!dr) {
data_pos = (double*)pos->data;
for (part=0; part<npart; part++) {
px = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
py = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
pz = *data_pos;
data_pos = (double*)((char*)data_pos - 2*pos->strides[1] + pos->strides[0]);
rr = sqrt( sqr(px-cx) + sqr(py-cy) + sqr(pz-cz) );
if (rr > dr)
dr = rr;
}
dr /= nshells;
printf( "dr set to %g\n", dr );
}
data_pos = (double*)pos->data;
data_data = (double*)data->data;
for (part=0; part<npart; part++) {
px = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
py = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
pz = *data_pos;
data_pos = (double*)((char*)data_pos - 2*pos->strides[1] + pos->strides[0]);
d = *data_data;
data_data = (double*)((char*)data_data + data->strides[0]);
rr = sqrt( sqr(px-cx) + sqr(py-cy) + sqr(pz-cz) );
shell = floor( rr / dr );
if (shell < nshells) {
profile[ shell ] += d;
count[ shell ] += 1;
}
}
for (shell=0; shell<nshells; shell++) {
profile[ nshells + shell ] = dr * (shell + 0.5);
}
switch (mode) {
// sum
case 0:
break;
// density
case 1:
for (shell=0; shell<nshells; shell++) {
v = 4.0 / 3.0 * M_PI * dr*dr*dr * ( ((double)shell+1.)*((double)shell+1.)*((double)shell+1.) - (double)shell*(double)shell*(double)shell );
profile[shell] /= v;
}
break;
// average
case 2:
for (shell=0; shell<nshells; shell++) if (count[shell] > 0) profile[shell] /= count[shell];
break;
}
free( count );
printf( "Calculation took %gs\n", ((double)clock()-(double)start)/CLOCKS_PER_SEC );
return PyArray_Return( pyProfile );
}
// =============================================================================
PyObject * Epetra_NumPyMultiVector::ExtractView() const
{
Py_INCREF(array);
return PyArray_Return(array);
}
static PyObject *
rsgrid (PyObject *self, PyObject *args) {
PyObject *input;
PyArrayObject *data, *P, *wvals;
int ndat, nw, i, j, Pdims[1];
double *times, *Pdata, *wdata;
double *sd, *cd1, *swt, *cwt;
double w_l, w_u, dw, dwt, wt, w, temp;
double S, C;
/** Initialize objects to NULL that we may have to XDECREF if a constructor
** fails so that XDECREF has an argument to work with. Strictly, this
** isn't needed for every object. */
data = NULL;
P = NULL;
wvals = NULL;
sd = NULL;
cd1 = NULL;
swt = NULL;
cwt = NULL;
/** Parse the args; make the data array contiguous. */
Py_TRY(PyArg_ParseTuple(args, "iddO", &nw, &w_l, &w_u, &input));
data = (PyArrayObject *)
PyArray_ContiguousFromObject(input, PyArray_DOUBLE, 1, 1);
if (data == NULL) goto FAIL;
/** Store the # of data; make vector references to event times. */
ndat = data->dimensions[0];
times = DDATA(data);
/** Make space for the trig. */
sd = (double *) malloc(ndat*sizeof(double));
cd1 = (double *) malloc(ndat*sizeof(double));
swt = (double *) malloc(ndat*sizeof(double));
cwt = (double *) malloc(ndat*sizeof(double));
/** Setup for the trig recurrences we'll use in the frequency loop. */
dw = (w_u - w_l) / (nw-1);
for (j=0; j<ndat; j++) {
dwt = dw * *(times+j);
sd[j] = sin(dwt);
cd1[j] = sin(0.5*dwt);
cd1[j] = -2.*cd1[j]*cd1[j];
wt = w_l * *(times+j);
swt[j] = sin(wt);
cwt[j] = cos(wt);
}
/** Loop over frequencies. */
Pdims[0] = nw;
P = (PyArrayObject *)PyArray_FromDims(1, Pdims, PyArray_DOUBLE);
if (P == NULL) goto FAIL;
Pdata = DDATA(P);
wvals = (PyArrayObject *)PyArray_FromDims(1, Pdims, PyArray_DOUBLE);
if (wvals == NULL) goto FAIL;
wdata = DDATA(wvals);
w = w_l;
for (i=0; i<nw; i++) {
wdata[i] = w;
w += dw;
S = C = 0.;
/* Loop over data to calculate the Rayleigh power;
also, use some trig to prepare for the next frequency. */
for (j=0; j<ndat; j++) {
S = S + swt[j];
C = C + cwt[j];
temp = cwt[j];
cwt[j] = cwt[j] + (cwt[j]*cd1[j] - swt[j]*sd[j]);
swt[j] = swt[j] + (swt[j]*cd1[j] + temp*sd[j]);
}
Pdata[i] = (S*S + C*C)/ndat;
}
/** Clean up and return everything in a tuple. */
Py_DECREF(data);
free(sd);
free(cd1);
free(swt);
free(cwt);
return Py_BuildValue("NN", PyArray_Return(wvals), PyArray_Return(P));
/** Misbehavior ends up here! */
FAIL:
Py_XDECREF(data);
Py_XDECREF(P);
Py_XDECREF(wvals);
if (sd != NULL) free(sd);
if (cd1 != NULL) free(cd1);
if (swt != NULL) free(swt);
if (cwt != NULL) free(cwt);
return NULL;
}
/* ravel_multi_index implementation - see add_newdocs.py */
NPY_NO_EXPORT PyObject *
arr_ravel_multi_index(PyObject *self, PyObject *args, PyObject *kwds)
{
int i, s;
PyObject *mode0=NULL, *coords0=NULL;
PyArrayObject *ret = NULL;
PyArray_Dims dimensions={0,0};
npy_intp ravel_strides[NPY_MAXDIMS];
NPY_ORDER order = NPY_CORDER;
NPY_CLIPMODE modes[NPY_MAXDIMS];
PyArrayObject *op[NPY_MAXARGS];
PyArray_Descr *dtype[NPY_MAXARGS];
npy_uint32 op_flags[NPY_MAXARGS];
NpyIter *iter = NULL;
char *kwlist[] = {"multi_index", "dims", "mode", "order", NULL};
memset(op, 0, sizeof(op));
dtype[0] = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"OO&|OO&:ravel_multi_index", kwlist,
&coords0,
PyArray_IntpConverter, &dimensions,
&mode0,
PyArray_OrderConverter, &order)) {
goto fail;
}
if (dimensions.len+1 > NPY_MAXARGS) {
PyErr_SetString(PyExc_ValueError,
"too many dimensions passed to ravel_multi_index");
goto fail;
}
if (!PyArray_ConvertClipmodeSequence(mode0, modes, dimensions.len)) {
goto fail;
}
switch (order) {
case NPY_CORDER:
s = 1;
for (i = dimensions.len-1; i >= 0; --i) {
ravel_strides[i] = s;
s *= dimensions.ptr[i];
}
break;
case NPY_FORTRANORDER:
s = 1;
for (i = 0; i < dimensions.len; ++i) {
ravel_strides[i] = s;
s *= dimensions.ptr[i];
}
break;
default:
PyErr_SetString(PyExc_ValueError,
"only 'C' or 'F' order is permitted");
goto fail;
}
/* Get the multi_index into op */
if (sequence_to_arrays(coords0, op, dimensions.len, "multi_index") < 0) {
goto fail;
}
for (i = 0; i < dimensions.len; ++i) {
op_flags[i] = NPY_ITER_READONLY|
NPY_ITER_ALIGNED;
}
op_flags[dimensions.len] = NPY_ITER_WRITEONLY|
NPY_ITER_ALIGNED|
NPY_ITER_ALLOCATE;
dtype[0] = PyArray_DescrFromType(NPY_INTP);
for (i = 1; i <= dimensions.len; ++i) {
dtype[i] = dtype[0];
}
iter = NpyIter_MultiNew(dimensions.len+1, op, NPY_ITER_BUFFERED|
NPY_ITER_EXTERNAL_LOOP|
NPY_ITER_ZEROSIZE_OK,
NPY_KEEPORDER,
NPY_SAME_KIND_CASTING,
op_flags, dtype);
if (iter == NULL) {
goto fail;
}
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr;
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
if (ravel_multi_index_loop(dimensions.len, dimensions.ptr,
ravel_strides, *countptr, modes,
dataptr, strides) != NPY_SUCCEED) {
goto fail;
}
} while(iternext(iter));
}
ret = NpyIter_GetOperandArray(iter)[dimensions.len];
Py_INCREF(ret);
Py_DECREF(dtype[0]);
for (i = 0; i < dimensions.len; ++i) {
Py_XDECREF(op[i]);
}
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return PyArray_Return(ret);
fail:
Py_XDECREF(dtype[0]);
for (i = 0; i < dimensions.len; ++i) {
Py_XDECREF(op[i]);
}
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return NULL;
}
static PyObject *_nonlinear_ld(PyObject *self, PyObject *args)
{
double rprs, d, fac, A_i, x, I;
int nthreads;
npy_intp i, dims[1];
double dx, A_f, x_in, x_out, delta, c1, c2, c3, c4;
PyArrayObject *ds, *flux;
if(!PyArg_ParseTuple(args,"Oddddddi", &ds, &rprs, &c1, &c2, &c3, &c4, &fac, &nthreads)) return NULL;
dims[0] = PyArray_DIMS(ds)[0];
flux = (PyArrayObject *) PyArray_SimpleNew(1, dims, PyArray_TYPE(ds)); //creates numpy array to store return flux values
double *f_array = PyArray_DATA(flux);
double *d_array = PyArray_DATA(ds);
/*
NOTE: the safest way to access numpy arrays is to use the PyArray_GETITEM and PyArray_SETITEM functions.
Here we use a trick for faster access and more convenient access, where we set a pointer to the
beginning of the array with the PyArray_DATA (e.g., f_array) and access elements with e.g., f_array[i].
Success of this operation depends on the numpy array storing data in blocks equal in size to a C double.
If you run into trouble along these lines, I recommend changing the array access to something like:
d = PyFloat_AsDouble(PyArray_GETITEM(ds, PyArray_GetPtr(ds, &i)));
where ds is a numpy array object.
Laura Kreidberg 07/2015
*/
#if defined (_OPENMP)
omp_set_num_threads(nthreads); //specifies number of threads (if OpenMP is supported)
#endif
double norm = (-c1/10. - c2/6. - 3.*c3/14. - c4/4. + 0.5)*2.*M_PI; //normalization for intensity profile (faster to calculate it once, rather than every time intensity is called)
#if defined (_OPENMP)
#pragma omp parallel for private(d, x_in, x_out, delta, x, dx, A_i, A_f, I)
#endif
for(i = 0; i < dims[0]; i++)
{
d = d_array[i];
x_in = MAX(d - rprs, 0.); //lower bound for integration
x_out = MIN(d + rprs, 1.0); //upper bound for integration
if(x_in >= 1.) f_array[i] = 1.0; //flux = 1. if the planet is not transiting
else
{
delta = 0.; //variable to store the integrated intensity, \int I dA
x = x_in; //starting radius for integration
dx = fac*acos(x); //initial step size
x += dx; //first step
A_i = 0.; //initial area
while(x < x_out)
{
A_f = area(d, x, rprs); //calculates area of overlapping circles
I = intensity(x - dx/2.,c1,c2, c3, c4, norm); //intensity at the midpoint
delta += (A_f - A_i)*I; //increase in transit depth for this integration step
dx = fac*acos(x); //updating step size
x = x + dx; //stepping to next element
A_i = A_f; //storing area
}
dx = x_out - x + dx; //calculating change in radius for last step FIXME
x = x_out; //final radius for integration
A_f = area(d, x, rprs); //area for last integration step
I = intensity(x - dx/2.,c1,c2, c3, c4, norm); //intensity at the midpoint
delta += (A_f - A_i)*I; //increase in transit depth for this integration step
f_array[i] = 1.0 - delta; //flux equals 1 - \int I dA
}
}
return PyArray_Return((PyArrayObject *)flux);
}
static PyObject * blobproperties (PyObject *self,
PyObject *args,
PyObject *keywds)
{
PyArrayObject *dataarray=NULL,*blobarray=NULL; /* in (not modified) */
PyArrayObject *results=NULL;
static char *kwlist[] = {
"data",
"blob",
"npeaks",
"omega",
"verbose",
NULL};
double *res;
double fval;
double omega=0;
int np=0,verbose=0,type,f,s,peak,bad;
int i,j, percent;
npy_intp safelyneed[3];
if(!PyArg_ParseTupleAndKeywords(args,keywds, "O!O!i|di",kwlist,
&PyArray_Type,
&dataarray, /* array args - data */
&PyArray_Type,
&blobarray, /* blobs */
&np, /* Number of peaks to treat */
&omega, /* omega angle - put 0 if unknown */
&verbose)) /* optional verbosity */
return NULL;
if(verbose)printf("omega = %f",omega);
/* Check array is two dimensional */
if(dataarray->nd != 2){
PyErr_SetString(PyExc_ValueError,
"data array must be 2d, first arg problem");
return NULL;
}
if(verbose!=0)printf("Welcome to blobproperties\n");
/* Check array is two dimensional and int -
results from connectedpixels above */
if(blobarray->nd != 2 && blobarray->descr->type_num != PyArray_INT){
PyErr_SetString(PyExc_ValueError,
"Blob array must be 2d and integer, second arg problem");
return NULL;
}
type=dataarray->descr->type_num;
/* Decide on fast/slow loop - inner versus outer */
if(blobarray->strides[0] > blobarray->strides[1]) {
f=1; s=0;}
else {
f=0; s=1;
}
if (verbose!=0){
printf("Fast index is %d, slow index is %d, ",f,s);
printf("strides[0]=%d, strides[1]=%d\n",
dataarray->strides[0],
dataarray->strides[1]);
}
/* results arrays */
safelyneed[0]=np;
safelyneed[1]=NPROPERTY;
results = (PyArrayObject *) PyArray_SimpleNew(2,
safelyneed,
PyArray_DOUBLE);
if( results == NULL){
PyErr_SetString(PyExc_ValueError,
"Malloc failed fo results");
return NULL;
}
Py_BEGIN_ALLOW_THREADS
if(verbose>0)printf("malloc'ed the results\n");
res = (double*)results->data;
/* Initialise the results */
for ( i=0 ; i<safelyneed[0] ; i++) {
for ( j=0 ; j<NPROPERTY; j++){
res[i*NPROPERTY+j]=0.;
}
/* Set min to max +1 and vice versa */
res[i*NPROPERTY+bb_mn_f]=blobarray->dimensions[f]+1;
res[i*NPROPERTY+bb_mn_s]=blobarray->dimensions[s]+1;
res[i*NPROPERTY+bb_mx_f]=-1;
res[i*NPROPERTY+bb_mx_s]=-1;
/* All pixels have the same omega in this frame */
res[i*NPROPERTY+bb_mx_o]=omega;
res[i*NPROPERTY+bb_mn_o]=omega;
}
if(verbose!=0)printf("Got some space to put the results in\n");
percent=(blobarray->dimensions[s]-1)/80.0;
if(percent < 1)percent=1;
bad = 0;
if(verbose!=0)printf("Scanning image\n");
/* i,j is looping along the indices data array */
for( i = 0 ; i <= (blobarray->dimensions[s]-1) ; i++ ){
if(verbose!=0 && (i%percent == 0) )printf(".");
for( j = 0 ; j <= (blobarray->dimensions[f]-1) ; j++ ){
peak = *(int *) getptr(blobarray,f,s,i,j);
if( peak > 0 && peak <=np ) {
fval = getval(getptr(dataarray,f,s,i,j),type);
/* printf("i,j,f,s,fval,peak %d %d %d %d %f %d\n",i,j,f,s,fval,peak); */
add_pixel( &res[NPROPERTY*(peak-1)] ,i , j ,fval , omega);
}
else{
if(peak!=0){
bad++;
if(verbose!=0 && bad<10){
printf("Found %d in your blob image at i=%d, j=%d\n",peak,i,j);}
/* Only complain 10 times - otherwise piles of crap go to screen */
}
}
} /* j */
} /* i */
if(verbose){
printf("\nFound %d bad pixels in the blob image\n",bad);
}
Py_END_ALLOW_THREADS
return Py_BuildValue("O", PyArray_Return(results) );
}
PyObject* radonShiftCorrelate(PyObject *self, PyObject *args) {
/*
** Inputs:
** (1) 2D numpy array of first Radon transform (using doubles)
** (2) 2D numpy array of second Radon transform (using doubles)
** (3) interger of search radius (in pixels)
** Modifies:
** nothing
** Outputs:
** 1D numpy array containing correlation values of angle (y-axis) and shift (x-axis)
*/
Py_Initialize();
/* Simple test loop */
/*struct item *headtwo = NULL;
int rad;
for(rad=0; rad<8; rad++) {
struct item *headtwo = NULL;
headtwo = getAnglesList(rad, headtwo);
fprintf(stderr, "radius %d, num angles %d\n", rad, list_length(headtwo));
//if (rad < 3) print_list(headtwo);
delete_list(headtwo);
}
fprintf(stderr, "Finish test radii\n");*/
/* End simple test loop */
/* Parse tuples separately since args will differ between C fcns */
int radius;
PyArrayObject *radonone, *radontwo;
//fprintf(stderr, "Start variable read\n");
if (!PyArg_ParseTuple(args, "OOi", &radonone, &radontwo, &radius))
return NULL;
if (radonone == NULL) return NULL;
if (radontwo == NULL) return NULL;
/* Create list of angles to check, number of angles is based on radius */
struct item *head = NULL;
head = getAnglesList(radius, head);
int numangles = list_length(head);
//fprintf(stderr, "Finish get angles, radius %d, num angles %d\n", radius, list_length(head));
/* dimensions error checking */
if (radonone->dimensions[0] != radontwo->dimensions[0]
|| radonone->dimensions[1] != radontwo->dimensions[1]) {
fprintf(stderr, "\n%s: Radon arrays are of different dimensions (%d,%d) vs. (%d,%d)\n\n",
__FILE__,
radonone->dimensions[0], radonone->dimensions[1],
radontwo->dimensions[0], radontwo->dimensions[1]);
return NULL;
}
/* Get the dimensions of the input */
int numrows = radonone->dimensions[0];
int numcols = radonone->dimensions[1];
//fprintf(stderr, "Dimensions: %d rows by %d cols\n", numrows, numcols);
if (2*radius > numcols) {
fprintf(stderr, "\n%s: Shift diameter %d is larger than Radon array dimensions (%d,%d))\n\n",
__FILE__, radius*2,
radontwo->dimensions[0], radontwo->dimensions[1]);
return NULL;
}
/*
double test;
test = *((double *)PyArray_GETPTR2(radonone, 0, 0));
fprintf(stderr, "Array 1 test value at (0,0) = %.3f\n", test);
test = *((double *)PyArray_GETPTR2(radontwo, 0, 0));
fprintf(stderr, "Array 2 test value at (0,0) = %.3f\n", test);
*/
/* Determine the dimensions for the output */
npy_intp outdims[2] = {numrows, numangles};
/* Make a new double matrix of desired dimensions */
//fprintf(stderr, "Creating output array of dimensions %d and %d\n", numrows, numangles);
import_array(); // this is required to use PyArray_New() and PyArray_SimpleNew()
PyArrayObject *output;
//output = (PyArrayObject *) PyArray_New(&PyArray_Type, 2, outdims, NPY_DOUBLE, NULL, NULL, 0, 0, NULL);
output = (PyArrayObject *) PyArray_SimpleNew(2, outdims, NPY_DOUBLE);
//fprintf(stderr, "Finish create output array\n");
/* Do the calculation. */
int row;
#pragma omp parallel for
for (row=0; row<numrows; row++) {
struct item *current;
int anglecol=0;
for(current=head; current!=NULL; current=current->next) {
/* calculation of cross correlation */
double rawshift = radius*sin(current->angle);
int shift;
if (rawshift > 0) {
shift = (int) (radius*sin(current->angle) + 0.5);
} else {
shift = (int) (radius*sin(current->angle) - 0.5);
}
//fprintf(stderr, "raw = %.3f; shift = %d\n", rawshift, shift);
int i,j,ishift,jshift;
double onevalue, twovalue;
double outputsum = 0.0;
//fprintf(stderr, "Position %d, %d\n", row, anglecol);
for (i=0; i<numrows; i++) {
for (j=0; j<numcols; j++) {
ishift = i+row;
if (ishift >= numrows) ishift -= numrows; // wrap overflow values
if (ishift < 0) ishift += numrows; // wrap negative values
jshift = j+shift;
if (jshift >= numcols) jshift -= numcols; // wrap overflow values
if (jshift < 0) jshift += numcols; // wrap negative values
//fprintf(stderr, "%d, %d <-", ishift, jshift);
onevalue = *((double *)PyArray_GETPTR2(radonone, ishift, jshift));
//fprintf(stderr, "-> %d, %d\n", i, j);
twovalue = *((double *)PyArray_GETPTR2(radontwo, i, j));
outputsum += onevalue * twovalue;
}}
outputsum /= (numrows*numcols);
*(double *) PyArray_GETPTR2(output, row, anglecol) = outputsum;
/* interation variables */
anglecol++;
} }
/* clean up any memory leaks */
delete_list(head);
return PyArray_Return(output);
}
static PyObject *
py_squared_distance_matrix(PyObject *self, PyObject *args)
{
int m,n,d;
double *dist;
PyObject *A, *B, *g;
PyArrayObject *arrayA, *arrayB, *arrayg;
PyArrayObject *array_dist;
/*
double scale, result;
PyObject *list;
*/
int out_dim[2];
/* send Python arrays to C */
if (!PyArg_ParseTuple(args, "OOO", &A, &B, &g))
{
return NULL;
}
/* printf("getting input success. \n"); */
arrayA = (PyArrayObject *) PyArray_ContiguousFromObject(A, PyArray_DOUBLE, 1, 2);
arrayB = (PyArrayObject *) PyArray_ContiguousFromObject(B, PyArray_DOUBLE, 1, 2);
arrayg = (PyArrayObject *) PyArray_ContiguousFromObject(g, PyArray_DOUBLE, 1, 2);
/* printf("converting success!\n"); */
if (arrayA->nd > 2 || arrayA->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString(PyExc_ValueError,
"array must be two-dimensional and of type float");
return NULL;
}
/*printf("checking input success!\n");*/
m = (arrayA->dimensions)[0];
n = (arrayB->dimensions)[0];
if (arrayA->nd>1)
d = (arrayA->dimensions)[1];
else
d = 1;
/* printf("m=%d,n=%d,d=%d\n",m,n,d); */
dist = (double *) malloc(m*n*sizeof(double));
/* call function */
squared_distance_matrix((double*)(arrayA->data), (double*)(arrayB->data), (double*)(arrayg->data), m, n, d, dist);
out_dim[0] = m;
out_dim[1] = n;
/* PyArray_FromDimsAndData() deprecated, use PyArray_SimpleNewFromData()
http://blog.enthought.com/?p=62
array_dist = (PyArrayObject*) PyArray_FromDimsAndData(2,out_dim,PyArray_DOUBLE, (char*)dist);
*/
array_dist = PyArray_SimpleNewFromData(2,out_dim,NPY_DOUBLE,dist);
if (array_dist == NULL){
printf("creating %dx%d array failed\n", out_dim[0],out_dim[1]);
return NULL;
}
/*free(dist);*/
/* send the result back to Python */
Py_DECREF(arrayA);
Py_DECREF(arrayB);
Py_DECREF(arrayg);
return PyArray_Return(array_dist);
//return PyFloat_FromDouble(result);
/*return Py_BuildValue("d", result);*/
}
static PyObject *
py_gauss_transform(PyObject *self, PyObject *args)
{
int m,n,dim;
double scale, result;
double *grad;
PyObject *A, *B;
PyArrayObject *arrayA, *arrayB;
PyArrayObject *arrayGrad;
PyObject *list;
/* send Python arrays to C */
if (!PyArg_ParseTuple(args, "OOd", &A, &B, &scale))
{
return NULL;
}
/* printf("getting input success. \n"); */
arrayA = (PyArrayObject *) PyArray_ContiguousFromObject(A, PyArray_DOUBLE, 1, 2);
arrayB = (PyArrayObject *) PyArray_ContiguousFromObject(B, PyArray_DOUBLE, 1, 2);
/* printf("converting success!\n"); */
if (arrayA->nd > 2 || arrayA->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString(PyExc_ValueError,
"array must be two-dimensional and of type float");
return NULL;
}
/* printf("checking input success!\n"); */
m = (arrayA->dimensions)[0];
n = (arrayB->dimensions)[0];
if (arrayA->nd>1)
dim = (arrayA->dimensions)[1];
else
dim = 1;
/* printf("m=%d,n=%d,dim=%d\n",m,n,dim); */
grad = (double *) malloc(m*dim*sizeof(double));
/* call function */
result = GaussTransform((double*)(arrayA->data), (double*)(arrayB->data), m, n, dim, scale, grad);
/* PyArray_FromDimsAndData() deprecated, use PyArray_SimpleNewFromData()
http://blog.enthought.com/?p=62
arrayGrad = (PyArrayObject*) PyArray_FromDimsAndData(2,arrayA->dimensions,PyArray_DOUBLE, (char*)grad);
*/
arrayGrad = PyArray_SimpleNewFromData(2,arrayA->dimensions,NPY_DOUBLE,grad);
if (arrayGrad == NULL){
printf("creating %dx%d array failed\n", arrayA->dimensions[0],arrayA->dimensions[1]);
return NULL;
}
/* free(grad); */
/* send the result back to Python */
Py_DECREF(arrayA);
Py_DECREF(arrayB);
//Build a list; send it back to interpreter
list = PyList_New(0);
// Check the API documentation for meaning of
// return values.
if(PyList_Append(list, PyFloat_FromDouble(result)) != 0)
{
// set exception context, raise (return 0)
return 0;
}
if(PyList_Append(list, PyArray_Return(arrayGrad)) != 0)
{
// set exception context, raise (return 0)
return 0;
}
return list;
//return PyArray_Return(arrayGrad);
//return PyFloat_FromDouble(result);
/*return Py_BuildValue("d", result);*/
}
PyObject *embedBoundsMatrix(python::object boundsMatArg,int maxIters=10,
bool randomizeOnFailure=false,int numZeroFail=2,
python::list weights=python::list(),
int randomSeed=-1){
PyObject *boundsMatObj = boundsMatArg.ptr();
if(!PyArray_Check(boundsMatObj))
throw_value_error("Argument isn't an array");
PyArrayObject *boundsMat=reinterpret_cast<PyArrayObject *>(boundsMatObj);
// get the dimensions of the array
unsigned int nrows = boundsMat->dimensions[0];
unsigned int ncols = boundsMat->dimensions[1];
if(nrows!=ncols)
throw_value_error("The array has to be square");
if(nrows<=0)
throw_value_error("The array has to have a nonzero size");
if (boundsMat->descr->type_num != PyArray_DOUBLE)
throw_value_error("Only double arrays are currently supported");
unsigned int dSize = nrows*nrows;
double *cData = new double[dSize];
double *inData = reinterpret_cast<double *>(boundsMat->data);
memcpy(static_cast<void *>(cData),
static_cast<const void *>(inData),
dSize*sizeof(double));
DistGeom::BoundsMatrix::DATA_SPTR sdata(cData);
DistGeom::BoundsMatrix bm(nrows,sdata);
RDGeom::Point3D *positions=new RDGeom::Point3D[nrows];
std::vector<RDGeom::Point *> posPtrs;
for (unsigned int i = 0; i < nrows; i++) {
posPtrs.push_back(&positions[i]);
}
RDNumeric::DoubleSymmMatrix distMat(nrows, 0.0);
// ---- ---- ---- ---- ---- ---- ---- ---- ----
// start the embedding:
bool gotCoords=false;
for(int iter=0;iter<maxIters && !gotCoords;iter++){
// pick a random distance matrix
DistGeom::pickRandomDistMat(bm,distMat,randomSeed);
// and embed it:
gotCoords=DistGeom::computeInitialCoords(distMat,posPtrs,randomizeOnFailure,
numZeroFail,randomSeed);
// update the seed:
if(randomSeed>=0) randomSeed+=iter*999;
}
if(gotCoords){
std::map<std::pair<int,int>,double> weightMap;
unsigned int nElems=PySequence_Size(weights.ptr());
for(unsigned int entryIdx=0;entryIdx<nElems;entryIdx++){
PyObject *entry=PySequence_GetItem(weights.ptr(),entryIdx);
if(!PySequence_Check(entry) || PySequence_Size(entry)!=3){
throw_value_error("weights argument must be a sequence of 3-sequences");
}
int idx1=PyInt_AsLong(PySequence_GetItem(entry,0));
int idx2=PyInt_AsLong(PySequence_GetItem(entry,1));
double w=PyFloat_AsDouble(PySequence_GetItem(entry,2));
weightMap[std::make_pair(idx1,idx2)]=w;
}
DistGeom::VECT_CHIRALSET csets;
ForceFields::ForceField *field = DistGeom::constructForceField(bm,posPtrs,csets,0.0, 0.0,
&weightMap);
CHECK_INVARIANT(field,"could not build dgeom force field");
field->initialize();
if(field->calcEnergy()>1e-5){
int needMore=1;
while(needMore){
needMore=field->minimize();
}
}
delete field;
} else {
throw_value_error("could not embed matrix");
}
// ---- ---- ---- ---- ---- ---- ---- ---- ----
// construct the results matrix:
npy_intp dims[2];
dims[0] = nrows;
dims[1] = 3;
PyArrayObject *res = (PyArrayObject *)PyArray_SimpleNew(2,dims,NPY_DOUBLE);
double *resData=reinterpret_cast<double *>(res->data);
for(unsigned int i=0;i<nrows;i++){
unsigned int iTab=i*3;
for (unsigned int j = 0; j < 3; ++j) {
resData[iTab + j]=positions[i][j]; //.x;
}
}
delete [] positions;
return PyArray_Return(res);
}
static PyObject *cosine_sim_expand_dkeys_cpu(PyObject *self, PyObject *args){
PyArrayObject *keys_in, *mem_in, *numpy_buffer_temp;
float *keys, *mem, keys_sq_sum, *mem_sq_sum;
float *comb;
if (!PyArg_ParseTuple(args, "O!O!", &PyArray_Type, &keys_in, &PyArray_Type, &mem_in))
return NULL;
int n_controllers = PyArray_DIM(keys_in, 0);
int mem_length = PyArray_DIM(keys_in, 1);
int M = PyArray_DIM(mem_in, 0); // num mem slots
keys = (float *) PyArray_DATA(keys_in);
mem = (float *) PyArray_DATA(mem_in);
///////////////////////// output buffer
int dims[5];
dims[0] = n_controllers;
dims[1] = M;
dims[2] = n_controllers;
dims[3] = mem_length;
numpy_buffer_temp = (PyArrayObject *) PyArray_FromDims(4, dims, NPY_FLOAT);
comb = (float *) PyArray_DATA(numpy_buffer_temp);
//////////////////////// keys_sq_sum, mem_sq_sum
MALLOC(mem_sq_sum, M * sizeof(DATA_TYPE))
memset(mem_sq_sum, 0, M * sizeof(DATA_TYPE));
for(int j = 0; j < M; j++){
for(int k = 0; k < mem_length; k++){
mem_sq_sum[j] += MEM(j,k) * MEM(j,k);
}
mem_sq_sum[j] = sqrt(mem_sq_sum[j]);
}
/////////////////////////
// mem*denom - temp (keys*numer*mem_sq_sum)
float numer, denom;
for(int i = 0; i < n_controllers; i++){ // [1]
keys_sq_sum = 0;
for(int k = 0; k < mem_length; k++){
keys_sq_sum += KEYS(i,k) * KEYS(i,k);
}
keys_sq_sum = sqrt(keys_sq_sum);
for(int j = 0; j < M; j++){
denom = keys_sq_sum * mem_sq_sum[j];
numer = 0;
for(int k = 0; k < mem_length; k++){
numer += KEYS(i,k) * MEM(j,k);
COMB(i,j,i,k) = MEM(j,k) / denom;
}
numer /= keys_sq_sum * denom * denom / mem_sq_sum[j];
for(int k = 0; k < mem_length; k++){ // [2]
COMB(i,j,i,k) -= KEYS(i,k) * numer;
}
}
}
free(mem_sq_sum);
return PyArray_Return(numpy_buffer_temp);
}
static PyObject *
_array_copy_nice(PyArrayObject *self)
{
return PyArray_Return((PyArrayObject *) PyArray_Copy(self));
}
// =============================================================================
PyObject * Epetra_NumPyIntSerialDenseVector::Values() const
{
Py_INCREF(array);
return PyArray_Return(array);
}
static PyObject* gist_extract(PyObject *self, PyObject *args)
{
int nblocks=4;
int n_scale=3;
int orientations_per_scale[50]={8,8,4};
PyArrayObject *image, *descriptor;
if (!PyArg_ParseTuple(args, "O", &image))
{
return NULL;
}
if (PyArray_TYPE(image) != NPY_UINT8) {
PyErr_SetString(PyExc_TypeError, "type of image must be uint8");
return NULL;
}
if (PyArray_NDIM(image) != 3) {
PyErr_SetString(PyExc_TypeError, "dimensions of image must be 3.");
return NULL;
}
npy_intp *dims_image = PyArray_DIMS(image);
const int w = (int) *(dims_image+1);
const int h = (int) *(dims_image);
// Read image to color_image_t structure
color_image_t *im=color_image_new(w,h);
for (int y=0, i=0 ; y<h ; ++y) {
for (int x=0 ; x<w ; ++x, ++i) {
im->c1[i] = *(unsigned char *)PyArray_GETPTR3(image, y, x, 0);
im->c2[i] = *(unsigned char *)PyArray_GETPTR3(image, y, x, 1);
im->c3[i] = *(unsigned char *)PyArray_GETPTR3(image, y, x, 2);
}
}
// Extract descriptor
float *desc=color_gist_scaletab(im,nblocks,n_scale,orientations_per_scale);
int descsize=0;
/* compute descriptor size */
for(int i=0;i<n_scale;i++)
descsize+=nblocks*nblocks*orientations_per_scale[i];
descsize*=3; /* color */
// Allocate output
npy_intp dim_desc[1] = {descsize};
descriptor = (PyArrayObject *) PyArray_SimpleNew(1, dim_desc, NPY_FLOAT);
// Set val
for (int i=0 ; i<descsize ; ++i) {
*(float *)PyArray_GETPTR1(descriptor, i) = desc[i];
}
// Release memory
color_image_delete(im);
free(desc);
return PyArray_Return(descriptor);
}
/* unravel_index implementation - see add_newdocs.py */
NPY_NO_EXPORT PyObject *
arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *indices0 = NULL, *ret_tuple = NULL;
PyArrayObject *ret_arr = NULL;
PyArrayObject *indices = NULL;
PyArray_Descr *dtype = NULL;
PyArray_Dims dimensions={0,0};
NPY_ORDER order = NPY_CORDER;
npy_intp unravel_size;
NpyIter *iter = NULL;
int i, ret_ndim;
npy_intp ret_dims[NPY_MAXDIMS], ret_strides[NPY_MAXDIMS];
char *kwlist[] = {"indices", "dims", "order", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|O&:unravel_index",
kwlist,
&indices0,
PyArray_IntpConverter, &dimensions,
PyArray_OrderConverter, &order)) {
goto fail;
}
if (dimensions.len == 0) {
PyErr_SetString(PyExc_ValueError,
"dims must have at least one value");
goto fail;
}
unravel_size = PyArray_MultiplyList(dimensions.ptr, dimensions.len);
if (!PyArray_Check(indices0)) {
indices = (PyArrayObject*)PyArray_FromAny(indices0,
NULL, 0, 0, 0, NULL);
if (indices == NULL) {
goto fail;
}
}
else {
indices = (PyArrayObject *)indices0;
Py_INCREF(indices);
}
dtype = PyArray_DescrFromType(NPY_INTP);
if (dtype == NULL) {
goto fail;
}
iter = NpyIter_New(indices, NPY_ITER_READONLY|
NPY_ITER_ALIGNED|
NPY_ITER_BUFFERED|
NPY_ITER_ZEROSIZE_OK|
NPY_ITER_DONT_NEGATE_STRIDES|
NPY_ITER_MULTI_INDEX,
NPY_KEEPORDER, NPY_SAME_KIND_CASTING,
dtype);
if (iter == NULL) {
goto fail;
}
/*
* Create the return array with a layout compatible with the indices
* and with a dimension added to the end for the multi-index
*/
ret_ndim = PyArray_NDIM(indices) + 1;
if (NpyIter_GetShape(iter, ret_dims) != NPY_SUCCEED) {
goto fail;
}
ret_dims[ret_ndim-1] = dimensions.len;
if (NpyIter_CreateCompatibleStrides(iter,
dimensions.len*sizeof(npy_intp), ret_strides) != NPY_SUCCEED) {
goto fail;
}
ret_strides[ret_ndim-1] = sizeof(npy_intp);
/* Remove the multi-index and inner loop */
if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
if (NpyIter_EnableExternalLoop(iter) != NPY_SUCCEED) {
goto fail;
}
ret_arr = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
ret_ndim, ret_dims, ret_strides, NULL, 0, NULL);
dtype = NULL;
if (ret_arr == NULL) {
goto fail;
}
if (order == NPY_CORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_corder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else if (order == NPY_FORTRANORDER) {
if (NpyIter_GetIterSize(iter) != 0) {
NpyIter_IterNextFunc *iternext;
char **dataptr;
npy_intp *strides;
npy_intp *countptr, count;
npy_intp *coordsptr = (npy_intp *)PyArray_DATA(ret_arr);
iternext = NpyIter_GetIterNext(iter, NULL);
if (iternext == NULL) {
goto fail;
}
dataptr = NpyIter_GetDataPtrArray(iter);
strides = NpyIter_GetInnerStrideArray(iter);
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
count = *countptr;
if (unravel_index_loop_forder(dimensions.len, dimensions.ptr,
unravel_size, count, *dataptr, *strides,
coordsptr) != NPY_SUCCEED) {
goto fail;
}
coordsptr += count*dimensions.len;
} while(iternext(iter));
}
}
else {
PyErr_SetString(PyExc_ValueError,
"only 'C' or 'F' order is permitted");
goto fail;
}
/* Now make a tuple of views, one per index */
ret_tuple = PyTuple_New(dimensions.len);
if (ret_tuple == NULL) {
goto fail;
}
for (i = 0; i < dimensions.len; ++i) {
PyArrayObject *view;
view = (PyArrayObject *)PyArray_New(&PyArray_Type, ret_ndim-1,
ret_dims, NPY_INTP,
ret_strides,
PyArray_BYTES(ret_arr) + i*sizeof(npy_intp),
0, 0, NULL);
if (view == NULL) {
goto fail;
}
Py_INCREF(ret_arr);
if (PyArray_SetBaseObject(view, (PyObject *)ret_arr) < 0) {
Py_DECREF(view);
goto fail;
}
PyTuple_SET_ITEM(ret_tuple, i, PyArray_Return(view));
}
Py_DECREF(ret_arr);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return ret_tuple;
fail:
Py_XDECREF(ret_tuple);
Py_XDECREF(ret_arr);
Py_XDECREF(dtype);
Py_XDECREF(indices);
PyDimMem_FREE(dimensions.ptr);
NpyIter_Deallocate(iter);
return NULL;
}
PyObject *getEuclideanDistMat(python::object descripMat) {
// Bit of a pain involved here, we accept three types of PyObjects here
// 1. A Numeric Array
// - first find what 'type' of entry we have (float, double and int is all
// we recognize for now)
// - then point to contiguous piece of memory from the array that contains
// the data with a type*
// - then make a new type** pointer so that double index into this
// contiguous memory will work
// and then pass it along to the distance calculator
// 2. A list of Numeric Vector (or 1D arrays)
// - in this case wrap descripMat with a PySequenceHolder<type*> where
// type is the
// type of entry in vector (accepted types are int, double and float
// - Then pass the PySequenceHolder to the metrci calculator
// 3. A list (or tuple) of lists (or tuple)
// - In this case other than wrapping descripMat with a PySequenceHolder
// each of the indivual list in there are also wrapped by a
// PySequenceHolder
// - so the distance calculator is passed in a
// "PySequenceHolder<PySequenceHolder<double>>"
// - FIX: not that we always convert entry values to double here, even if
// we passed
// in a list of list of ints (or floats). Given that lists can be
// heterogeneous, I do not
// know how to ask a list what type of entries if contains.
//
// OK my brain is going to explode now
// first deal with situation where we have an Numeric Array
PyObject *descMatObj = descripMat.ptr();
PyArrayObject *distRes;
if (PyArray_Check(descMatObj)) {
// get the dimensions of the array
int nrows = ((PyArrayObject *)descMatObj)->dimensions[0];
int ncols = ((PyArrayObject *)descMatObj)->dimensions[1];
int i;
CHECK_INVARIANT((nrows > 0) && (ncols > 0), "");
npy_intp dMatLen = nrows * (nrows - 1) / 2;
// now that we have the dimensions declare the distance matrix which is
// always a
// 1D double array
distRes = (PyArrayObject *)PyArray_SimpleNew(1, &dMatLen, NPY_DOUBLE);
// grab a pointer to the data in the array so that we can directly put
// values in there
// and avoid copying :
double *dMat = (double *)distRes->data;
PyArrayObject *copy;
copy = (PyArrayObject *)PyArray_ContiguousFromObject(
descMatObj, ((PyArrayObject *)descMatObj)->descr->type_num, 2, 2);
// if we have double array
if (((PyArrayObject *)descMatObj)->descr->type_num == NPY_DOUBLE) {
double *desc = (double *)copy->data;
// REVIEW: create an adaptor object to hold a double * and support
// operator[]() so that we don't have to do this stuff:
// here is the 2D array trick this so that when the distance calaculator
// asks for desc2D[i] we basically get the ith row as double*
double **desc2D = new double *[nrows];
for (i = 0; i < nrows; i++) {
desc2D[i] = desc;
desc += ncols;
}
MetricMatrixCalc<double **, double *> mmCalc;
mmCalc.setMetricFunc(&EuclideanDistanceMetric<double *, double *>);
mmCalc.calcMetricMatrix(desc2D, nrows, ncols, dMat);
delete[] desc2D;
// we got the distance matrix we are happy so return
return PyArray_Return(distRes);
}
// if we have a float array
else if (((PyArrayObject *)descMatObj)->descr->type_num == NPY_FLOAT) {
float *desc = (float *)copy->data;
float **desc2D = new float *[nrows];
for (i = 0; i < nrows; i++) {
desc2D[i] = desc;
desc += ncols;
}
MetricMatrixCalc<float **, float *> mmCalc;
mmCalc.setMetricFunc(&EuclideanDistanceMetric<float *, float *>);
mmCalc.calcMetricMatrix(desc2D, nrows, ncols, dMat);
delete[] desc2D;
return PyArray_Return(distRes);
}
// if we have an interger array
else if (((PyArrayObject *)descMatObj)->descr->type_num == NPY_INT) {
int *desc = (int *)copy->data;
int **desc2D = new int *[nrows];
for (i = 0; i < nrows; i++) {
desc2D[i] = desc;
desc += ncols;
}
MetricMatrixCalc<int **, int *> mmCalc;
mmCalc.setMetricFunc(&EuclideanDistanceMetric<int *, int *>);
mmCalc.calcMetricMatrix(desc2D, nrows, ncols, dMat);
delete[] desc2D;
return PyArray_Return(distRes);
} else {
// unreconiged type for the matrix, throw up
throw_value_error(
"The array has to be of type int, float, or double for "
"GetEuclideanDistMat");
}
} // done with an array input
else {
// REVIEW: removed a ton of code here
// we have probably have a list or a tuple
unsigned int ncols = 0;
unsigned int nrows =
python::extract<unsigned int>(descripMat.attr("__len__")());
CHECK_INVARIANT(nrows > 0, "Empty list passed in");
npy_intp dMatLen = nrows * (nrows - 1) / 2;
distRes = (PyArrayObject *)PyArray_SimpleNew(1, &dMatLen, NPY_DOUBLE);
double *dMat = (double *)distRes->data;
// assume that we a have a list of list of values (that can be extracted to
// double)
std::vector<PySequenceHolder<double> > dData;
dData.reserve(nrows);
for (unsigned int i = 0; i < nrows; i++) {
// PySequenceHolder<double> row(seq[i]);
PySequenceHolder<double> row(descripMat[i]);
if (i == 0) {
ncols = row.size();
} else if (row.size() != ncols) {
throw_value_error("All subsequences must be the same length");
}
dData.push_back(row);
}
MetricMatrixCalc<std::vector<PySequenceHolder<double> >,
PySequenceHolder<double> > mmCalc;
mmCalc.setMetricFunc(&EuclideanDistanceMetric<PySequenceHolder<double>,
PySequenceHolder<double> >);
mmCalc.calcMetricMatrix(dData, nrows, ncols, dMat);
}
return PyArray_Return(distRes);
}
PyObject *
solve(PyObject * self, PyObject * args)
{
enum ApplicationReturnStatus status; /* Solve return code */
int i;
int n;
/* Return values */
problem *temp = (problem *) self;
IpoptProblem nlp = (IpoptProblem) (temp->nlp);
DispatchData *bigfield = (DispatchData *) (temp->data);
/* int dX[1]; */
npy_intp dX[1];
PyArrayObject *x = NULL, *mL = NULL, *mU = NULL;
Number obj; /* objective value */
PyObject *retval = NULL;
PyArrayObject *x0 = NULL;
PyObject *myuserdata = NULL;
Number *newx0 = NULL;
if (!PyArg_ParseTuple(args, "O!|O", &PyArray_Type, &x0, &myuserdata)) {
retval = NULL;
goto done;
}
if (myuserdata != NULL) {
bigfield->userdata = myuserdata;
/*
* logger("[PyIPOPT] User specified data field to callback
* function.\n");
*/
}
if (nlp == NULL) {
PyErr_SetString(PyExc_TypeError,
"nlp objective passed to solve is NULL\n Problem created?\n");
retval = NULL;
goto done;
}
if (bigfield->eval_h_python == NULL) {
AddIpoptStrOption(nlp, "hessian_approximation", "limited-memory");
/* logger("Can't find eval_h callback function\n"); */
}
/* allocate space for the initial point and set the values */
npy_intp *dim = ((PyArrayObject *) x0)->dimensions;
n = dim[0];
dX[0] = n;
x = (PyArrayObject *) PyArray_SimpleNew(1, dX, PyArray_DOUBLE);
if (!x) {
retval = PyErr_NoMemory();
goto done;
}
newx0 = (Number *) malloc(sizeof(Number) * n);
if (!newx0) {
retval = PyErr_NoMemory();
goto done;
}
double *xdata = (double *) x0->data;
for (i = 0; i < n; i++)
newx0[i] = xdata[i];
mL = (PyArrayObject *) PyArray_SimpleNew(1, dX, PyArray_DOUBLE);
mU = (PyArrayObject *) PyArray_SimpleNew(1, dX, PyArray_DOUBLE);
/* For status code, see IpReturnCodes_inc.h in Ipopt */
status = IpoptSolve(nlp, newx0, NULL, &obj, NULL, (double *) mL->data, (double *) mU->data, (UserDataPtr) bigfield);
double* return_x_data = (double *) x->data;
for (i = 0; i < n; i++) {
return_x_data[i] = newx0[i];
}
retval = Py_BuildValue(
"OOOdO",
PyArray_Return(x),
PyArray_Return(mL),
PyArray_Return(mU),
obj,
Py_BuildValue("i", status)
);
goto done;
done:
/* clean up and return */
if (retval == NULL) {
Py_XDECREF(x);
Py_XDECREF(mL);
Py_XDECREF(mU);
}
free(newx0);
return retval;
}
PyObject * vl_ikmeans_python(
PyArrayObject & inputData,
int K,
int max_niters,
char * method,
int verb)
{
// check types
assert(inputData.descr->type_num == PyArray_UBYTE);
assert(inputData.flags & NPY_FORTRAN);
npy_intp M, N;
int err = 0;
vl_uint8 * data;
VlIKMFilt *ikmf;
M = inputData.dimensions[0]; /* n of components */
N = inputData.dimensions[1]; /* n of elements */
// K must be a positive integer not greater than the number of data.
assert(K>0 && K<=N);
int method_type = VL_IKM_LLOYD;
if (strcmp("lloyd", method) == 0) {
method_type = VL_IKM_LLOYD;
} else if (strcmp("elkan", method) == 0) {
method_type = VL_IKM_ELKAN;
} else {
assert(0);
}
/* ------------------------------------------------------------------
* Do the job
* --------------------------------------------------------------- */
if (verb) {
char const * method_name = 0;
switch (method_type) {
case VL_IKM_LLOYD:
method_name = "Lloyd";
break;
case VL_IKM_ELKAN:
method_name = "Elkan";
break;
default:
assert (0);
}
printf("ikmeans: MaxInters = %d\n", max_niters);
printf("ikmeans: Method = %s\n", method_name);
}
data = (vl_uint8*) inputData.data;
ikmf = vl_ikm_new(method_type);
vl_ikm_set_verbosity(ikmf, verb);
vl_ikm_set_max_niters(ikmf, max_niters);
vl_ikm_init_rand_data(ikmf, data, M, N, K);
err = vl_ikm_train(ikmf, data, N);
if (err)
printf("ikmeans: possible overflow!");
/* ------------------------------------------------------------------
* Return results
* --------------------------------------------------------------- */
// allocate PyArrayObject for centers (column-majored)
npy_intp dims[2];
dims[0] = M;
dims[1] = K;
PyArrayObject * centers = (PyArrayObject*) PyArray_NewFromDescr(
&PyArray_Type, PyArray_DescrFromType(PyArray_INT32),
2, dims, NULL, NULL, NPY_F_CONTIGUOUS, NULL);
// copy data
int * centers_data = (int*) centers->data;
memcpy(centers_data, vl_ikm_get_centers(ikmf), sizeof(vl_ikm_acc) * M * K);
// allocate PyArrayObject for cluster assignment array
PyArrayObject * asgn = (PyArrayObject*) PyArray_SimpleNew(
1, (npy_intp*) &N, PyArray_UINT32);
// copy data
unsigned int * asgn_data = (unsigned int*) asgn->data;
int j;
vl_ikm_push(ikmf, (vl_uint*) asgn_data, data, N);
// clean
vl_ikm_delete(ikmf);
if (verb) {
printf("ikmeans: done\n");
}
// construct tuple to return both results: (regions, frames)
PyObject * tuple = PyTuple_New(2);
PyTuple_SetItem(tuple, 0, PyArray_Return(centers));
PyTuple_SetItem(tuple, 1, PyArray_Return(asgn));
return tuple;
}
static PyObject *
odepack_odeint(PyObject *dummy, PyObject *args, PyObject *kwdict)
{
PyObject *fcn, *y0, *p_tout, *o_rtol = NULL, *o_atol = NULL;
PyArrayObject *ap_y = NULL, *ap_yout = NULL;
PyArrayObject *ap_rtol = NULL, *ap_atol = NULL;
PyArrayObject *ap_tout = NULL;
PyObject *extra_args = NULL;
PyObject *Dfun = Py_None;
int neq, itol = 1, itask = 1, istate = 1, iopt = 0, lrw, *iwork, liw, jt = 4;
double *y, t, *tout, *rtol, *atol, *rwork;
double h0 = 0.0, hmax = 0.0, hmin = 0.0;
int ixpr = 0, mxstep = 0, mxhnil = 0, mxordn = 12, mxords = 5, ml = -1, mu = -1;
PyObject *o_tcrit = NULL;
PyArrayObject *ap_tcrit = NULL;
PyArrayObject *ap_hu = NULL, *ap_tcur = NULL, *ap_tolsf = NULL, *ap_tsw = NULL;
PyArrayObject *ap_nst = NULL, *ap_nfe = NULL, *ap_nje = NULL, *ap_nqu = NULL;
PyArrayObject *ap_mused = NULL;
int imxer = 0, lenrw = 0, leniw = 0, col_deriv = 0;
npy_intp out_sz = 0, dims[2];
int k, ntimes, crit_ind = 0;
int allocated = 0, full_output = 0, numcrit = 0;
double *yout, *yout_ptr, *tout_ptr, *tcrit;
double *wa;
static char *kwlist[] = {"fun", "y0", "t", "args", "Dfun", "col_deriv",
"ml", "mu", "full_output", "rtol", "atol", "tcrit",
"h0", "hmax", "hmin", "ixpr", "mxstep", "mxhnil",
"mxordn", "mxords", NULL};
odepack_params save_params;
if (!PyArg_ParseTupleAndKeywords(args, kwdict, "OOO|OOiiiiOOOdddiiiii", kwlist,
&fcn, &y0, &p_tout, &extra_args, &Dfun,
&col_deriv, &ml, &mu, &full_output, &o_rtol, &o_atol,
&o_tcrit, &h0, &hmax, &hmin, &ixpr, &mxstep, &mxhnil,
&mxordn, &mxords)) {
return NULL;
}
if (o_tcrit == Py_None) {
o_tcrit = NULL;
}
if (o_rtol == Py_None) {
o_rtol = NULL;
}
if (o_atol == Py_None) {
o_atol = NULL;
}
/* Set up jt, ml, and mu */
if (Dfun == Py_None) {
/* set jt for internally generated */
jt++;
}
if (ml < 0 && mu < 0) {
/* neither ml nor mu given, mark jt for full jacobian */
jt -= 3;
}
if (ml < 0) {
/* if one but not both are given */
ml = 0;
}
if (mu < 0) {
mu = 0;
}
/* Stash the current global_params in save_params. */
memcpy(&save_params, &global_params, sizeof(save_params));
if (extra_args == NULL) {
if ((extra_args = PyTuple_New(0)) == NULL) {
goto fail;
}
}
else {
Py_INCREF(extra_args); /* We decrement on exit. */
}
if (!PyTuple_Check(extra_args)) {
PYERR(odepack_error, "Extra arguments must be in a tuple");
}
if (!PyCallable_Check(fcn) || (Dfun != Py_None && !PyCallable_Check(Dfun))) {
PYERR(odepack_error, "The function and its Jacobian must be callable functions.");
}
/* Set global_params from the function arguments. */
global_params.python_function = fcn;
global_params.extra_arguments = extra_args;
global_params.python_jacobian = Dfun;
global_params.jac_transpose = !(col_deriv);
global_params.jac_type = jt;
/* Initial input vector */
ap_y = (PyArrayObject *) PyArray_ContiguousFromObject(y0, NPY_DOUBLE, 0, 0);
if (ap_y == NULL) {
goto fail;
}
if (PyArray_NDIM(ap_y) > 1) {
PyErr_SetString(PyExc_ValueError, "Initial condition y0 must be one-dimensional.");
goto fail;
}
y = (double *) PyArray_DATA(ap_y);
neq = PyArray_Size((PyObject *) ap_y);
dims[1] = neq;
/* Set of output times for integration */
ap_tout = (PyArrayObject *) PyArray_ContiguousFromObject(p_tout, NPY_DOUBLE, 0, 0);
if (ap_tout == NULL) {
goto fail;
}
if (PyArray_NDIM(ap_tout) > 1) {
PyErr_SetString(PyExc_ValueError, "Output times t must be one-dimensional.");
goto fail;
}
tout = (double *) PyArray_DATA(ap_tout);
ntimes = PyArray_Size((PyObject *)ap_tout);
dims[0] = ntimes;
t = tout[0];
/* Setup array to hold the output evaluations*/
ap_yout= (PyArrayObject *) PyArray_SimpleNew(2,dims,NPY_DOUBLE);
if (ap_yout== NULL) {
goto fail;
}
yout = (double *) PyArray_DATA(ap_yout);
/* Copy initial vector into first row of output */
memcpy(yout, y, neq*sizeof(double)); /* copy initial value to output */
yout_ptr = yout + neq; /* set output pointer to next position */
itol = setup_extra_inputs(&ap_rtol, o_rtol, &ap_atol, o_atol, &ap_tcrit,
o_tcrit, &numcrit, neq);
if (itol < 0 ) {
goto fail; /* Something didn't work */
}
rtol = (double *) PyArray_DATA(ap_rtol);
atol = (double *) PyArray_DATA(ap_atol);
if (o_tcrit != NULL) {
tcrit = (double *)(PyArray_DATA(ap_tcrit));
}
/* Find size of working arrays*/
if (compute_lrw_liw(&lrw, &liw, neq, jt, ml, mu, mxordn, mxords) < 0) {
goto fail;
}
if ((wa = (double *)malloc(lrw*sizeof(double) + liw*sizeof(int)))==NULL) {
PyErr_NoMemory();
goto fail;
}
allocated = 1;
rwork = wa;
iwork = (int *)(wa + lrw);
iwork[0] = ml;
iwork[1] = mu;
if (h0 != 0.0 || hmax != 0.0 || hmin != 0.0 || ixpr != 0 || mxstep != 0 ||
mxhnil != 0 || mxordn != 0 || mxords != 0) {
rwork[4] = h0;
rwork[5] = hmax;
rwork[6] = hmin;
iwork[4] = ixpr;
iwork[5] = mxstep;
iwork[6] = mxhnil;
iwork[7] = mxordn;
iwork[8] = mxords;
iopt = 1;
}
istate = 1;
k = 1;
/* If full output make some useful output arrays */
if (full_output) {
out_sz = ntimes-1;
ap_hu = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_DOUBLE);
ap_tcur = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_DOUBLE);
ap_tolsf = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_DOUBLE);
ap_tsw = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_DOUBLE);
ap_nst = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_INT);
ap_nfe = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_INT);
ap_nje = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_INT);
ap_nqu = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_INT);
ap_mused = (PyArrayObject *) PyArray_SimpleNew(1, &out_sz, NPY_INT);
if (ap_hu == NULL || ap_tcur == NULL || ap_tolsf == NULL ||
ap_tsw == NULL || ap_nst == NULL || ap_nfe == NULL ||
ap_nje == NULL || ap_nqu == NULL || ap_mused == NULL) {
goto fail;
}
}
if (o_tcrit != NULL) {
/* There are critical points */
itask = 4;
rwork[0] = *tcrit;
}
while (k < ntimes && istate > 0) { /* loop over desired times */
tout_ptr = tout + k;
/* Use tcrit if relevant */
if (itask == 4 && *tout_ptr > *(tcrit + crit_ind)) {
crit_ind++;
rwork[0] = *(tcrit+crit_ind);
}
if (crit_ind >= numcrit) {
itask = 1; /* No more critical values */
}
LSODA(ode_function, &neq, y, &t, tout_ptr, &itol, rtol, atol, &itask,
&istate, &iopt, rwork, &lrw, iwork, &liw,
ode_jacobian_function, &jt);
if (full_output) {
*((double *)PyArray_DATA(ap_hu) + (k-1)) = rwork[10];
*((double *)PyArray_DATA(ap_tcur) + (k-1)) = rwork[12];
*((double *)PyArray_DATA(ap_tolsf) + (k-1)) = rwork[13];
*((double *)PyArray_DATA(ap_tsw) + (k-1)) = rwork[14];
*((int *)PyArray_DATA(ap_nst) + (k-1)) = iwork[10];
*((int *)PyArray_DATA(ap_nfe) + (k-1)) = iwork[11];
*((int *)PyArray_DATA(ap_nje) + (k-1)) = iwork[12];
*((int *)PyArray_DATA(ap_nqu) + (k-1)) = iwork[13];
if (istate == -5 || istate == -4) {
imxer = iwork[15];
}
else {
imxer = -1;
}
lenrw = iwork[16];
leniw = iwork[17];
*((int *)PyArray_DATA(ap_mused) + (k-1)) = iwork[18];
}
if (PyErr_Occurred()) {
goto fail;
}
memcpy(yout_ptr, y, neq*sizeof(double)); /* copy integration result to output*/
yout_ptr += neq;
k++;
}
/* Restore global_params from the previously stashed save_params. */
memcpy(&global_params, &save_params, sizeof(save_params));
Py_DECREF(extra_args);
Py_DECREF(ap_atol);
Py_DECREF(ap_rtol);
Py_XDECREF(ap_tcrit);
Py_DECREF(ap_y);
Py_DECREF(ap_tout);
free(wa);
/* Do Full output */
if (full_output) {
return Py_BuildValue("N{s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:i,s:i,s:i,s:N}i",
PyArray_Return(ap_yout),
"hu", PyArray_Return(ap_hu),
"tcur", PyArray_Return(ap_tcur),
"tolsf", PyArray_Return(ap_tolsf),
"tsw", PyArray_Return(ap_tsw),
"nst", PyArray_Return(ap_nst),
"nfe", PyArray_Return(ap_nfe),
"nje", PyArray_Return(ap_nje),
"nqu", PyArray_Return(ap_nqu),
"imxer", imxer,
"lenrw", lenrw,
"leniw", leniw,
"mused", PyArray_Return(ap_mused),
istate);
}
else {
return Py_BuildValue("Ni", PyArray_Return(ap_yout), istate);
}
fail:
/* Restore global_params from the previously stashed save_params. */
memcpy(&global_params, &save_params, sizeof(save_params));
Py_XDECREF(extra_args);
Py_XDECREF(ap_y);
Py_XDECREF(ap_rtol);
Py_XDECREF(ap_atol);
Py_XDECREF(ap_tcrit);
Py_XDECREF(ap_tout);
Py_XDECREF(ap_yout);
if (allocated) {
free(wa);
}
if (full_output) {
Py_XDECREF(ap_hu);
Py_XDECREF(ap_tcur);
Py_XDECREF(ap_tolsf);
Py_XDECREF(ap_tsw);
Py_XDECREF(ap_nst);
Py_XDECREF(ap_nfe);
Py_XDECREF(ap_nje);
Py_XDECREF(ap_nqu);
Py_XDECREF(ap_mused);
}
return NULL;
}
static PyObject * fillDensityGrid(PyObject *self, PyObject *args){
/*
Function to fill the density grid based using the CT grid and a conversion table
Input:
ctGrid : 3D numpy array representing the CT
conversionTable :2D Array: 2 rows, n columns: row 0 : CT values, row 1 :density values
Output:
3D numpy array representing a new CT grid.
*/
//Initialize pointers that will receive input data
PyArrayObject * ctGrid = NULL; // We assume that ct Value have been previously correctly scaled.
PyArrayObject * conversionTable = NULL; //
//Parse input args:
if (!PyArg_ParseTuple(args, "O!O!",
&PyArray_Type,&ctGrid,
&PyArray_Type,&conversionTable)) return NULL;
if(!ctGrid) return NULL;
if(!conversionTable) return NULL;
//Cast values to float values: numpy creates array with float values
if (ctGrid->descr->type_num != NPY_FLOAT) ctGrid = (PyArrayObject*)PyArray_Cast(ctGrid,PyArray_FLOAT);
if (conversionTable->descr->type_num != NPY_FLOAT) conversionTable = (PyArrayObject*)PyArray_Cast(conversionTable,PyArray_FLOAT);
float * dataDensityGrid, * dataCTGrid, * dataConversion;
dataCTGrid = (float*) ctGrid -> data;
dataConversion = (float*) conversionTable -> data;
int nbColsConvTab = conversionTable->dimensions[1];
int nbFramesCT = ctGrid->dimensions[0];
int nbRowsCT = ctGrid->dimensions[1];
int nbColsCT = ctGrid-> dimensions[2];
int dimGrid[] ={nbFramesCT,nbRowsCT,nbColsCT} ;
PyArrayObject * densGrid = NULL;
// create output grid
if( ( densGrid = (PyArrayObject *) PyArray_FromDims(ctGrid->nd, dimGrid, PyArray_FLOAT) ) == NULL ){
PyErr_SetString(PyExc_ValueError,"Error - malloc in fillDensityGrid - densGrid allocation failed\n");
}
dataDensityGrid = (float*) densGrid -> data;
float * slope, * intercept;
slope = (float *) malloc(sizeof(float) * (nbColsConvTab-1) );
if(!slope) {
PyErr_SetString(PyExc_ValueError,"Error allocation slope tab in fillDensity\n");
}
intercept = (float *) malloc(sizeof(float) * (nbColsConvTab-1) );
if(!intercept) {
PyErr_SetString(PyExc_ValueError,"Error allocation intercept tab in fillDensity\n");
}
for(int i = 0; i < nbColsConvTab-1; i++){
slope[i] = FLT_MAX;
intercept[i] = FLT_MAX;
}
float ctValue;
float convertedValue;
int idx;
for(int f = 0 ; f < nbFramesCT ; f++){ // End - iterate through frames
for(int r = 0 ; r < nbRowsCT ; r++){ // End - iterate through rows
for(int c = 0 ; c < nbColsCT ; c++){ // End - iterate through columns
idx = f * nbColsCT * nbRowsCT + r * nbColsCT + c;
ctValue = dataCTGrid[ idx ];
convertedValue = 0;
if( ctValue <= dataConversion[0] && ctValue >= (dataConversion[0] - absolute(dataConversion[0]*0.1) )) {
convertedValue = dataConversion[1 * nbColsConvTab];
}
else{
if ( ctValue >= dataConversion[nbColsConvTab - 1] && ctValue <= (dataConversion[nbColsConvTab - 1] + absolute(dataConversion[nbColsConvTab - 1]*0.1)) ){
convertedValue = dataConversion[1 * nbColsConvTab + nbColsConvTab - 1];
}
else{
if( ctValue > dataConversion[0] && ctValue < dataConversion[nbColsConvTab - 1])
{
for( int i = 0 ; i < nbColsConvTab-1 ; i ++){
if(slope[i] == FLT_MAX){
slope[i] = (dataConversion[nbColsConvTab + i]- dataConversion[nbColsConvTab + i + 1])/ ( dataConversion[i]- dataConversion[i+1]);
}
if(intercept[i] == FLT_MAX){
intercept[i] = dataConversion[nbColsConvTab + i] - dataConversion[i] * slope[i];
}
if(ctValue >= dataConversion[i] && ctValue < dataConversion[i+1]){
convertedValue = ctValue * slope[i] + intercept[i];
break;
}
}
}
else{
printf("Error- fill density array - ct value out of range [%f , %f]: ctValue = %f\n",dataConversion[0],dataConversion[nbColsConvTab - 1],ctValue);
PyErr_SetString(PyExc_ValueError,"Error ct value in fill density array...");
}
}
}
dataDensityGrid[ idx ] = convertedValue;
} // End - iterate through columns
} // End - iterate through rows
} // End - iterate through frames
free(slope);
free(intercept);
return PyArray_Return(densGrid);
}
/* generates Python output from the raw output from DODRC */
PyObject *gen_output(int n, int m, int np, int nq, int ldwe, int ld2we,
PyArrayObject * beta, PyArrayObject * work,
PyArrayObject * iwork, int isodr, int info,
int full_output)
{
PyArrayObject *sd_beta, *cov_beta;
int delta, eps, xplus, fn, sd, vcv, rvar, wss, wssde, wssep, rcond;
int eta, olmav, tau, alpha, actrs, pnorm, rnors, prers, partl, sstol;
int taufc, apsma, betao, betac, betas, betan, s, ss, ssf, qraux, u;
int fs, fjacb, we1, diff, delts, deltn, t, tt, omega, fjacd;
int wrk1, wrk2, wrk3, wrk4, wrk5, wrk6, wrk7, lwkmn;
PyObject *retobj;
npy_intp dim1[1], dim2[2];
if (info == 50005) {
/* fatal error in fcn call; return NULL to propogate the exception */
return NULL;
}
lwkmn = work->dimensions[0];
F_FUNC(dwinf,DWINF)(&n, &m, &np, &nq, &ldwe, &ld2we, &isodr,
&delta, &eps, &xplus, &fn, &sd, &vcv, &rvar, &wss, &wssde,
&wssep, &rcond, &eta, &olmav, &tau, &alpha, &actrs, &pnorm,
&rnors, &prers, &partl, &sstol, &taufc, &apsma, &betao, &betac,
&betas, &betan, &s, &ss, &ssf, &qraux, &u, &fs, &fjacb, &we1,
&diff, &delts, &deltn, &t, &tt, &omega, &fjacd, &wrk1, &wrk2,
&wrk3, &wrk4, &wrk5, &wrk6, &wrk7, &lwkmn);
/* convert FORTRAN indices to C indices */
delta--;
eps--;
xplus--;
fn--;
sd--;
vcv--;
rvar--;
wss--;
wssde--;
wssep--;
rcond--;
eta--;
olmav--;
tau--;
alpha--;
actrs--;
pnorm--;
rnors--;
prers--;
partl--;
sstol--;
taufc--;
apsma--;
betao--;
betac--;
betas--;
betan--;
s--;
ss--;
ssf--;
qraux--;
u--;
fs--;
fjacb--;
we1--;
diff--;
delts--;
deltn--;
t--;
tt--;
omega--;
fjacd--;
wrk1--;
wrk2--;
wrk3--;
wrk4--;
wrk5--;
wrk6--;
wrk7--;
dim1[0] = beta->dimensions[0];
sd_beta = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);
dim2[0] = beta->dimensions[0];
dim2[1] = beta->dimensions[0];
cov_beta = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);
memcpy(sd_beta->data, (void *)((double *)(work->data) + sd),
np * sizeof(double));
memcpy(cov_beta->data, (void *)((double *)(work->data) + vcv),
np * np * sizeof(double));
if (!full_output)
{
retobj = Py_BuildValue("OOO", PyArray_Return(beta),
PyArray_Return(sd_beta),
PyArray_Return(cov_beta));
Py_DECREF((PyObject *) sd_beta);
Py_DECREF((PyObject *) cov_beta);
return retobj;
}
else
{
PyArrayObject *deltaA, *epsA, *xplusA, *fnA;
double res_var, sum_square, sum_square_delta, sum_square_eps;
double inv_condnum, rel_error;
PyObject *work_ind;
work_ind =
Py_BuildValue
("{s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i}",
"delta", delta, "eps", eps, "xplus", xplus, "fn", fn, "sd", sd, "sd",
vcv, "rvar", rvar, "wss", wss, "wssde", wssde, "wssep", wssep,
"rcond", rcond, "eta", eta, "olmav", olmav, "tau", tau, "alpha",
alpha, "actrs", actrs, "pnorm", pnorm, "rnors", rnors, "prers",
prers, "partl", partl, "sstol", sstol, "taufc", taufc, "apsma",
apsma, "betao", betao, "betac", betac, "betas", betas, "betan",
betan, "s", s, "ss", ss, "ssf", ssf, "qraux", qraux, "u", u, "fs",
fs, "fjacb", fjacb, "we1", we1, "diff", diff, "delts", delts,
"deltn", deltn, "t", t, "tt", tt, "omega", omega, "fjacd", fjacd,
"wrk1", wrk1, "wrk2", wrk2, "wrk3", wrk3, "wrk4", wrk4, "wrk5", wrk5,
"wrk6", wrk6, "wrk7", wrk7);
if (m == 1)
{
dim1[0] = n;
deltaA =
(PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);
xplusA =
(PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);
}
else
{
dim2[0] = m;
dim2[1] = n;
deltaA =
(PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);
xplusA =
(PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);
}
if (nq == 1)
{
dim1[0] = n;
epsA = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);
fnA = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);
}
else
{
dim2[0] = nq;
dim2[1] = n;
epsA = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);
fnA = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);
}
memcpy(deltaA->data, (void *)((double *)(work->data) + delta),
m * n * sizeof(double));
memcpy(epsA->data, (void *)((double *)(work->data) + eps),
nq * n * sizeof(double));
memcpy(xplusA->data, (void *)((double *)(work->data) + xplus),
m * n * sizeof(double));
memcpy(fnA->data, (void *)((double *)(work->data) + fn),
nq * n * sizeof(double));
res_var = *((double *)(work->data) + rvar);
sum_square = *((double *)(work->data) + wss);
sum_square_delta = *((double *)(work->data) + wssde);
sum_square_eps = *((double *)(work->data) + wssep);
inv_condnum = *((double *)(work->data) + rcond);
rel_error = *((double *)(work->data) + eta);
retobj =
Py_BuildValue
("OOO{s:O,s:O,s:O,s:O,s:d,s:d,s:d,s:d,s:d,s:d,s:O,s:O,s:O,s:i}",
PyArray_Return(beta), PyArray_Return(sd_beta),
PyArray_Return(cov_beta), "delta", PyArray_Return(deltaA), "eps",
PyArray_Return(epsA), "xplus", PyArray_Return(xplusA), "y",
PyArray_Return(fnA), "res_var", res_var, "sum_square", sum_square,
"sum_square_delta", sum_square_delta, "sum_square_eps",
sum_square_eps, "inv_condnum", inv_condnum, "rel_error", rel_error,
"work", PyArray_Return(work), "work_ind", work_ind, "iwork",
PyArray_Return(iwork), "info", info);
Py_DECREF((PyObject *) sd_beta);
Py_DECREF((PyObject *) cov_beta);
Py_DECREF((PyObject *) deltaA);
Py_DECREF((PyObject *) epsA);
Py_DECREF((PyObject *) xplusA);
Py_DECREF((PyObject *) fnA);
Py_DECREF((PyObject *) work_ind);
return retobj;
}
}
// =============================================================================
PyObject * Epetra_NumPyIntSerialDenseMatrix::A()
{
Py_INCREF(array);
return PyArray_Return(array);
}
static PyObject*
pydat_get(HDSObject *self)
{
// Recover C-pointer passed via Python
HDSLoc* loc = HDS_retrieve_locator(self);
// guard against structures
int state, status = SAI__OK;
errBegin(&status);
datStruc(loc, &state, &status);
if (raiseHDSException(&status)) return NULL;
if(state) {
PyErr_SetString(PyExc_IOError, "dat_get error: cannot use on structures");
return NULL;
}
// get type
char typ_str[DAT__SZTYP+1];
datType(loc, typ_str, &status);
// get shape
const int NDIMX=7;
int ndim;
hdsdim tdim[NDIMX];
datShape(loc, NDIMX, tdim, &ndim, &status);
if (raiseHDSException(&status)) return NULL;
PyArrayObject* arr = NULL;
// Either return values as a single scalar or a numpy array
// Reverse order of dimensions
npy_intp rdim[NDIMX];
int i;
for(i=0; i<ndim; i++) rdim[i] = tdim[ndim-i-1];
if(strcmp(typ_str, "_INTEGER") == 0 || strcmp(typ_str, "_LOGICAL") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_INT);
} else if(strcmp(typ_str, "_REAL") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_FLOAT);
} else if(strcmp(typ_str, "_DOUBLE") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_DOUBLE);
} else if(strncmp(typ_str, "_CHAR", 5) == 0) {
// work out the number of bytes
size_t nbytes;
datLen(loc, &nbytes, &status);
if (status != SAI__OK) goto fail;
int ncdim = 1+ndim;
int cdim[ncdim];
cdim[0] = nbytes+1;
for(i=0; i<ndim; i++) cdim[i+1] = rdim[i];
PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_STRING);
descr->elsize = nbytes;
arr = (PyArrayObject*) PyArray_NewFromDescr(&PyArray_Type, descr, ndim, rdim,
NULL, NULL, 0, NULL);
} else if(strcmp(typ_str, "_WORD") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_SHORT);
} else if(strcmp(typ_str, "_UWORD") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_USHORT);
} else if(strcmp(typ_str, "_BYTE") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_BYTE);
} else if(strcmp(typ_str, "_UBYTE") == 0) {
arr = (PyArrayObject*) PyArray_SimpleNew(ndim, rdim, NPY_UBYTE);
} else {
PyErr_SetString(PyExc_IOError, "dat_get: encountered an unimplemented type");
return NULL;
}
if(arr == NULL) goto fail;
datGet(loc, typ_str, ndim, tdim, arr->data, &status);
if(status != SAI__OK) goto fail;
return PyArray_Return(arr);
fail:
raiseHDSException(&status);
Py_XDECREF(arr);
return NULL;
};
static PyObject *FIRsepsym2d(PyObject *NPY_UNUSED(dummy), PyObject *args)
{
PyObject *image=NULL, *hrow=NULL, *hcol=NULL;
PyArrayObject *a_image=NULL, *a_hrow=NULL, *a_hcol=NULL, *out=NULL;
int thetype, M, N, ret;
npy_intp outstrides[2], instrides[2];
if (!PyArg_ParseTuple(args, "OOO", &image, &hrow, &hcol)) return NULL;
thetype = PyArray_ObjectType(image, PyArray_FLOAT);
thetype = NPY_MIN(thetype, PyArray_CDOUBLE);
a_image = (PyArrayObject *)PyArray_FromObject(image, thetype, 2, 2);
a_hrow = (PyArrayObject *)PyArray_ContiguousFromObject(hrow, thetype, 1, 1);
a_hcol = (PyArrayObject *)PyArray_ContiguousFromObject(hcol, thetype, 1, 1);
if ((a_image == NULL) || (a_hrow == NULL) || (a_hcol==NULL)) goto fail;
out = (PyArrayObject *)PyArray_SimpleNew(2,DIMS(a_image),thetype);
if (out == NULL) goto fail;
M = DIMS(a_image)[0];
N = DIMS(a_image)[1];
convert_strides(STRIDES(a_image), instrides, ELSIZE(a_image), 2);
outstrides[0] = N;
outstrides[1] = 1;
switch (thetype) {
case PyArray_FLOAT:
ret = S_separable_2Dconvolve_mirror((float *)DATA(a_image),
(float *)DATA(out), M, N,
(float *)DATA(a_hrow),
(float *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
case PyArray_DOUBLE:
ret = D_separable_2Dconvolve_mirror((double *)DATA(a_image),
(double *)DATA(out), M, N,
(double *)DATA(a_hrow),
(double *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
#ifdef __GNUC__
case PyArray_CFLOAT:
ret = C_separable_2Dconvolve_mirror((__complex__ float *)DATA(a_image),
(__complex__ float *)DATA(out), M, N,
(__complex__ float *)DATA(a_hrow),
(__complex__ float *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
case PyArray_CDOUBLE:
ret = Z_separable_2Dconvolve_mirror((__complex__ double *)DATA(a_image),
(__complex__ double *)DATA(out), M, N,
(__complex__ double *)DATA(a_hrow),
(__complex__ double *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
#endif
default:
PYERR("Incorrect type.");
}
if (ret < 0) PYERR("Problem occured inside routine.");
Py_DECREF(a_image);
Py_DECREF(a_hrow);
Py_DECREF(a_hcol);
return PyArray_Return(out);
fail:
Py_XDECREF(a_image);
Py_XDECREF(a_hrow);
Py_XDECREF(a_hcol);
Py_XDECREF(out);
return NULL;
}
PyObject* _calcDensSlice(PyObject *self, PyObject *args) {
PyArrayObject *pos, *hsml, *mass, *pyGrid;
int npart, nx, ny, cells;
int dims[2];
double bx, by, cx, cy, cz;
double *data_pos, *data_hsml, *data_mass;
double *grid;
int part;
double px, py, pz, h, v, cpx, cpy, r2, h2;
double p[3];
int x, y;
int xmin, xmax, ymin, ymax, axis0, axis1;
double cellsizex, cellsizey;
time_t start;
start = clock();
axis0 = 0;
axis1 = 1;
if (!PyArg_ParseTuple( args, "O!O!O!iiddddd|ii:calcDensSlice( pos, hsml, mass, nx, ny, boxx, boxy, centerx, centery, centerz, [axis0, axis1] )", &PyArray_Type, &pos, &PyArray_Type, &hsml, &PyArray_Type, &mass, &nx, &ny, &bx, &by, &cx, &cy, &cz, &axis0, &axis1 )) {
return 0;
}
if (pos->nd != 2 || pos->dimensions[1] != 3 || pos->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "pos has to be of dimensions [n,3] and type double" );
return 0;
}
if (hsml->nd != 1 || hsml->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "hsml has to be of dimension [n] and type double" );
return 0;
}
if (mass->nd != 1 || mass->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "mass has to be of dimension [n] and type double" );
return 0;
}
npart = pos->dimensions[0];
if (npart != hsml->dimensions[0] || npart != mass->dimensions[0]) {
PyErr_SetString( PyExc_ValueError, "pos, hsml and mass have to have the same size in the first dimension" );
return 0;
}
dims[0] = nx;
dims[1] = ny;
pyGrid = (PyArrayObject *)PyArray_FromDims( 2, dims, PyArray_DOUBLE );
grid = (double*)pyGrid->data;
cells = nx*ny;
memset( grid, 0, cells*sizeof(double) );
cellsizex = bx / nx;
cellsizey = by / ny;
data_pos = (double*)pos->data;
data_hsml = (double*)hsml->data;
data_mass = (double*)mass->data;
for (part=0; part<npart; part++) {
p[0] = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
p[1] = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
p[2] = *data_pos;
data_pos = (double*)((char*)data_pos - 2*pos->strides[1] + pos->strides[0]);
px = p[ axis0 ];
py = p[ axis1 ];
pz = p[ 3 - axis0 - axis1 ];
h = *data_hsml;
data_hsml = (double*)((char*)data_hsml + hsml->strides[0]);
h2 = h*h;
v = *data_mass;
data_mass = (double*)((char*)data_mass + mass->strides[0]);
xmin = max( floor( (px - h - cx + 0.5*bx) / cellsizex ), 0 );
xmax = min( ceil( (px + h - cx + 0.5*bx) / cellsizex ), nx-1 );
ymin = max( floor( (py - h - cy + 0.5*by) / cellsizey ), 0 );
ymax = min( ceil( (py + h - cy + 0.5*by) / cellsizey ), ny-1 );
if (xmin < nx && ymin < ny && xmax >= 0 && ymax >= 0 && abs(pz-cz) < h) {
for (x=xmin; x<=xmax; x++) {
cpx = -0.5*bx + bx*(x+0.5)/nx;
for (y=ymin; y<=ymax; y++) {
cpy = -0.5*by + by*(y+0.5)/ny;
r2 = sqr(px-cpx-cx) + sqr(py-cpy-cy) + sqr(pz-cz);
if (r2 > h2) continue;
grid[x*ny + y] += _getkernel( h, r2 ) * v;
}
}
}
}
printf( "Calculation took %gs\n", ((double)clock()-(double)start)/CLOCKS_PER_SEC );
return PyArray_Return( pyGrid );
}
static PyObject *IIRsymorder1(PyObject *NPY_UNUSED(dummy), PyObject *args)
{
PyObject *sig=NULL;
PyArrayObject *a_sig=NULL, *out=NULL;
Py_complex c0, z1;
double precision = -1.0;
int thetype, N, ret;
npy_intp outstrides, instrides;
if (!PyArg_ParseTuple(args, "ODD|d", &sig, &c0, &z1, &precision))
return NULL;
thetype = PyArray_ObjectType(sig, PyArray_FLOAT);
thetype = NPY_MIN(thetype, PyArray_CDOUBLE);
a_sig = (PyArrayObject *)PyArray_FromObject(sig, thetype, 1, 1);
if ((a_sig == NULL)) goto fail;
out = (PyArrayObject *)PyArray_SimpleNew(1,DIMS(a_sig),thetype);
if (out == NULL) goto fail;
N = DIMS(a_sig)[0];
convert_strides(STRIDES(a_sig), &instrides, ELSIZE(a_sig), 1);
outstrides = 1;
switch (thetype) {
case PyArray_FLOAT:
{
float rc0 = c0.real;
float rz1 = z1.real;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-6;
ret = S_IIR_forback1 (rc0, rz1, (float *)DATA(a_sig),
(float *)DATA(out), N,
instrides, outstrides, (float )precision);
}
break;
case PyArray_DOUBLE:
{
double rc0 = c0.real;
double rz1 = z1.real;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-11;
ret = D_IIR_forback1 (rc0, rz1, (double *)DATA(a_sig),
(double *)DATA(out), N,
instrides, outstrides, precision);
}
break;
#ifdef __GNUC__
case PyArray_CFLOAT:
{
__complex__ float zc0 = c0.real + 1.0i*c0.imag;
__complex__ float zz1 = z1.real + 1.0i*z1.imag;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-6;
ret = C_IIR_forback1 (zc0, zz1, (__complex__ float *)DATA(a_sig),
(__complex__ float *)DATA(out), N,
instrides, outstrides, (float )precision);
}
break;
case PyArray_CDOUBLE:
{
__complex__ double zc0 = c0.real + 1.0i*c0.imag;
__complex__ double zz1 = z1.real + 1.0i*z1.imag;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-11;
ret = Z_IIR_forback1 (zc0, zz1, (__complex__ double *)DATA(a_sig),
(__complex__ double *)DATA(out), N,
instrides, outstrides, precision);
}
break;
#endif
default:
PYERR("Incorrect type.");
}
if (ret == 0) {
Py_DECREF(a_sig);
return PyArray_Return(out);
}
if (ret == -1) PYERR("Could not allocate enough memory.");
if (ret == -2) PYERR("|z1| must be less than 1.0");
if (ret == -3) PYERR("Sum to find symmetric boundary conditions did not converge.");
PYERR("Unknown error.");
fail:
Py_XDECREF(a_sig);
Py_XDECREF(out);
return NULL;
}
PyObject* _calcAbundGrid(PyObject *self, PyObject *args) {
PyArrayObject *pos, *hsml, *mass, *abund, *pyGrid;
int npart, nx, ny, nz, cells, nspecies;
int dims[4];
double bx, by, bz, cx, cy, cz;
double *data_pos, *data_hsml, *data_mass, *data_abund;
double *grid;
int part, species;
double *xnuc;
double px, py, pz, h, h2, m, cpx, cpy, cpz, r2, kk;
int x, y, z0, z1;
int xmin, xmax, ymin, ymax, zmin, zmax, zmid;
double cellsizex, cellsizey, cellsizez;
time_t start;
start = clock();
if (!PyArg_ParseTuple( args, "O!O!O!O!iiidddddd:calcAbundGrid( pos, hsml, mass, abund, nx, ny, nz, boxx, boxy, boxz, centerx, centery, centerz )", &PyArray_Type, &pos, &PyArray_Type, &hsml, &PyArray_Type, &mass, &PyArray_Type, &abund, &nx, &ny, &nz, &bx, &by, &bz, &cx, &cy, &cz )) {
return 0;
}
if (pos->nd != 2 || pos->dimensions[1] != 3 || pos->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "pos has to be of dimensions [n,3] and type double" );
return 0;
}
if (hsml->nd != 1 || hsml->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "hsml has to be of dimension [n] and type double" );
return 0;
}
if (mass->nd != 1 || mass->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "mass has to be of dimension [n] and type double" );
return 0;
}
if (abund->nd != 2 || abund->descr->type_num != PyArray_DOUBLE) {
PyErr_SetString( PyExc_ValueError, "abund has to be of dimension [n,nspecies] and type double" );
return 0;
}
nspecies = abund->dimensions[1];
npart = pos->dimensions[0];
if (npart != hsml->dimensions[0] || npart != mass->dimensions[0] || npart != abund->dimensions[0]) {
PyErr_SetString( PyExc_ValueError, "pos, hsml and abund have to have the same size in the first dimension" );
return 0;
}
xnuc = (double*)malloc( nspecies * sizeof( double ) );
dims[0] = nx;
dims[1] = ny;
dims[2] = nz;
dims[3] = nspecies+1;
pyGrid = (PyArrayObject *)PyArray_FromDims( 4, dims, PyArray_DOUBLE );
grid = (double*)pyGrid->data;
cells = nx*ny*nz*(nspecies+1);
memset( grid, 0, cells*sizeof(double) );
cellsizex = bx / nx;
cellsizey = by / ny;
cellsizez = bz / nz;
data_pos = (double*)pos->data;
data_hsml = (double*)hsml->data;
data_mass = (double*)mass->data;
data_abund = (double*)abund->data;
for (part=0; part<npart; part++) {
px = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
py = *data_pos;
data_pos = (double*)((char*)data_pos + pos->strides[1]);
pz = *data_pos;
data_pos = (double*)((char*)data_pos - 2*pos->strides[1] + pos->strides[0]);
h = *data_hsml;
data_hsml = (double*)((char*)data_hsml + hsml->strides[0]);
h2 = h*h;
m = *data_mass;
data_mass = (double*)((char*)data_mass + mass->strides[0]);
for (species = 0; species < nspecies; species++ ) {
xnuc[species] = *data_abund;
data_abund = (double*)((char*)data_abund + abund->strides[1]);
}
data_abund = (double*)((char*)data_abund - nspecies*abund->strides[1] + abund->strides[0]);
xmin = max( floor( (px - h - cx + 0.5*bx) / cellsizex ), 0 );
xmax = min( ceil( (px + h - cx + 0.5*bx) / cellsizex ), nx-1 );
ymin = max( floor( (py - h - cy + 0.5*by) / cellsizey ), 0 );
ymax = min( ceil( (py + h - cy + 0.5*by) / cellsizey ), ny-1 );
zmin = max( floor( (pz - h - cz + 0.5*bz) / cellsizez ), 0 );
zmax = min( ceil( (pz + h - cz + 0.5*bz) / cellsizez ), nz-1 );
zmid = floor( 0.5 * (zmin+zmax) + 0.5 );
if (xmin < nx && ymin < ny && xmax >= 0 && ymax >= 0 && zmin < nz && zmax >= 0) {
for (x=xmin; x<=xmax; x++) {
cpx = -0.5*bx + bx*(x+0.5)/nx;
for (y=ymin; y<=ymax; y++) {
cpy = -0.5*by + by*(y+0.5)/ny;
for (z0=zmid; z0>=zmin; z0--) {
cpz = -0.5*bz + bz*(z0+0.5)/nz;
r2 = ( sqr(px-cpx-cx) + sqr(py-cpy-cy) + sqr(pz-cpz-cz) );
if (r2 > h2) break;
kk = _getkernel( h, r2 ) * m;
for (species = 0; species < nspecies; species++ )
grid[((x*ny + y)*nz + z0)*(nspecies+1) + species] += kk * xnuc[species];
grid[((x*ny + y)*nz + z0)*(nspecies+1) + nspecies] += kk;
}
for (z1=zmid+1; z1<=zmax; z1++) {
cpz = -0.5*bz + bz*(z1+0.5)/nz;
r2 = ( sqr(px-cpx-cx) + sqr(py-cpy-cy) + sqr(pz-cpz-cz) );
if (r2 > h2) break;
kk = _getkernel( h, r2 ) * m;
for (species = 0; species < nspecies; species++ )
grid[((x*ny + y)*nz + z1)*(nspecies+1) + species] += kk * xnuc[species];
grid[((x*ny + y)*nz + z1)*(nspecies+1) + nspecies] += kk;
}
}
}
}
}
free( xnuc );
printf( "Calculation took %gs\n", ((double)clock()-(double)start)/CLOCKS_PER_SEC );
return PyArray_Return( pyGrid );
}
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);
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);
}