Changeset 54b0650 in sasview for src/sas/sascalc/calculator/c_extensions

Timestamp:

Nov 7, 2017 1:05:12 PM (7 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

f926abb

Parents:

0957bb3a

Message:

fix C interface to sldi after py3 conversion

Location:

src/sas/sascalc/calculator/c_extensions

Files:

• sld2i.c (modified) (5 diffs)
• sld2i.h (modified) (2 diffs)
• sld2i_module.c (modified) (5 diffs)

src/sas/sascalc/calculator/c_extensions/sld2i.c

@@ -25 +25 @@
  * @param s_theta: angle (from x-axis) of the up spin in degree
  */
-void initGenI(GenI* this, int npix, double* x, double* y, double* z, double* sldn,
+void initGenI(GenI* this, int is_avg, int npix, double* x, double* y, double* z, double* sldn,
                         double* mx, double* my, double* mz, double* voli,
                         double in_spin, double out_spin,
                         double s_theta) {
+        this->is_avg = is_avg;
         this->n_pix = npix;
         this->x_val = x;
@@ -73 +74 @@
         // Loop over q-values and multiply apply matrix
 
+        //printf("npoints: %d, npix: %d\n", npoints, this->n_pix);
         for(int i=0; i<npoints; i++){
                 //I_out[i] = 0.0;
@@ -150 +152 @@
         // Assumes that q doesn't have qz component and sld_n is all real
         //double Pi = 4.0*atan(1.0);
-        int is_sym = this->n_pix < 0;
         double qr = 0.0;
         double sumj;
         double sld_j = 0.0;
         double count = 0.0;
-        int n_pix = is_sym ? -this->n_pix : this->n_pix;
         //Assume that pixel volumes are given in vol_pix in A^3 unit
         // Loop over q-values and multiply apply matrix
         for(int i=0; i<npoints; i++){
                 sumj =0.0;
-                for(int j=0; j<n_pix; j++){
+                for(int j=0; j<this->n_pix; j++){
                         //Isotropic: Assumes all slds are real (no magnetic)
                         //Also assumes there is no polarization: No dependency on spin
-                        if (is_sym == 1){
+                        if (this->is_avg == 1){
                                 // approximation for a spherical symmetric particle
                                 qr = sqrt(this->x_val[j]*this->x_val[j]+this->y_val[j]*this->y_val[j]+this->z_val[j]*this->z_val[j])*q[i];
@@ -177 +177 @@
                                 //full calculation
                                 //pragma omp parallel for
-                                for(int k=0; k<n_pix; k++){
+                                for(int k=0; k<this->n_pix; k++){
                                         sld_j =  this->sldn_val[j] * this->sldn_val[k] * this->vol_pix[j] * this->vol_pix[k];
                                         qr = (this->x_val[j]-this->x_val[k])*(this->x_val[j]-this->x_val[k])+
@@ -196 +196 @@
                 }
                 I_out[i] = sumj;
-                if (is_sym == 1){
+                if (this->is_avg == 1) {
                         I_out[i] *= sumj;
                 }

src/sas/sascalc/calculator/c_extensions/sld2i.h

@@ -10 +10 @@
 typedef struct {
         // vectors
+        int is_avg;
         int n_pix;
         double* x_val;
@@ -26 +27 @@
 
 // Constructor
-void initGenI(GenI*, int npix, double* x, double* y, double* z, double* sldn,
-                double* mx, double* my, double* mz, double* voli,
+void initGenI(GenI*, int is_avg, int npix, double* x, double* y, double* z,
+                double* sldn, double* mx, double* my, double* mz, double* voli,
                 double in_spin, double out_spin,
                 double s_theta);

src/sas/sascalc/calculator/c_extensions/sld2i_module.c

@@ -35 +35 @@
 void
 del_sld2i(PyObject *obj){
+#if PY_MAJOR_VERSION < 3
+        GenI* sld2i = (GenI *)obj;
+#else
         GenI* sld2i = (GenI *)(PyCapsule_GetPointer(obj, "GenI"));
+#endif
         PyMem_Free((void *)sld2i);
 }
@@ -51 +55 @@
         PyObject *mz_val_obj;
         PyObject *vol_pix_obj;
-        Py_ssize_t n_x;
-        //PyObject rlimit_obj;
-        //PyObject npoints_obj;
-        //PyObject nrbins_obj;
-        //PyObject nphibins_obj;
-        int n_pix;
+        Py_ssize_t n_x, n_y, n_z, n_sld, n_mx, n_my, n_mz, n_vol_pix;
+        int is_avg;
         double* x_val;
         double* y_val;
@@ -69 +69 @@
         double stheta;
 
-        if (!PyArg_ParseTuple(args, "iOOOOOOOOddd", &n_pix, &x_val_obj, &y_val_obj, &z_val_obj, &sldn_val_obj, &mx_val_obj, &my_val_obj, &mz_val_obj, &vol_pix_obj, &inspin, &outspin, &stheta)) return NULL;
-        OUTVECTOR(x_val_obj, x_val, n_x);
-        OUTVECTOR(y_val_obj, y_val, n_x);
-        OUTVECTOR(z_val_obj, z_val, n_x);
-        OUTVECTOR(sldn_val_obj, sldn_val, n_x);
-        OUTVECTOR(mx_val_obj, mx_val, n_x);
-        OUTVECTOR(my_val_obj, my_val, n_x);
-        OUTVECTOR(mz_val_obj, mz_val, n_x);
-        OUTVECTOR(vol_pix_obj, vol_pix, n_x);
-        GenI* sld2i =  PyMem_Malloc(sizeof(GenI));
+        if (!PyArg_ParseTuple(args, "iOOOOOOOOddd", &is_avg, &x_val_obj, &y_val_obj, &z_val_obj, &sldn_val_obj, &mx_val_obj, &my_val_obj, &mz_val_obj, &vol_pix_obj, &inspin, &outspin, &stheta)) return NULL;
+        INVECTOR(x_val_obj, x_val, n_x);
+        INVECTOR(y_val_obj, y_val, n_y);
+        INVECTOR(z_val_obj, z_val, n_z);
+        INVECTOR(sldn_val_obj, sldn_val, n_sld);
+        INVECTOR(mx_val_obj, mx_val, n_mx);
+        INVECTOR(my_val_obj, my_val, n_my);
+        INVECTOR(mz_val_obj, mz_val, n_mz);
+        INVECTOR(vol_pix_obj, vol_pix, n_vol_pix);
+        GenI* sld2i = PyMem_Malloc(sizeof(GenI));
+        //printf("sldi:%p\n", sld2i);
         if (sld2i != NULL) {
-                initGenI(sld2i, n_pix,x_val,y_val,z_val,sldn_val,mx_val,my_val,mz_val,vol_pix,inspin,outspin,stheta);
+                initGenI(sld2i,is_avg,n_x,x_val,y_val,z_val,sldn_val,mx_val,my_val,mz_val,vol_pix,inspin,outspin,stheta);
         }
-        return PyCapsule_New(sld2i, "GenI", del_sld2i);
+        PyObject *obj = PyCapsule_New(sld2i, "GenI", del_sld2i);
+        //printf("constructed %p\n", obj);
+        return obj;
 }
 
@@ -89 +92 @@
  */
 PyObject * genicom_inputXY(PyObject *self, PyObject *args) {
-        int npoints;
+        PyObject *gen_obj;
         PyObject *qx_obj;
+        PyObject *qy_obj;
+        PyObject *I_out_obj;
+        Py_ssize_t n_qx, n_qy, n_out;
         double *qx;
-        PyObject *qy_obj;
         double *qy;
-        PyObject *I_out_obj;
-        Py_ssize_t n_out;
         double *I_out;
-        PyObject *gen_obj;
 
-        if (!PyArg_ParseTuple(args, "OiOOO",  &gen_obj, &npoints, &qx_obj, &qy_obj, &I_out_obj)) return NULL;
-        OUTVECTOR(qx_obj, qx, n_out);
-        OUTVECTOR(qy_obj, qy, n_out);
+        if (!PyArg_ParseTuple(args, "OOOO",  &gen_obj, &qx_obj, &qy_obj, &I_out_obj)) return NULL;
+        GenI* sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI");
+        INVECTOR(qx_obj, qx, n_qx);
+        INVECTOR(qy_obj, qy, n_qy);
         OUTVECTOR(I_out_obj, I_out, n_out);
 
         // Sanity check
-        //if(n_in!=n_out) return Py_BuildValue("i",-1);
+        //if(n_q!=n_out) return Py_BuildValue("i",-1);
 
-        // Set the array pointers
-        GenI* sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI");
-
-        genicomXY(sld2i, npoints, qx, qy, I_out);
+        genicomXY(sld2i, n_qx, qx, qy, I_out);
         //return PyCObject_FromVoidPtr(s, del_genicom);
         return Py_BuildValue("i",1);
@@ -119 +119 @@
  */
 PyObject * genicom_input(PyObject *self, PyObject *args) {
-        int npoints;
+        PyObject *gen_obj;
         PyObject *q_obj;
+        PyObject *I_out_obj;
+        Py_ssize_t n_q, n_out;
         double *q;
-        PyObject *I_out_obj;
-        Py_ssize_t n_out;
         double *I_out;
-        PyObject *gen_obj;
 
-        if (!PyArg_ParseTuple(args, "OiOO",  &gen_obj, &npoints, &q_obj, &I_out_obj)) return NULL;
-        OUTVECTOR(q_obj, q, n_out);
+        if (!PyArg_ParseTuple(args, "OOO",  &gen_obj, &q_obj, &I_out_obj)) return NULL;
+        GenI *sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI");
+        INVECTOR(q_obj, q, n_q);
         OUTVECTOR(I_out_obj, I_out, n_out);
 
         // Sanity check
-        //if(n_in!=n_out) return Py_BuildValue("i",-1);
+        //if (n_q!=n_out) return Py_BuildValue("i",-1);
 
-        // Set the array pointers
-        GenI *sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI");
-
-        genicom(sld2i, npoints, q, I_out);
-        //return PyCObject_FromVoidPtr(s, del_genicom);
+        genicom(sld2i, n_q, q, I_out);
         return Py_BuildValue("i",1);
 }