PyObject *
convertToNumPyArray(const Domi::MDArrayView< T > & mdArrayView)
{
// Get the number of dimensions and initialize the dimensions and
// strides arrays
int numDims = mdArrayView.numDims();
Teuchos::Array< npy_intp > dims(numDims);
Teuchos::Array< npy_intp > strides(numDims);
int typecode = NumPy_TypeCode< T >();
// Set the dimensions and strides
for (int axis = 0; axis < numDims; ++axis)
{
dims[ axis] = mdArrayView.dimension(axis);
strides[axis] = mdArrayView.strides()[axis];
}
// Get the data pointer and flags, based on data layout
void * data = (void*) mdArrayView.getRawPtr();
int flags = (mdArrayView.layout() == Domi::C_ORDER) ? NPY_ARRAY_CARRAY :
NPY_ARRAY_FARRAY;
// Return the result
return PyArray_New(&PyArray_Type,
numDims,
dims.getRawPtr(),
typecode,
strides.getRawPtr(),
data,
0,
flags,
NULL);
}
static PyArrayObject *mx2numeric(const mxArray *pArray)
{
//current function returns PyArrayObject in c order currently
mwSize nd;
npy_intp pydims[NPY_MAXDIMS];
PyArrayObject *lRetval = NULL,*t=NULL;
const double *lPR;
const double *lPI;
pyassert(PyArray_API,
"Unable to perform this function without NumPy installed");
nd = mxGetNumberOfDimensions(pArray);
{
const mwSize *dims;
dims = mxGetDimensions(pArray);
for (mwSize i=0; i != nd; i++){
pydims[i] = static_cast<npy_intp>(dims[i]);
}
}
//this function creates a fortran array
t = (PyArrayObject *)
PyArray_New(&PyArray_Type,static_cast<npy_intp>(nd), pydims,
mxIsComplex(pArray) ? PyArray_CDOUBLE : PyArray_DOUBLE,
NULL, // strides
NULL, // data
0, //(ignored itemsize),
NPY_F_CONTIGUOUS,
NULL); // obj
if (t == NULL) return NULL;
lPR = mxGetPr(pArray);
if (mxIsComplex(pArray)) {
double *lDst = (double *)PyArray_DATA(t);
// AWMS unsigned int almost certainly can overflow on some platforms!
npy_intp numberOfElements = PyArray_SIZE(t);
lPI = mxGetPi(pArray);
for (mwIndex i = 0; i != numberOfElements; i++) {
*lDst++ = *lPR++;
*lDst++ = *lPI++;
}
}
else {
double *lDst = (double *)PyArray_DATA(t);
npy_intp numberOfElements = PyArray_SIZE(t);
for (mwIndex i = 0; i != numberOfElements; i++) {
*lDst++ = *lPR++;
}
}
lRetval = (PyArrayObject *)PyArray_FromArray(t,NULL,NPY_C_CONTIGUOUS|NPY_ALIGNED|NPY_WRITEABLE);
Py_DECREF(t);
return lRetval;
error_return:
return NULL;
}
static PyObject *
fortran_getattr(PyFortranObject *fp, char *name) {
int i,j,k,flag;
if (fp->dict != NULL) {
PyObject *v = PyDict_GetItemString(fp->dict, name);
if (v != NULL) {
Py_INCREF(v);
return v;
}
}
for (i=0,j=1;i<fp->len && (j=strcmp(name,fp->defs[i].name));i++);
if (j==0)
if (fp->defs[i].rank!=-1) { /* F90 allocatable array */
if (fp->defs[i].func==NULL) return NULL;
for(k=0;k<fp->defs[i].rank;++k)
fp->defs[i].dims.d[k]=-1;
save_def = &fp->defs[i];
(*(fp->defs[i].func))(&fp->defs[i].rank,fp->defs[i].dims.d,set_data,&flag);
if (flag==2)
k = fp->defs[i].rank + 1;
else
k = fp->defs[i].rank;
if (fp->defs[i].data !=NULL) { /* array is allocated */
PyObject *v = PyArray_New(&PyArray_Type, k, fp->defs[i].dims.d,
fp->defs[i].type, NULL, fp->defs[i].data, 0, NPY_FARRAY,
NULL);
if (v==NULL) return NULL;
/* Py_INCREF(v); */
return v;
} else { /* array is not allocated */
Py_INCREF(Py_None);
return Py_None;
}
}
if (strcmp(name,"__dict__")==0) {
Py_INCREF(fp->dict);
return fp->dict;
}
if (strcmp(name,"__doc__")==0) {
PyObject *s = PyString_FromString("");
for (i=0;i<fp->len;i++)
PyString_ConcatAndDel(&s,fortran_doc(fp->defs[i]));
if (PyDict_SetItemString(fp->dict, name, s))
return NULL;
return s;
}
if ((strcmp(name,"_cpointer")==0) && (fp->len==1)) {
PyObject *cobj = PyCObject_FromVoidPtr((void *)(fp->defs[0].data),NULL);
if (PyDict_SetItemString(fp->dict, name, cobj))
return NULL;
return cobj;
}
return Py_FindMethod(fortran_methods, (PyObject *)fp, name);
}
/*
Copy a buffer using numpy.
Copy buffer x into y assuming that y is contiguous.
*/
void fff_vector_fetch_using_NumPy(fff_vector* y, const char* x, npy_intp stride, int type, int itemsize)
{
npy_intp dim[1] = {(npy_intp)y->size};
npy_intp strides[1] = {stride};
PyArrayObject* X = (PyArrayObject*) PyArray_New(&PyArray_Type, 1, dim, type, strides,
(void*)x, itemsize, NPY_BEHAVED, NULL);
PyArrayObject* Y = (PyArrayObject*) PyArray_SimpleNewFromData(1, dim, NPY_DOUBLE, (void*)y->data);
PyArray_CastTo(Y, X);
Py_XDECREF(Y);
Py_XDECREF(X);
return;
}
PyObject *
PyFortranObject_New(FortranDataDef* defs, f2py_void_func init) {
int i;
PyFortranObject *fp = NULL;
PyObject *v = NULL;
if (init!=NULL) /* Initialize F90 module objects */
(*(init))();
if ((fp = PyObject_New(PyFortranObject, &PyFortran_Type))==NULL) return NULL;
if ((fp->dict = PyDict_New())==NULL) return NULL;
fp->len = 0;
while (defs[fp->len].name != NULL) fp->len++;
if (fp->len == 0) goto fail;
fp->defs = defs;
for (i=0;i<fp->len;i++)
if (fp->defs[i].rank == -1) { /* Is Fortran routine */
v = PyFortranObject_NewAsAttr(&(fp->defs[i]));
if (v==NULL) return NULL;
PyDict_SetItemString(fp->dict,fp->defs[i].name,v);
} else
if ((fp->defs[i].data)!=NULL) { /* Is Fortran variable or array (not allocatable) */
if (fp->defs[i].type == NPY_STRING) {
int n = fp->defs[i].rank-1;
v = PyArray_New(&PyArray_Type, n, fp->defs[i].dims.d,
NPY_STRING, NULL, fp->defs[i].data, fp->defs[i].dims.d[n],
NPY_FARRAY, NULL);
}
else {
v = PyArray_New(&PyArray_Type, fp->defs[i].rank, fp->defs[i].dims.d,
fp->defs[i].type, NULL, fp->defs[i].data, 0, NPY_FARRAY,
NULL);
}
if (v==NULL) return NULL;
PyDict_SetItemString(fp->dict,fp->defs[i].name,v);
}
Py_XDECREF(v);
return (PyObject *)fp;
fail:
Py_XDECREF(v);
return NULL;
}
void local_histogram(double* H,
unsigned int clamp,
PyArrayIterObject* iter,
const unsigned int* size)
{
PyArrayObject *block, *im = iter->ao;
PyArrayIterObject* block_iter;
unsigned int i, left, right, center, halfsize, dim, offset=0;
npy_intp block_dims[3];
UPDATE_ITERATOR_COORDS(iter);
/* Compute block corners */
for (i=0; i<3; i++) {
center = iter->coordinates[i];
halfsize = size[i]/2;
dim = PyArray_DIM(im, i);
/* Left handside corner */
if (center<halfsize)
left = 0;
else
left = center-halfsize;
/* Right handside corner (plus one)*/
right = center+halfsize+1;
if (right>dim)
right = dim;
/* Block properties */
offset += left*PyArray_STRIDE(im, i);
block_dims[i] = right-left;
}
/* Create the block as a vew and the block iterator */
block = (PyArrayObject*)PyArray_New(&PyArray_Type, 3, block_dims,
PyArray_TYPE(im), PyArray_STRIDES(im),
(void*)(PyArray_DATA(im)+offset),
PyArray_ITEMSIZE(im),
NPY_BEHAVED, NULL);
block_iter = (PyArrayIterObject*)PyArray_IterNew((PyObject*)block);
/* Compute block histogram */
histogram(H, clamp, block_iter);
/* Free memory */
Py_XDECREF(block_iter);
Py_XDECREF(block);
return;
}
PyObjectHandle LuaToPythonConverter::convertTensor(lua_State* L,
thpp::Tensor<T>& tensor,
int numpyType) {
npy_intp zero = 0;
int ndims;
std::unique_ptr<npy_intp[]> dims;
npy_intp* dimsPtr;
std::unique_ptr<npy_intp[]> strides;
// Numpy and Torch disagree on empty tensors. In Torch, an empty tensor
// is a tensor with zero dimensions. In Numpy, a tensor with zero dimensions
// is a scalar (with one element). So we'll convert an empty Torch tensor
// to a 1d Numpy tensor of shape [0]. Also see pushTensor in PythonToLua.cpp.
if (tensor.ndims() != 0) {
ndims = tensor.ndims();
auto tsizes = tensor.sizes();
DCHECK_EQ(tsizes.size(), ndims);
dims.reset(new npy_intp[ndims]);
dimsPtr = dims.get();
std::copy(tsizes.begin(), tsizes.end(), dims.get());
if (!tensor.isContiguous()) {
auto tstrides = tensor.strides();
DCHECK_EQ(tstrides.size(), ndims);
strides.reset(new npy_intp[ndims]);
// Numpy strides use bytes; Torch strides use element counts.
for (int i = 0; i < ndims; ++i) {
strides[i] = tstrides[i] * sizeof(T);
}
}
} else {
ndims = 1;
dimsPtr = &zero;
}
PyObjectHandle obj(PyArray_New(
&PyArray_Type, ndims, dimsPtr, numpyType,
strides.get(), tensor.data(), 0,
NPY_ARRAY_ALIGNED, nullptr));
checkPythonError(obj, L, "create numpy.ndarray of type {}", numpyType);
// Create a PythonStorage object to hold the reference count.
// PyArray_SetBaseObject steals the reference to the base object.
int r = PyArray_SetBaseObject(reinterpret_cast<PyArrayObject*>(obj.get()),
PythonStorage<T>::allocate(
L, tensor.storage()).release());
checkPythonError(r != -1, L, "SetBaseObject on numpy.ndarray");
return obj;
}
PyObject* PyArray_FromMatrixXd(const MatrixXd& mat) {
// matrix dimensionality
npy_intp dims[2];
dims[0] = mat.rows();
dims[1] = mat.cols();
// allocate PyArray
#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
PyObject* array = PyArray_New(&PyArray_Type, 2, dims, NPY_DOUBLE, 0, 0, sizeof(double), NPY_C_CONTIGUOUS, 0);
#else
PyObject* array = PyArray_New(&PyArray_Type, 2, dims, NPY_DOUBLE, 0, 0, sizeof(double), NPY_F_CONTIGUOUS, 0);
#endif
// copy data
const double* data = mat.data();
double* dataCopy = reinterpret_cast<double*>(PyArray_DATA(array));
for(int i = 0; i < mat.size(); ++i)
dataCopy[i] = data[i];
return array;
}
static PyObject *pixbuf_get_pixels_array(PyObject *self, PyObject *args)
{
/* 1) read in Python pixbuf, get the underlying gdk_pixbuf */
PyGObject *py_pixbuf;
GdkPixbuf *gdk_pixbuf;
PyArrayObject *array;
npy_intp dims[3] = { 0, 0, 3 };
npy_intp strides[3];
if (!PyArg_ParseTuple(args, "O!:pixbuf_get_pixels_array", &PyGdkPixbuf_Type, &py_pixbuf))
return NULL;
gdk_pixbuf = GDK_PIXBUF(py_pixbuf->obj);
/* 2) same as pygtk/gtk/gdk.c _wrap_gdk_pixbuf_get_pixels_array()
* with 'self' changed to py_pixbuf
*/
dims[0] = gdk_pixbuf_get_height(gdk_pixbuf);
dims[1] = gdk_pixbuf_get_width(gdk_pixbuf);
if (gdk_pixbuf_get_has_alpha(gdk_pixbuf))
dims[2] = 4;
strides[0] = gdk_pixbuf_get_rowstride(gdk_pixbuf);
strides[1] = dims[2];
strides[2] = 1;
array = (PyArrayObject*)
PyArray_New(&PyArray_Type, 3, dims, NPY_UBYTE, strides,
(void*)gdk_pixbuf_get_pixels(gdk_pixbuf), 1,
NPY_ARRAY_WRITEABLE, NULL);
if (array == NULL)
return NULL;
/* the array holds a ref to the pixbuf pixels through this wrapper*/
Py_INCREF(py_pixbuf);
#if NPY_API_VERSION >= 0x00000007
if (PyArray_SetBaseObject(array, (PyObject *)py_pixbuf) == -1) {
Py_DECREF(py_pixbuf);
Py_DECREF(array);
return NULL;
}
#else
PyArray_BASE(array) = (PyObject *) py_pixbuf;
#endif
return PyArray_Return(array);
}
PyObject* GeneralSwarm_AddParticlesFromCoordArray( void* swarm, Index count, Index dim, double* array )
{
GeneralSwarm* self = (GeneralSwarm*)swarm;
unsigned* cellArray = Memory_Alloc_Array( unsigned, count, "GeneralSwarm_AddParticlesFromCoordArray_CellArray" );
GlobalParticle localParticle;
GlobalParticle* particle = &localParticle;
int cellLocalCount = self->cellLocalCount;
int oldParticleCount = self->particleLocalCount;
int ii;
int totsLocalParticles=0;
// find which particles are local. we do this to avoid swarm reallocs.
for (ii=0; ii<count; ii++) {
memcpy(&(particle->coord), array + dim*ii, dim*sizeof(double));
cellArray[ii] = CellLayout_CellOf( self->cellLayout, particle );
if( cellArray[ii] < cellLocalCount )
totsLocalParticles++;
}
// alloc particle local index array (to be returned)
int* partLocalIndex = Memory_Alloc_Array( int, count, "GeneralSwarm_AddParticlesFromCoordArray_CellArray" );
// ok, lets add them to the swarm, now that we know how many are required
self->particleLocalCount += totsLocalParticles;
Swarm_Realloc( self );
int newPartIndex = oldParticleCount;
for (ii=0; ii<count; ii++) {
if( cellArray[ii] < cellLocalCount ){
particle = (GlobalParticle*)Swarm_ParticleAt( self, newPartIndex );
memcpy(&(particle->coord), array + dim*ii, dim*sizeof(double));
Swarm_AddParticleToCell( swarm, cellArray[ii], newPartIndex );
partLocalIndex[ii] = newPartIndex;
newPartIndex++;
} else {
partLocalIndex[ii] = -1;
}
}
/* create numpy array to return */
npy_intp dims[1] = { count };
PyObject* pyobj = PyArray_New(&PyArray_Type, 1, dims, NPY_INT, NULL, (void*)partLocalIndex, sizeof(int), 0, NULL);
/* enable the owndata flag.. this tells numpy to dealloc the data when it is finished with it */
#if NPY_API_VERSION < 0x00000007
(((PyArrayObject*)pyobj)->flags) = NPY_ARRAY_OWNDATA;
#else
PyArray_ENABLEFLAGS((PyArrayObject*)pyobj, NPY_ARRAY_OWNDATA);
#endif
return pyobj;
}
static PyObject *
get_times_for_entity (NsLibrary *lib,
uint32 file_id,
uint32 entity_id,
uint32 index,
uint32 length)
{
PyObject *array;
ns_RESULT res;
npy_intp dims[1];
double *data;
int i;
res = ns_OK;
dims[0] = length;
array = PyArray_New (&PyArray_Type,
1,
dims,
NPY_DOUBLE,
NULL,
NULL /* data */,
0 /* itemsize */,
NPY_CARRAY,
NULL);
data = (double *) PyArray_DATA (array);
for (i = 0; i < length; i++)
{
res = lib->GetTimeByIndex (file_id,
entity_id,
index + i,
(data + i));
if (res != ns_OK)
break;
}
if (check_result_is_error (res, lib))
{
Py_DECREF (array);
return NULL;
}
return array;
}
static PyObject* py_as_nparray(PyObject *self, PyObject *args)
{
// Suppose you have data in C code and want to pass to Python as an array
const int np=10;
Particle* const p= calloc(sizeof(Particle), np);
for(int i=0; i<np; ++i) {
p[i].x[0]= (float) i + 1;
}
// This memory is assumed to be freed by the C code
// (Memory leak in this example)
const int nd=2;
const int ncol= 3;
npy_intp dims[]= {np, ncol};
npy_intp strides[]= {sizeof(Particle), sizeof(float)};
return PyArray_New(&PyArray_Type, nd, dims, NPY_FLOAT, strides,
p->x, 0, 0, 0);
}
void Invocation::insertArgument(const std::string& name,
boost::uint8_t* data,
boost::uint32_t data_len,
boost::uint32_t data_stride,
dimension::Interpretation dataType,
boost::uint32_t numBytes)
{
npy_intp mydims = data_len;
int nd = 1;
npy_intp* dims = &mydims;
npy_intp stride = data_stride;
npy_intp* strides = &stride;
int flags = NPY_CARRAY; // NPY_BEHAVED
const int pyDataType = getPythonDataType(dataType, numBytes);
PyObject* pyArray = PyArray_New(&PyArray_Type, nd, dims, pyDataType, strides, data, 0, flags, NULL);
m_pyInputArrays.push_back(pyArray);
PyDict_SetItemString(m_varsIn, name.c_str(), pyArray);
return;
}
extern
PyArrayObject* array_from_pyobj(const int type_num,
npy_intp *dims,
const int rank,
const int intent,
PyObject *obj) {
/* Note about reference counting
-----------------------------
If the caller returns the array to Python, it must be done with
Py_BuildValue("N",arr).
Otherwise, if obj!=arr then the caller must call Py_DECREF(arr).
Note on intent(cache,out,..)
---------------------
Don't expect correct data when returning intent(cache) array.
*/
char mess[200];
PyArrayObject *arr = NULL;
PyArray_Descr *descr;
char typechar;
int elsize;
if ((intent & F2PY_INTENT_HIDE)
|| ((intent & F2PY_INTENT_CACHE) && (obj==Py_None))
|| ((intent & F2PY_OPTIONAL) && (obj==Py_None))
) {
/* intent(cache), optional, intent(hide) */
if (count_nonpos(rank,dims)) {
int i;
strcpy(mess, "failed to create intent(cache|hide)|optional array"
"-- must have defined dimensions but got (");
for(i=0;i<rank;++i)
sprintf(mess+strlen(mess),"%" NPY_INTP_FMT ",",dims[i]);
strcat(mess, ")");
PyErr_SetString(PyExc_ValueError,mess);
return NULL;
}
arr = (PyArrayObject *)
PyArray_New(&PyArray_Type, rank, dims, type_num,
NULL,NULL,0,
!(intent&F2PY_INTENT_C),
NULL);
if (arr==NULL) return NULL;
if (!(intent & F2PY_INTENT_CACHE))
PyArray_FILLWBYTE(arr, 0);
return arr;
}
descr = PyArray_DescrFromType(type_num);
elsize = descr->elsize;
typechar = descr->type;
Py_DECREF(descr);
if (PyArray_Check(obj)) {
arr = (PyArrayObject *)obj;
if (intent & F2PY_INTENT_CACHE) {
/* intent(cache) */
if (PyArray_ISONESEGMENT(arr)
&& PyArray_ITEMSIZE(arr)>=elsize) {
if (check_and_fix_dimensions(arr,rank,dims)) {
return NULL; /*XXX: set exception */
}
if (intent & F2PY_INTENT_OUT)
Py_INCREF(arr);
return arr;
}
strcpy(mess, "failed to initialize intent(cache) array");
if (!PyArray_ISONESEGMENT(arr))
strcat(mess, " -- input must be in one segment");
if (PyArray_ITEMSIZE(arr)<elsize)
sprintf(mess+strlen(mess),
" -- expected at least elsize=%d but got %" NPY_INTP_FMT,
elsize,
(npy_intp)PyArray_ITEMSIZE(arr)
);
PyErr_SetString(PyExc_ValueError,mess);
return NULL;
}
/* here we have always intent(in) or intent(inout) or intent(inplace) */
if (check_and_fix_dimensions(arr,rank,dims)) {
return NULL; /*XXX: set exception */
}
/*
printf("intent alignement=%d\n", F2PY_GET_ALIGNMENT(intent));
printf("alignement check=%d\n", F2PY_CHECK_ALIGNMENT(arr, intent));
int i;
for (i=1;i<=16;i++)
printf("i=%d isaligned=%d\n", i, ARRAY_ISALIGNED(arr, i));
*/
if ((! (intent & F2PY_INTENT_COPY))
&& PyArray_ITEMSIZE(arr)==elsize
&& ARRAY_ISCOMPATIBLE(arr,type_num)
&& F2PY_CHECK_ALIGNMENT(arr, intent)
) {
if ((intent & F2PY_INTENT_C)?PyArray_ISCARRAY(arr):PyArray_ISFARRAY(arr)) {
if ((intent & F2PY_INTENT_OUT)) {
Py_INCREF(arr);
}
/* Returning input array */
return arr;
}
}
if (intent & F2PY_INTENT_INOUT) {
strcpy(mess, "failed to initialize intent(inout) array");
if ((intent & F2PY_INTENT_C) && !PyArray_ISCARRAY(arr))
strcat(mess, " -- input not contiguous");
if (!(intent & F2PY_INTENT_C) && !PyArray_ISFARRAY(arr))
strcat(mess, " -- input not fortran contiguous");
if (PyArray_ITEMSIZE(arr)!=elsize)
sprintf(mess+strlen(mess),
" -- expected elsize=%d but got %" NPY_INTP_FMT,
elsize,
(npy_intp)PyArray_ITEMSIZE(arr)
);
if (!(ARRAY_ISCOMPATIBLE(arr,type_num)))
sprintf(mess+strlen(mess)," -- input '%c' not compatible to '%c'",
PyArray_DESCR(arr)->type,typechar);
if (!(F2PY_CHECK_ALIGNMENT(arr, intent)))
sprintf(mess+strlen(mess)," -- input not %d-aligned", F2PY_GET_ALIGNMENT(intent));
PyErr_SetString(PyExc_ValueError,mess);
return NULL;
}
/* here we have always intent(in) or intent(inplace) */
{
PyArrayObject *retarr = (PyArrayObject *) \
PyArray_New(&PyArray_Type, PyArray_NDIM(arr), PyArray_DIMS(arr), type_num,
NULL,NULL,0,
!(intent&F2PY_INTENT_C),
NULL);
if (retarr==NULL)
return NULL;
F2PY_REPORT_ON_ARRAY_COPY_FROMARR;
if (PyArray_CopyInto(retarr, arr)) {
Py_DECREF(retarr);
return NULL;
}
if (intent & F2PY_INTENT_INPLACE) {
if (swap_arrays(arr,retarr))
return NULL; /* XXX: set exception */
Py_XDECREF(retarr);
if (intent & F2PY_INTENT_OUT)
Py_INCREF(arr);
} else {
arr = retarr;
}
}
return arr;
}
if ((intent & F2PY_INTENT_INOUT) ||
(intent & F2PY_INTENT_INPLACE) ||
(intent & F2PY_INTENT_CACHE)) {
PyErr_SetString(PyExc_TypeError,
"failed to initialize intent(inout|inplace|cache) "
"array, input not an array");
return NULL;
}
{
F2PY_REPORT_ON_ARRAY_COPY_FROMANY;
arr = (PyArrayObject *) \
PyArray_FromAny(obj,PyArray_DescrFromType(type_num), 0,0,
((intent & F2PY_INTENT_C)?NPY_ARRAY_CARRAY:NPY_ARRAY_FARRAY) \
| NPY_ARRAY_FORCECAST, NULL);
if (arr==NULL)
return NULL;
if (check_and_fix_dimensions(arr,rank,dims))
return NULL; /*XXX: set exception */
return arr;
}
}
static PyObject*
run(PyObject *self, PyObject *args, PyObject *kwargs)
{
/* get the number of arguments */
Py_ssize_t argc = PyTuple_Size(args);
if(argc != 3)
{
std::cout << "Not the right number of arguments" << std::endl;
Py_INCREF(Py_None);
return Py_None;
}
/* get the first argument (kwargs) */
PyObject *dxObj = PyTuple_GetItem(args, 0);
PyObject *dyObj = PyTuple_GetItem(args, 1);
PyObject *fmObj = PyTuple_GetItem(args, 2);
assert(PyArray_Check(dxObj));
assert(PyArray_Check(dyObj));
// Found variable, now copy it into the C/OCL data structure
PyArrayObject * dxArray = (PyArrayObject*)dxObj;
PyArrayObject * dyArray = (PyArrayObject*)dyObj;
npy_intp * dims = PyArray_DIMS(dxArray);
npy_intp out_dims[3];
out_dims[0] = dims[0];
out_dims[1] = dims[1];
out_dims[2] = 3;
double * dxData = (double *)dxArray->data;
double * dyData = (double *)dyArray->data;
unsigned char * out_data = (unsigned char *) calloc(out_dims[0] * out_dims[1] * out_dims[2], sizeof(unsigned char));
double flowmax = 0.0;
double input_fm;
PyArray_ScalarAsCtype(fmObj, &input_fm);
if(input_fm <= 0)
{
for(int i = 0 ; i < out_dims[0] ; i++)
{
for(int j = 0 ; j < out_dims[1] ; j++)
{
double fx = dxData[j + i * out_dims[1]];
double fy = dyData[j + i * out_dims[1]];
double mag = sqrt(fx * fx + fy * fy);
if(mag > flowmax) flowmax = mag;
}
}
}
else
{
flowmax = input_fm;
}
for(int i = 0 ; i < out_dims[0] ; i++)
{
for(int j = 0 ; j < out_dims[1] ; j++)
{
double fx = dxData[j + i * out_dims[1]];
double fy = dyData[j + i * out_dims[1]];
computeColor(fx / flowmax, fy / flowmax , &out_data[j * 3 + i * out_dims[1] * 3]);
}
}
PyObject * retArray = PyArray_New(&PyArray_Type, 3, out_dims, NPY_UINT8, NULL, out_data, 0, NPY_C_CONTIGUOUS, NULL);
return retArray;
}
static PyObject *
data_array_by_name(particles_t *self, char *key)
{
int data_type;
BOOL ex;
int ierror = ERROR_NONE;
void *array;
PyObject *r;
npy_intp dims[3];
#ifndef SEP_XYZ
npy_intp strides[3];
#endif
char errstr[100];
#ifdef DEBUG
printf("[data_array_by_name] self = %p, key = %p\n", self, key);
printf("[data_array_by_name] self->f90obj = %p, self->f90data = %p\n",
self->f90obj, self->f90data);
printf("[data_array_by_name] key = %s\n", key);
#endif
ex = f_data_exists(self->f90data, key, &data_type);
#ifdef DEBUG
printf("[data_array_by_name] ex = %i\n", ex);
#endif
r = NULL;
if (ex) {
switch (data_type) {
case TYPE_REAL:
real_ptr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = data_get_len(self->f90data);
#ifdef DEBUG
printf("[data_array_by_name] TYPE_REAL, dim = %i\n", dims[0]);
#endif
r = PyArray_New(&PyArray_Type, 1, dims, NPY_DOUBLE, NULL, array, 0,
NPY_FARRAY, NULL);
break;
case TYPE_INTEGER:
integer_ptr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = data_get_len(self->f90data);
#ifdef DEBUG
printf("[data_array_by_name] TYPE_INTEGER, dim = %i\n", dims[0]);
#endif
r = PyArray_New(&PyArray_Type, 1, dims, NPY_INT, NULL, array, 0,
NPY_FARRAY, NULL);
break;
case TYPE_REAL3:
realx_ptr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = data_get_len(self->f90data);
dims[1] = 3;
strides[0] = 3*NPY_SIZEOF_DOUBLE;
strides[1] = NPY_SIZEOF_DOUBLE;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_REAL3, dim = %i %i, strides = %i %i\n",
dims[0], dims[1], strides[0], strides[1]);
#endif
r = PyArray_New(&PyArray_Type, 2, dims, NPY_DOUBLE, strides, array, 0,
NPY_BEHAVED, NULL);
break;
case TYPE_REAL3x3:
#ifdef DEBUG
printf("[data_array_by_name] Type is REAL3x3\n");
#endif
realxxx_ptr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = data_get_len(self->f90data);
dims[1] = 3;
dims[2] = 3;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_REAL3x3, dim = %i %i %i\n", dims[0],
dims[1], dims[2]);
#endif
r = PyArray_New(&PyArray_Type, 3, dims, NPY_DOUBLE, NULL, array, 0,
NPY_FARRAY, NULL);
break;
case TYPE_REAL_ATTR:
real_attr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_REAL_ATTR\n");
#endif
r = PyFloat_FromDouble(*((double*) array));
break;
case TYPE_REAL3_ATTR:
real3_attr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = 3;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_REAL3_ATTR, dim = %i\n", dims[0]);
#endif
r = PyArray_New(&PyArray_Type, 1, dims, NPY_DOUBLE, NULL, array, 0,
NPY_FARRAY, NULL);
break;
case TYPE_REAL3x3_ATTR:
real3x3_attr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = 3;
dims[1] = 3;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_REAL3_ATTR, dim = %i %i\n", dims[0],
dims[1]);
#endif
r = PyArray_New(&PyArray_Type, 2, dims, NPY_DOUBLE, NULL, array, 0,
NPY_FARRAY, NULL);
break;
case TYPE_INTEGER_ATTR:
integer_attr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_INTEGER_ATTR\n");
#endif
r = PyInt_FromLong(*((int*) array));
break;
case TYPE_INTEGER3_ATTR:
integer3_attr_by_name(self->f90data, key, &array, &ierror);
if (error_to_py(ierror))
return NULL;
dims[0] = 3;
#ifdef DEBUG
printf("[data_array_by_name] TYPE_INTEGER3_ATTR, dim = %i\n", dims[0]);
#endif
r = PyArray_New(&PyArray_Type, 1, dims, NPY_INT, NULL, array, 0,
NPY_FARRAY, NULL);
break;
default:
sprintf(errstr, "InternalError: Unknown type returned for field or "
"attribute '%s'.", PyString_AS_STRING(key));
PyErr_SetString(PyExc_KeyError, errstr);
r = NULL;
}
}
return r;
}
/*NUMPY_API
* ArgMax
*/
NPY_NO_EXPORT PyObject *
PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
{
PyArrayObject *ap = NULL, *rp = NULL;
PyArray_ArgFunc* arg_func;
char *ip;
npy_intp *rptr;
npy_intp i, n, m;
int elsize;
NPY_BEGIN_THREADS_DEF;
if ((ap = (PyArrayObject *)PyArray_CheckAxis(op, &axis, 0)) == NULL) {
return NULL;
}
/*
* We need to permute the array so that axis is placed at the end.
* And all other dimensions are shifted left.
*/
if (axis != PyArray_NDIM(ap)-1) {
PyArray_Dims newaxes;
npy_intp dims[NPY_MAXDIMS];
int j;
newaxes.ptr = dims;
newaxes.len = PyArray_NDIM(ap);
for (j = 0; j < axis; j++) {
dims[j] = j;
}
for (j = axis; j < PyArray_NDIM(ap) - 1; j++) {
dims[j] = j + 1;
}
dims[PyArray_NDIM(ap) - 1] = axis;
op = (PyArrayObject *)PyArray_Transpose(ap, &newaxes);
Py_DECREF(ap);
if (op == NULL) {
return NULL;
}
}
else {
op = ap;
}
/* Will get native-byte order contiguous copy. */
ap = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op,
PyArray_DESCR(op)->type_num, 1, 0);
Py_DECREF(op);
if (ap == NULL) {
return NULL;
}
arg_func = PyArray_DESCR(ap)->f->argmax;
if (arg_func == NULL) {
PyErr_SetString(PyExc_TypeError,
"data type not ordered");
goto fail;
}
elsize = PyArray_DESCR(ap)->elsize;
m = PyArray_DIMS(ap)[PyArray_NDIM(ap)-1];
if (m == 0) {
PyErr_SetString(PyExc_ValueError,
"attempt to get argmax of an empty sequence");
goto fail;
}
if (!out) {
rp = (PyArrayObject *)PyArray_New(Py_TYPE(ap), PyArray_NDIM(ap)-1,
PyArray_DIMS(ap), NPY_INTP,
NULL, NULL, 0, 0,
(PyObject *)ap);
if (rp == NULL) {
goto fail;
}
}
else {
if ((PyArray_NDIM(out) != PyArray_NDIM(ap) - 1) ||
!PyArray_CompareLists(PyArray_DIMS(out), PyArray_DIMS(ap),
PyArray_NDIM(out))) {
PyErr_SetString(PyExc_ValueError,
"output array does not match result of np.argmax.");
goto fail;
}
rp = (PyArrayObject *)PyArray_FromArray(out,
PyArray_DescrFromType(NPY_INTP),
NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY);
if (rp == NULL) {
goto fail;
}
}
NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap));
n = PyArray_SIZE(ap)/m;
rptr = (npy_intp *)PyArray_DATA(rp);
for (ip = PyArray_DATA(ap), i = 0; i < n; i++, ip += elsize*m) {
arg_func(ip, m, rptr, ap);
rptr += 1;
}
NPY_END_THREADS_DESCR(PyArray_DESCR(ap));
Py_DECREF(ap);
/* Trigger the UPDATEIFCOPY if necessary */
if (out != NULL && out != rp) {
Py_DECREF(rp);
rp = out;
Py_INCREF(rp);
}
return (PyObject *)rp;
fail:
Py_DECREF(ap);
Py_XDECREF(rp);
return NULL;
}
/*NUMPY_API
* ArgMax
*/
NPY_NO_EXPORT PyObject *
PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
{
PyArrayObject *ap = NULL, *rp = NULL;
PyArray_ArgFunc* arg_func;
char *ip;
intp *rptr;
intp i, n, m;
int elsize;
int copyret = 0;
NPY_BEGIN_THREADS_DEF;
if ((ap=(PyAO *)_check_axis(op, &axis, 0)) == NULL) {
return NULL;
}
/*
* We need to permute the array so that axis is placed at the end.
* And all other dimensions are shifted left.
*/
if (axis != ap->nd-1) {
PyArray_Dims newaxes;
intp dims[MAX_DIMS];
int i;
newaxes.ptr = dims;
newaxes.len = ap->nd;
for (i = 0; i < axis; i++) dims[i] = i;
for (i = axis; i < ap->nd - 1; i++) dims[i] = i + 1;
dims[ap->nd - 1] = axis;
op = (PyAO *)PyArray_Transpose(ap, &newaxes);
Py_DECREF(ap);
if (op == NULL) {
return NULL;
}
}
else {
op = ap;
}
/* Will get native-byte order contiguous copy. */
ap = (PyArrayObject *)
PyArray_ContiguousFromAny((PyObject *)op,
op->descr->type_num, 1, 0);
Py_DECREF(op);
if (ap == NULL) {
return NULL;
}
arg_func = ap->descr->f->argmax;
if (arg_func == NULL) {
PyErr_SetString(PyExc_TypeError, "data type not ordered");
goto fail;
}
elsize = ap->descr->elsize;
m = ap->dimensions[ap->nd-1];
if (m == 0) {
PyErr_SetString(PyExc_ValueError,
"attempt to get argmax/argmin "\
"of an empty sequence");
goto fail;
}
if (!out) {
rp = (PyArrayObject *)PyArray_New(ap->ob_type, ap->nd-1,
ap->dimensions, PyArray_INTP,
NULL, NULL, 0, 0,
(PyObject *)ap);
if (rp == NULL) {
goto fail;
}
}
else {
if (PyArray_SIZE(out) !=
PyArray_MultiplyList(ap->dimensions, ap->nd - 1)) {
PyErr_SetString(PyExc_TypeError,
"invalid shape for output array.");
}
rp = (PyArrayObject *)\
PyArray_FromArray(out,
PyArray_DescrFromType(PyArray_INTP),
NPY_CARRAY | NPY_UPDATEIFCOPY);
if (rp == NULL) {
goto fail;
}
if (rp != out) {
copyret = 1;
}
}
NPY_BEGIN_THREADS_DESCR(ap->descr);
n = PyArray_SIZE(ap)/m;
rptr = (intp *)rp->data;
for (ip = ap->data, i = 0; i < n; i++, ip += elsize*m) {
arg_func(ip, m, rptr, ap);
rptr += 1;
}
NPY_END_THREADS_DESCR(ap->descr);
Py_DECREF(ap);
if (copyret) {
PyArrayObject *obj;
obj = (PyArrayObject *)rp->base;
Py_INCREF(obj);
Py_DECREF(rp);
rp = obj;
}
return (PyObject *)rp;
fail:
Py_DECREF(ap);
Py_XDECREF(rp);
return NULL;
}
static PyObject *
do_get_analog_data (PyObject *self, PyObject *args, PyObject *kwds)
{
NsLibrary *lib;
PyObject *cobj;
PyObject *iobj, *id_obj, *idx_obj, *sz_obj;
PyObject *res_obj;
PyObject *array;
PyObject *times;
uint32 file_id;
uint32 entity_id;
uint32 index;
uint32 count;
uint32 cont_count;
ns_RESULT res;
void *buffer;
npy_intp dims[1];
if (!PyArg_ParseTuple (args, "OOOOO", &cobj, &iobj, &id_obj, &idx_obj, &sz_obj))
{
PyErr_SetString (PyExc_StandardError, "Could not parse arguments");
return NULL;
}
if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) ||
!PyInt_Check (id_obj) || !PyInt_Check (idx_obj) ||
!PyInt_Check (sz_obj))
{
PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)");
return NULL;
}
lib = PyCObject_AsVoidPtr (cobj);
file_id = (uint32) PyInt_AsUnsignedLongMask (iobj);
entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj);
index = (uint32) PyInt_AsUnsignedLongMask (idx_obj);
count = (uint32) PyInt_AsUnsignedLongMask (sz_obj);
/* ** */
dims[0] = count; //sample count
array = PyArray_New (&PyArray_Type,
1,
dims,
NPY_DOUBLE,
NULL,
NULL /* data */,
0 /* itemsize */,
NPY_CARRAY,
NULL);
buffer = PyArray_DATA (array);
res = lib->GetAnalogData (file_id,
entity_id,
index,
count,
&cont_count,
buffer);
if (check_result_is_error (res, lib))
{
Py_DECREF (array);
return NULL;
}
times = get_times_for_entity (lib,
file_id,
entity_id,
index,
count);
if (times == NULL)
{
Py_DECREF (array);
return NULL;
}
res_obj = PyTuple_New (3);
PyTuple_SetItem (res_obj, 0, array);
PyTuple_SetItem (res_obj, 1, times);
PyTuple_SetItem (res_obj, 2, PyInt_FromLong (cont_count));
return res_obj;
}
static PyObject *
dotblas_matrixproduct(PyObject *dummy, PyObject *args)
{
PyObject *op1, *op2;
PyArrayObject *ap1=NULL, *ap2=NULL, *ret=NULL;
int j, l, lda, ldb, ldc;
int typenum, nd;
intp ap1stride=0;
intp dimensions[MAX_DIMS];
intp numbytes;
static const float oneF[2] = {1.0, 0.0};
static const float zeroF[2] = {0.0, 0.0};
static const double oneD[2] = {1.0, 0.0};
static const double zeroD[2] = {0.0, 0.0};
double prior1, prior2;
PyTypeObject *subtype;
PyArray_Descr *dtype;
MatrixShape ap1shape, ap2shape;
if (!PyArg_ParseTuple(args, "OO", &op1, &op2)) return NULL;
/*
* "Matrix product" using the BLAS.
* Only works for float double and complex types.
*/
typenum = PyArray_ObjectType(op1, 0);
typenum = PyArray_ObjectType(op2, typenum);
/* This function doesn't handle other types */
if ((typenum != PyArray_DOUBLE && typenum != PyArray_CDOUBLE &&
typenum != PyArray_FLOAT && typenum != PyArray_CFLOAT)) {
return PyArray_Return((PyArrayObject *)PyArray_MatrixProduct(op1, op2));
}
dtype = PyArray_DescrFromType(typenum);
ap1 = (PyArrayObject *)PyArray_FromAny(op1, dtype, 0, 0, ALIGNED, NULL);
if (ap1 == NULL) return NULL;
Py_INCREF(dtype);
ap2 = (PyArrayObject *)PyArray_FromAny(op2, dtype, 0, 0, ALIGNED, NULL);
if (ap2 == NULL) goto fail;
if ((ap1->nd > 2) || (ap2->nd > 2)) {
/* This function doesn't handle dimensions greater than 2
(or negative striding) -- other
than to ensure the dot function is altered
*/
if (!altered) {
/* need to alter dot product */
PyObject *tmp1, *tmp2;
tmp1 = PyTuple_New(0);
tmp2 = dotblas_alterdot(NULL, tmp1);
Py_DECREF(tmp1);
Py_DECREF(tmp2);
}
ret = (PyArrayObject *)PyArray_MatrixProduct((PyObject *)ap1,
(PyObject *)ap2);
Py_DECREF(ap1);
Py_DECREF(ap2);
return PyArray_Return(ret);
}
if (_bad_strides(ap1)) {
op1 = PyArray_NewCopy(ap1, PyArray_ANYORDER);
Py_DECREF(ap1);
ap1 = (PyArrayObject *)op1;
if (ap1 == NULL) goto fail;
}
if (_bad_strides(ap2)) {
op2 = PyArray_NewCopy(ap2, PyArray_ANYORDER);
Py_DECREF(ap2);
ap2 = (PyArrayObject *)op2;
if (ap2 == NULL) goto fail;
}
ap1shape = _select_matrix_shape(ap1);
ap2shape = _select_matrix_shape(ap2);
if (ap1shape == _scalar || ap2shape == _scalar) {
PyArrayObject *oap1, *oap2;
oap1 = ap1;
oap2 = ap2;
/* One of ap1 or ap2 is a scalar */
if (ap1shape == _scalar) { /* Make ap2 the scalar */
PyArrayObject *t = ap1;
ap1 = ap2;
ap2 = t;
ap1shape = ap2shape;
ap2shape = _scalar;
}
if (ap1shape == _row) ap1stride = ap1->strides[1];
else if (ap1->nd > 0) ap1stride = ap1->strides[0];
if (ap1->nd == 0 || ap2->nd == 0) {
intp *thisdims;
if (ap1->nd == 0) {
nd = ap2->nd;
thisdims = ap2->dimensions;
}
else {
nd = ap1->nd;
thisdims = ap1->dimensions;
}
l = 1;
for (j=0; j<nd; j++) {
dimensions[j] = thisdims[j];
l *= dimensions[j];
}
}
else {
l = oap1->dimensions[oap1->nd-1];
if (oap2->dimensions[0] != l) {
PyErr_SetString(PyExc_ValueError, "matrices are not aligned");
goto fail;
}
nd = ap1->nd + ap2->nd - 2;
/* nd = 0 or 1 or 2 */
/* If nd == 0 do nothing ... */
if (nd == 1) {
/* Either ap1->nd is 1 dim or ap2->nd is 1 dim
and the other is 2-dim */
dimensions[0] = (oap1->nd == 2) ? oap1->dimensions[0] : oap2->dimensions[1];
l = dimensions[0];
/* Fix it so that dot(shape=(N,1), shape=(1,))
and dot(shape=(1,), shape=(1,N)) both return
an (N,) array (but use the fast scalar code)
*/
}
else if (nd == 2) {
dimensions[0] = oap1->dimensions[0];
dimensions[1] = oap2->dimensions[1];
/* We need to make sure that dot(shape=(1,1), shape=(1,N))
and dot(shape=(N,1),shape=(1,1)) uses
scalar multiplication appropriately
*/
if (ap1shape == _row) l = dimensions[1];
else l = dimensions[0];
}
}
}
else { /* (ap1->nd <= 2 && ap2->nd <= 2) */
/* Both ap1 and ap2 are vectors or matrices */
l = ap1->dimensions[ap1->nd-1];
if (ap2->dimensions[0] != l) {
PyErr_SetString(PyExc_ValueError, "matrices are not aligned");
goto fail;
}
nd = ap1->nd+ap2->nd-2;
if (nd == 1)
dimensions[0] = (ap1->nd == 2) ? ap1->dimensions[0] : ap2->dimensions[1];
else if (nd == 2) {
dimensions[0] = ap1->dimensions[0];
dimensions[1] = ap2->dimensions[1];
}
}
/* Choose which subtype to return */
if (ap1->ob_type != ap2->ob_type) {
prior2 = PyArray_GetPriority((PyObject *)ap2, 0.0);
prior1 = PyArray_GetPriority((PyObject *)ap1, 0.0);
subtype = (prior2 > prior1 ? ap2->ob_type : ap1->ob_type);
}
else {
prior1 = prior2 = 0.0;
subtype = ap1->ob_type;
}
ret = (PyArrayObject *)PyArray_New(subtype, nd, dimensions,
typenum, NULL, NULL, 0, 0,
(PyObject *)
(prior2 > prior1 ? ap2 : ap1));
if (ret == NULL) goto fail;
numbytes = PyArray_NBYTES(ret);
memset(ret->data, 0, numbytes);
if (numbytes==0 || l == 0) {
Py_DECREF(ap1);
Py_DECREF(ap2);
return PyArray_Return(ret);
}
if (ap2shape == _scalar) {
/* Multiplication by a scalar -- Level 1 BLAS */
/* if ap1shape is a matrix and we are not contiguous, then we can't
just blast through the entire array using a single
striding factor */
NPY_BEGIN_ALLOW_THREADS
if (typenum == PyArray_DOUBLE) {
if (l == 1) {
*((double *)ret->data) = *((double *)ap2->data) * \
*((double *)ap1->data);
}
else if (ap1shape != _matrix) {
cblas_daxpy(l, *((double *)ap2->data), (double *)ap1->data,
ap1stride/sizeof(double), (double *)ret->data, 1);
}
else {
int maxind, oind, i, a1s, rets;
char *ptr, *rptr;
double val;
maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1);
oind = 1-maxind;
ptr = ap1->data;
rptr = ret->data;
l = ap1->dimensions[maxind];
val = *((double *)ap2->data);
a1s = ap1->strides[maxind] / sizeof(double);
rets = ret->strides[maxind] / sizeof(double);
for (i=0; i < ap1->dimensions[oind]; i++) {
cblas_daxpy(l, val, (double *)ptr, a1s,
(double *)rptr, rets);
ptr += ap1->strides[oind];
rptr += ret->strides[oind];
}
}
}
else if (typenum == PyArray_CDOUBLE) {
if (l == 1) {
cdouble *ptr1, *ptr2, *res;
ptr1 = (cdouble *)ap2->data;
ptr2 = (cdouble *)ap1->data;
res = (cdouble *)ret->data;
res->real = ptr1->real * ptr2->real - ptr1->imag * ptr2->imag;
res->imag = ptr1->real * ptr2->imag + ptr1->imag * ptr2->real;
}
else if (ap1shape != _matrix) {
cblas_zaxpy(l, (double *)ap2->data, (double *)ap1->data,
ap1stride/sizeof(cdouble), (double *)ret->data, 1);
}
else {
int maxind, oind, i, a1s, rets;
char *ptr, *rptr;
double *pval;
maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1);
oind = 1-maxind;
ptr = ap1->data;
rptr = ret->data;
l = ap1->dimensions[maxind];
pval = (double *)ap2->data;
a1s = ap1->strides[maxind] / sizeof(cdouble);
rets = ret->strides[maxind] / sizeof(cdouble);
for (i=0; i < ap1->dimensions[oind]; i++) {
cblas_zaxpy(l, pval, (double *)ptr, a1s,
(double *)rptr, rets);
ptr += ap1->strides[oind];
rptr += ret->strides[oind];
}
}
}
else if (typenum == PyArray_FLOAT) {
if (l == 1) {
*((float *)ret->data) = *((float *)ap2->data) * \
*((float *)ap1->data);
}
else if (ap1shape != _matrix) {
cblas_saxpy(l, *((float *)ap2->data), (float *)ap1->data,
ap1stride/sizeof(float), (float *)ret->data, 1);
}
else {
int maxind, oind, i, a1s, rets;
char *ptr, *rptr;
float val;
maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1);
oind = 1-maxind;
ptr = ap1->data;
rptr = ret->data;
l = ap1->dimensions[maxind];
val = *((float *)ap2->data);
a1s = ap1->strides[maxind] / sizeof(float);
rets = ret->strides[maxind] / sizeof(float);
for (i=0; i < ap1->dimensions[oind]; i++) {
cblas_saxpy(l, val, (float *)ptr, a1s,
(float *)rptr, rets);
ptr += ap1->strides[oind];
rptr += ret->strides[oind];
}
}
}
else if (typenum == PyArray_CFLOAT) {
if (l == 1) {
cfloat *ptr1, *ptr2, *res;
ptr1 = (cfloat *)ap2->data;
ptr2 = (cfloat *)ap1->data;
res = (cfloat *)ret->data;
res->real = ptr1->real * ptr2->real - ptr1->imag * ptr2->imag;
res->imag = ptr1->real * ptr2->imag + ptr1->imag * ptr2->real;
}
else if (ap1shape != _matrix) {
cblas_caxpy(l, (float *)ap2->data, (float *)ap1->data,
ap1stride/sizeof(cfloat), (float *)ret->data, 1);
}
else {
int maxind, oind, i, a1s, rets;
char *ptr, *rptr;
float *pval;
maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1);
oind = 1-maxind;
ptr = ap1->data;
rptr = ret->data;
l = ap1->dimensions[maxind];
pval = (float *)ap2->data;
a1s = ap1->strides[maxind] / sizeof(cfloat);
rets = ret->strides[maxind] / sizeof(cfloat);
for (i=0; i < ap1->dimensions[oind]; i++) {
cblas_caxpy(l, pval, (float *)ptr, a1s,
(float *)rptr, rets);
ptr += ap1->strides[oind];
rptr += ret->strides[oind];
}
}
}
NPY_END_ALLOW_THREADS
}
static PyObject *
potential_energy_and_forces(potential_t *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {
"particles",
"neighbors",
"epot_per_at",
"epot_per_bond",
"f_per_bond",
"wpot_per_at",
"wpot_per_bond",
NULL
};
npy_intp dims[3];
npy_intp strides[3];
particles_t *a;
neighbors_t *n;
PyObject *return_epot_per_at = NULL;
PyObject *return_epot_per_bond = NULL;
PyObject *return_f_per_bond = NULL;
PyObject *return_wpot_per_at = NULL;
PyObject *return_wpot_per_bond = NULL;
int ierror = ERROR_NONE;
double epot;
PyObject *f;
PyObject *wpot;
PyObject *epot_per_at = NULL;
PyObject *epot_per_bond = NULL;
PyObject *f_per_bond = NULL;
PyObject *wpot_per_at = NULL;
PyObject *wpot_per_bond = NULL;
double *epot_per_at_ptr = NULL;
double *epot_per_bond_ptr = NULL;
double *f_per_bond_ptr = NULL;
double *wpot_per_at_ptr = NULL;
double *wpot_per_bond_ptr = NULL;
PyObject *r;
int i;
/* --- */
#ifdef DEBUG
printf("[potential_energy_and_forces] self = %p\n", self);
#endif
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!|O!O!O!O!O!", kwlist,
&particles_type, &a, &neighbors_type, &n,
&PyBool_Type, &return_epot_per_at,
&PyBool_Type, &return_epot_per_bond,
&PyBool_Type, &return_f_per_bond,
&PyBool_Type, &return_wpot_per_at,
&PyBool_Type, &return_wpot_per_bond))
return NULL;
epot = 0.0;
dims[0] = data_get_len(a->f90data);
dims[1] = 3;
strides[0] = dims[1]*NPY_SIZEOF_DOUBLE;
strides[1] = NPY_SIZEOF_DOUBLE;
f = (PyObject*) PyArray_New(&PyArray_Type, 2, dims, NPY_DOUBLE, strides,
NULL, 0, NPY_FARRAY, NULL);
memset(PyArray_DATA(f), 0, dims[0]*dims[1]*NPY_SIZEOF_DOUBLE);
dims[0] = 3;
dims[1] = 3;
wpot = PyArray_ZEROS(2, dims, NPY_DOUBLE, 1);
if (return_epot_per_at) {
if (return_epot_per_at == Py_True) {
dims[0] = data_get_len(a->f90data);
epot_per_at = PyArray_ZEROS(1, dims, NPY_DOUBLE, 1);
epot_per_at_ptr = PyArray_DATA(epot_per_at);
} else {
epot_per_at = Py_None;
Py_INCREF(Py_None);
}
}
if (return_epot_per_bond) {
if (return_epot_per_bond == Py_True) {
dims[0] = get_neighbors_size(n, a);
epot_per_bond = PyArray_ZEROS(1, dims, NPY_DOUBLE, 1);
epot_per_bond_ptr = PyArray_DATA(epot_per_bond);
} else {
epot_per_bond = Py_None;
Py_INCREF(Py_None);
}
}
if (return_f_per_bond) {
if (return_f_per_bond == Py_True) {
dims[0] = get_neighbors_size(n, a);
dims[1] = 3;
strides[0] = dims[1]*NPY_SIZEOF_DOUBLE;
strides[1] = NPY_SIZEOF_DOUBLE;
f_per_bond = (PyObject*) PyArray_New(&PyArray_Type, 2, dims,
NPY_DOUBLE, strides, NULL, 0,
NPY_FARRAY, NULL);
f_per_bond_ptr = PyArray_DATA(f_per_bond);
memset(f_per_bond_ptr, 0, dims[0]*dims[1]*NPY_SIZEOF_DOUBLE);
} else {
f_per_bond = Py_None;
Py_INCREF(Py_None);
}
}
if (return_wpot_per_at) {
if (return_wpot_per_at == Py_True) {
dims[0] = data_get_len(a->f90data);
dims[1] = 3;
dims[2] = 3;
strides[0] = dims[1]*dims[2]*NPY_SIZEOF_DOUBLE;
strides[1] = dims[2]*NPY_SIZEOF_DOUBLE;
strides[2] = NPY_SIZEOF_DOUBLE;
wpot_per_at = (PyObject*) PyArray_New(&PyArray_Type, 3, dims,
NPY_DOUBLE, strides, NULL, 0,
NPY_FARRAY, NULL);
wpot_per_at_ptr = PyArray_DATA(wpot_per_at);
memset(wpot_per_at_ptr, 0, dims[0]*dims[1]*dims[2]*NPY_SIZEOF_DOUBLE);
} else {
wpot_per_at = Py_None;
Py_INCREF(Py_None);
}
}
if (return_wpot_per_bond) {
if (return_wpot_per_bond == Py_True) {
dims[0] = get_neighbors_size(n, a);
dims[1] = 3;
dims[2] = 3;
strides[0] = dims[1]*dims[2]*NPY_SIZEOF_DOUBLE;
strides[1] = dims[2]*NPY_SIZEOF_DOUBLE;
strides[2] = NPY_SIZEOF_DOUBLE;
wpot_per_bond = (PyObject*) PyArray_New(&PyArray_Type, 3, dims,
NPY_DOUBLE, strides, NULL,
0, NPY_FARRAY, NULL);
wpot_per_bond_ptr = PyArray_DATA(wpot_per_bond);
memset(wpot_per_bond_ptr, 0, dims[0]*dims[1]*dims[2]*NPY_SIZEOF_DOUBLE);
} else {
wpot_per_bond = Py_None;
Py_INCREF(Py_None);
}
}
#ifdef DEBUG
printf("[potential_energy_and_forces] self->f90class->name = %s\n",
self->f90class->name);
printf("[potential_energy_and_forces] self->f90obj = %p\n",
self->f90obj);
printf("[potential_energy_and_forces] a->f90obj = %p\n",
a->f90obj);
printf("[potential_energy_and_forces] n->f90obj = %p\n",
n->f90obj);
printf("[potential_energy_and_forces] self->f90class->energy_and_forces = %p\n",
self->f90class->energy_and_forces);
#endif
self->f90class->energy_and_forces(self->f90obj, a->f90obj, n->f90obj,
&epot, PyArray_DATA(f), PyArray_DATA(wpot),
epot_per_at_ptr, epot_per_bond_ptr,
f_per_bond_ptr, wpot_per_at_ptr,
wpot_per_bond_ptr,
&ierror);
/*
* Now we need to reorder the per-bond properties such that some Python
* script can actually make sense out of the data.
*/
if (epot_per_bond_ptr) {
dims[0] = get_number_of_all_neighbors(n, a);
PyObject *tmp = PyArray_ZEROS(1, dims, NPY_DOUBLE, 1);
f_pack_per_bond_scalar(n->f90obj, epot_per_bond_ptr, PyArray_DATA(tmp));
Py_DECREF(epot_per_bond);
epot_per_bond = tmp;
}
if (wpot_per_bond_ptr) {
dims[0] = get_number_of_all_neighbors(n, a);
dims[1] = 3;
dims[2] = 3;
PyObject *tmp = PyArray_ZEROS(3, dims, NPY_DOUBLE, 0);
f_pack_per_bond_3x3(n->f90obj, wpot_per_bond_ptr, PyArray_DATA(tmp));
Py_DECREF(wpot_per_bond);
wpot_per_bond = tmp;
}
#ifdef DEBUG
printf("[potential_energy_and_forces] epot = %f\n", epot);
#endif
if (error_to_py(ierror))
return NULL;
/* --- Compose return tuple --- */
i = 3;
if (epot_per_at) i++;
if (epot_per_bond) i++;
if (f_per_bond) i++;
if (wpot_per_at) i++;
if (wpot_per_bond) i++;
r = PyTuple_New(i);
if (!r)
return NULL;
PyTuple_SET_ITEM(r, 0, PyFloat_FromDouble(epot));
PyTuple_SET_ITEM(r, 1, f);
PyTuple_SET_ITEM(r, 2, wpot);
i = 2;
if (epot_per_at) {
i++;
PyTuple_SET_ITEM(r, i, epot_per_at);
}
if (epot_per_bond) {
i++;
PyTuple_SET_ITEM(r, i, epot_per_bond);
}
if (f_per_bond) {
i++;
PyTuple_SET_ITEM(r, i, f_per_bond);
}
if (wpot_per_at) {
i++;
PyTuple_SET_ITEM(r, i, wpot_per_at);
}
if (wpot_per_bond) {
i++;
PyTuple_SET_ITEM(r, i, wpot_per_bond);
}
#ifdef DEBUG
printf("{potential_energy_and_forces}\n");
#endif
return r;
}
static PyObject *
fortran_getattr(PyFortranObject *fp, char *name) {
int i,j,k,flag;
if (fp->dict != NULL) {
PyObject *v = PyDict_GetItemString(fp->dict, name);
if (v != NULL) {
Py_INCREF(v);
return v;
}
}
for (i=0,j=1;i<fp->len && (j=strcmp(name,fp->defs[i].name));i++);
if (j==0)
if (fp->defs[i].rank!=-1) { /* F90 allocatable array */
if (fp->defs[i].func==NULL) return NULL;
for(k=0;k<fp->defs[i].rank;++k)
fp->defs[i].dims.d[k]=-1;
save_def = &fp->defs[i];
(*(fp->defs[i].func))(&fp->defs[i].rank,fp->defs[i].dims.d,set_data,&flag);
if (flag==2)
k = fp->defs[i].rank + 1;
else
k = fp->defs[i].rank;
if (fp->defs[i].data !=NULL) { /* array is allocated */
PyObject *v = PyArray_New(&PyArray_Type, k, fp->defs[i].dims.d,
fp->defs[i].type, NULL, fp->defs[i].data, 0, NPY_FARRAY,
NULL);
if (v==NULL) return NULL;
/* Py_INCREF(v); */
return v;
} else { /* array is not allocated */
Py_INCREF(Py_None);
return Py_None;
}
}
if (strcmp(name,"__dict__")==0) {
Py_INCREF(fp->dict);
return fp->dict;
}
if (strcmp(name,"__doc__")==0) {
#if PY_VERSION_HEX >= 0x03000000
PyObject *s = PyUnicode_FromString(""), *s2, *s3;
for (i=0;i<fp->len;i++) {
s2 = fortran_doc(fp->defs[i]);
s3 = PyUnicode_Concat(s, s2);
Py_DECREF(s2);
Py_DECREF(s);
s = s3;
}
#else
PyObject *s = PyString_FromString("");
for (i=0;i<fp->len;i++)
PyString_ConcatAndDel(&s,fortran_doc(fp->defs[i]));
#endif
if (PyDict_SetItemString(fp->dict, name, s))
return NULL;
return s;
}
if ((strcmp(name,"_cpointer")==0) && (fp->len==1)) {
PyObject *cobj = F2PyCapsule_FromVoidPtr((void *)(fp->defs[0].data),NULL);
if (PyDict_SetItemString(fp->dict, name, cobj))
return NULL;
return cobj;
}
#if PY_VERSION_HEX >= 0x03000000
if (1) {
PyObject *str, *ret;
str = PyUnicode_FromString(name);
ret = PyObject_GenericGetAttr((PyObject *)fp, str);
Py_DECREF(str);
return ret;
}
#else
return Py_FindMethod(fortran_methods, (PyObject *)fp, name);
#endif
}
/*
* digitize(x, bins, right=False) returns an array of integers the same length
* as x. The values i returned are such that bins[i - 1] <= x < bins[i] if
* bins is monotonically increasing, or bins[i - 1] > x >= bins[i] if bins
* is monotonically decreasing. Beyond the bounds of bins, returns either
* i = 0 or i = len(bins) as appropriate. If right == True the comparison
* is bins [i - 1] < x <= bins[i] or bins [i - 1] >= x > bins[i]
*/
NPY_NO_EXPORT PyObject *
arr_digitize(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds)
{
PyObject *obj_x = NULL;
PyObject *obj_bins = NULL;
PyArrayObject *arr_x = NULL;
PyArrayObject *arr_bins = NULL;
PyObject *ret = NULL;
npy_intp len_bins;
int monotonic, right = 0;
NPY_BEGIN_THREADS_DEF
static char *kwlist[] = {"x", "bins", "right", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,
&obj_x, &obj_bins, &right)) {
goto fail;
}
/* PyArray_SearchSorted will make `x` contiguous even if we don't */
arr_x = (PyArrayObject *)PyArray_FROMANY(obj_x, NPY_DOUBLE, 0, 0,
NPY_ARRAY_CARRAY_RO);
if (arr_x == NULL) {
goto fail;
}
/* TODO: `bins` could be strided, needs change to check_array_monotonic */
arr_bins = (PyArrayObject *)PyArray_FROMANY(obj_bins, NPY_DOUBLE, 1, 1,
NPY_ARRAY_CARRAY_RO);
if (arr_bins == NULL) {
goto fail;
}
len_bins = PyArray_SIZE(arr_bins);
if (len_bins == 0) {
PyErr_SetString(PyExc_ValueError, "bins must have non-zero length");
goto fail;
}
NPY_BEGIN_THREADS_THRESHOLDED(len_bins)
monotonic = check_array_monotonic((const double *)PyArray_DATA(arr_bins),
len_bins);
NPY_END_THREADS
if (monotonic == 0) {
PyErr_SetString(PyExc_ValueError,
"bins must be monotonically increasing or decreasing");
goto fail;
}
/* PyArray_SearchSorted needs an increasing array */
if (monotonic == - 1) {
PyArrayObject *arr_tmp = NULL;
npy_intp shape = PyArray_DIM(arr_bins, 0);
npy_intp stride = -PyArray_STRIDE(arr_bins, 0);
void *data = (void *)(PyArray_BYTES(arr_bins) - stride * (shape - 1));
arr_tmp = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &shape,
NPY_DOUBLE, &stride, data, 0,
PyArray_FLAGS(arr_bins), NULL);
if (!arr_tmp) {
goto fail;
}
if (PyArray_SetBaseObject(arr_tmp, (PyObject *)arr_bins) < 0) {
Py_DECREF(arr_tmp);
goto fail;
}
arr_bins = arr_tmp;
}
ret = PyArray_SearchSorted(arr_bins, (PyObject *)arr_x,
right ? NPY_SEARCHLEFT : NPY_SEARCHRIGHT, NULL);
if (!ret) {
goto fail;
}
/* If bins is decreasing, ret has bins from end, not start */
if (monotonic == -1) {
npy_intp *ret_data =
(npy_intp *)PyArray_DATA((PyArrayObject *)ret);
npy_intp len_ret = PyArray_SIZE((PyArrayObject *)ret);
NPY_BEGIN_THREADS_THRESHOLDED(len_ret)
while (len_ret--) {
*ret_data = len_bins - *ret_data;
ret_data++;
}
NPY_END_THREADS
}
/* 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, NPY_ARRAY_WRITEABLE, 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;
}
static PyObject *
do_get_segment_data (PyObject *self, PyObject *args, PyObject *kwds)
{
NsLibrary *lib;
PyObject *cobj;
PyObject *iobj, *id_obj, *idx_obj, *sz_obj, *src_obj;
PyObject *res_obj;
PyObject *array;
uint32 file_id;
uint32 entity_id;
uint32 index;
uint32 count;
uint32 sources;
uint32 sample_count;
uint32 uint_id;
uint32 buffer_size;
ns_RESULT res;
double *buffer;
npy_intp dims[2];
double time_stamp;
if (!PyArg_ParseTuple (args, "OOOOOO", &cobj, &iobj, &id_obj, &idx_obj, &src_obj, &sz_obj))
{
PyErr_SetString (PyExc_StandardError, "Could not parse arguments");
return NULL;
}
if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) ||
!PyInt_Check (id_obj) || !PyInt_Check (idx_obj) ||
!PyInt_Check (sz_obj) || !PyInt_Check (src_obj))
{
PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)");
return NULL;
}
lib = PyCObject_AsVoidPtr (cobj);
file_id = (uint32) PyInt_AsUnsignedLongMask (iobj);
entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj);
index = (uint32) PyInt_AsUnsignedLongMask (idx_obj);
count = (uint32) PyInt_AsUnsignedLongMask (sz_obj);
sources = (uint32) PyInt_AsUnsignedLongMask (src_obj);
/* ** */
dims[0] = sources; //source count
dims[1] = count; //sample count
array = PyArray_New (&PyArray_Type,
2,
dims,
NPY_DOUBLE,
NULL,
NULL /* data */,
0 /* itemsize */,
0,
NULL);
buffer = (double *) PyArray_DATA (array);
buffer_size = (uint32) PyArray_NBYTES (array);
res = lib->GetSegmentData (file_id,
entity_id,
index,
&time_stamp,
buffer,
buffer_size,
&sample_count,
&uint_id);
if (check_result_is_error (res, lib))
{
Py_DECREF (array);
return NULL;
}
res_obj = PyTuple_New (4);
PyTuple_SetItem (res_obj, 0, array);
PyTuple_SetItem (res_obj, 1, PyFloat_FromDouble (time_stamp));
PyTuple_SetItem (res_obj, 2, PyInt_FromLong (sample_count));
PyTuple_SetItem (res_obj, 3, PyInt_FromLong (uint_id));
return res_obj;
}
static PyObject *
do_get_neural_data (PyObject *self, PyObject *args, PyObject *kwds)
{
NsLibrary *lib;
PyObject *cobj;
PyObject *iobj, *id_obj, *idx_obj, *sz_obj;
PyObject *array;
uint32 file_id;
uint32 entity_id;
uint32 index;
uint32 index_count;
ns_RESULT res;
void *buffer;
npy_intp dims[1];
if (!PyArg_ParseTuple (args, "OOOOO", &cobj, &iobj, &id_obj, &idx_obj, &sz_obj))
{
PyErr_SetString (PyExc_StandardError, "Could not parse arguments");
return NULL;
}
if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) ||
!PyInt_Check (id_obj) || !PyInt_Check (idx_obj) ||
!PyInt_Check (sz_obj))
{
PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)");
return NULL;
}
lib = PyCObject_AsVoidPtr (cobj);
file_id = (uint32) PyInt_AsUnsignedLongMask (iobj);
entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj);
index = (uint32) PyInt_AsUnsignedLongMask (idx_obj);
index_count = (uint32) PyInt_AsUnsignedLongMask (sz_obj);
/* ** */
dims[0] = index_count;
array = PyArray_New (&PyArray_Type,
1,
dims,
NPY_DOUBLE,
NULL,
NULL /* data */,
0 /* itemsize */,
NPY_CARRAY,
NULL);
buffer = PyArray_DATA (array);
res = lib->GetNeuralData (file_id,
entity_id,
index,
index_count,
buffer);
if (check_result_is_error (res, lib))
{
Py_DECREF (array);
return NULL;
}
return array;
}
static PyObject * enz_vnmpocnp(PyObject *self, PyObject *args,
PyObject *keywds)
{
static char *kwlist[] = { "r", "f", "n", "m", "L_max",
"bessel_name", "ncpus", "verb", NULL };
long syscpus = sysconf(_SC_NPROCESSORS_ONLN);
PyObject *r_o, *f_o, *n_o, *m_o;
PyObject *r = NULL;
PyObject *f = NULL;
PyObject *n = NULL;
PyObject *m = NULL;
const char *error = NULL;
npy_intp r_n, f_n, beta_n;
PyObject *vnm = NULL;
npy_intp vnm_dims[3];
double *datar = NULL;
complex double *dataf = NULL;
int *datan = NULL;
int *datam = NULL;
complex double *datap = NULL;
int kL_max = 35;
int kncpus = -1;
int kverb = 0;
char *kbessel_name = "jn";
int ret;
if (syscpus <= 0)
syscpus = 1;
if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!O!O!O!|isii",
kwlist,
&PyArray_Type, &r_o,
&PyArray_Type, &f_o,
&PyArray_Type, &n_o,
&PyArray_Type, &m_o,
&kL_max, &kbessel_name, &kncpus, &kverb)) {
PyErr_SetString(PyExc_SyntaxError, "failed to parse args");
return NULL;
}
r = PyArray_FROM_OTF(r_o, NPY_FLOAT64, NPY_ARRAY_IN_ARRAY);
f = PyArray_FROM_OTF(f_o, NPY_COMPLEX128, NPY_ARRAY_IN_ARRAY);
n = PyArray_FROM_OTF(n_o, NPY_INT64, NPY_ARRAY_IN_ARRAY);
m = PyArray_FROM_OTF(m_o, NPY_INT64, NPY_ARRAY_IN_ARRAY);
if (!r) {
PyErr_SetString(PyExc_ValueError, "cannot convert r to PyArray");
return NULL;
}
if (!f) {
PyErr_SetString(PyExc_ValueError, "cannot convert f to PyArray");
return NULL;
}
if (!n) {
PyErr_SetString(PyExc_ValueError, "cannot convert n to PyArray");
return NULL;
}
if (!m) {
PyErr_SetString(PyExc_ValueError, "cannot convert m to PyArray");
return NULL;
}
if (!r || not_vect(r) || PyArray_TYPE((PyArrayObject*)r) != NPY_FLOAT64) {
error = "r is not a vector of doubles";
goto exit_decrement;
}
r_n = PyArray_DIM((PyArrayObject*)r, 0);
if (!f || not_vect(f) ||
PyArray_TYPE((PyArrayObject*)f) != NPY_COMPLEX128) {
error = "f is not a vector of complex numbers";
goto exit_decrement;
}
f_n = PyArray_DIM((PyArrayObject*)f, 0);
if (!n || not_vect(n) || PyArray_TYPE((PyArrayObject*)n) != NPY_INT64) {
error = "n is not a vector of integers";
goto exit_decrement;
}
if (!m || not_vect(m) || PyArray_TYPE((PyArrayObject*)m) != NPY_INT64) {
error = "m is not a vector of integers";
goto exit_decrement;
}
if (PyArray_DIM((PyArrayObject*)n, 0) !=
PyArray_DIM((PyArrayObject*)m, 0)) {
error = "n and m must have the same length";
goto exit_decrement;
}
beta_n = PyArray_DIM((PyArrayObject*)n, 0);
vnm_dims[0] = r_n;
vnm_dims[1] = f_n;
vnm_dims[2] = beta_n;
vnm = PyArray_New(&PyArray_Type, 3, vnm_dims, NPY_COMPLEX128, NULL, NULL,
0, NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED, NULL);
if (!vnm) {
error = "cannot create vnm";
goto exit_decrement;
}
PyArray_CLEARFLAGS((PyArrayObject*)vnm, NPY_ARRAY_C_CONTIGUOUS);
assert(PyArray_Size(vnm) == (r_n * f_n * beta_n));
assert(PyArray_NBYTES(vnm) == (r_n * f_n * beta_n * sizeof(double complex)));
datap = PyArray_DATA((PyArrayObject*)vnm);
if (kncpus < 0)
kncpus = beta_n < syscpus ? beta_n : syscpus;
else
kncpus = kncpus > syscpus ? syscpus : kncpus;
if ((r_n * f_n * beta_n) != 0) {
datar = PyArray_DATA((PyArrayObject*)r);
dataf = PyArray_DATA((PyArrayObject*)f);
datan = PyArray_DATA((PyArrayObject*)n);
datam = PyArray_DATA((PyArrayObject*)m);
Py_BEGIN_ALLOW_THREADS
ret = vnmpocnp(r_n, datar,
f_n, dataf,
beta_n,
datan, datam,
kL_max, kbessel_name,
kncpus,
kverb, datap, &error);
Py_END_ALLOW_THREADS
if (ret) {
Py_XDECREF(vnm);
goto exit_decrement;
}
}
