Ignore:
Timestamp:
Jul 27, 2009 6:10:49 PM (15 years ago)
Author:
Gervaise Alina <gervyh@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
f20767b
Parents:
812b901
Message:

code reverse initial definition of run and runXY restore

File:
1 edited

Legend:

Unmodified
Added
Removed

  • sansmodels/src/sans/models/c_models/classTemplate.txt

    r812b901 r4176435  
    2323 */ 
    2424  
    25 #define NO_IMPORT_ARRAY 
    26 #define PY_ARRAY_UNIQUE_SYMBOL PyArray_API_sans 
    27  
    2825extern "C" { 
    2926#include <Python.h> 
    30 #include <arrayobject.h> 
    3127#include "structmember.h" 
    3228#include <stdio.h> 
    … …  
    120116    } 
    121117} 
    122 /** 
    123  * Function to call to evaluate model 
    124  * @param args: input numpy array q[]  
    125  * @return: numpy array object  
    126  */ 
    127   
    128 static PyObject *evaluateOneDim([CMODEL]* model, PyArrayObject *q){ 
    129     PyArrayObject *result; 
    130     
    131     // Check validity of array q , q must be of dimension 1, an array of double 
    132     if (q->nd != 1 || q->descr->type_num != PyArray_DOUBLE) 
    133     { 
    134         //const char * message= "Invalid array: q->nd=%d,type_num=%d\n",q->nd,q->descr->type_num; 
    135         //PyErr_SetString(PyExc_ValueError , message); 
    136         return NULL; 
    137     } 
    138     result = (PyArrayObject *)PyArray_FromDims(q->nd, (int *)(q->dimensions),  
    139                                                                                   PyArray_DOUBLE); 
    140         if (result == NULL) { 
    141         const char * message= "Could not create result "; 
    142         PyErr_SetString(PyExc_RuntimeError , message); 
    143                 return NULL; 
    144         } 
    145          for (int i = 0; i < q->dimensions[0]; i++){ 
    146       double q_value  = *(double *)(q->data + i*q->strides[0]); 
    147       double *result_value = (double *)(result->data + i*result->strides[0]); 
    148       *result_value =(*model)(q_value); 
    149         } 
    150     return PyArray_Return(result);  
    151  } 
    152 /** 
    153  * Function to call to evaluate model 
    154  * @param args: input numpy array  [q[],phi[]] 
    155  * @return: numpy array object  
    156  */ 
    157  static PyObject * evaluateTwoDim( [CMODEL]* model,  
    158                               PyArrayObject *q, PyArrayObject *phi) 
    159  { 
    160     PyArrayObject *result; 
    161     //check validity of input vectors 
    162     if (q->nd != 1 || q->descr->type_num != PyArray_DOUBLE 
    163         || phi->nd != 1 || phi->descr->type_num != PyArray_DOUBLE 
    164         || phi->dimensions[0] != q->dimensions[0]){ 
    165          
    166         //const char * message= "Invalid array: q->nd=%d,type_num=%d\n",q->nd,q->descr->type_num; 
    167         //PyErr_SetString(PyExc_ValueError , message);  
    168         return NULL; 
    169     } 
    170         result= (PyArrayObject *)PyArray_FromDims(q->nd,(int*)(q->dimensions), PyArray_DOUBLE); 
    171  
    172         if (result == NULL){ 
    173             const char * message= "Could not create result "; 
    174         PyErr_SetString(PyExc_RuntimeError , message); 
    175             return NULL; 
    176         } 
    177          
    178     for (int i = 0; i < q->dimensions[0]; i++) { 
    179       double q_value = *(double *)(q->data + i*q->strides[0]); 
    180       double phi_value = *(double *)(phi->data + i*phi->strides[0]); 
    181       double *result_value = (double *)(result->data + i*result->strides[0]); 
    182       if (q_value == 0) 
    183           *result_value = 0.0; 
    184       else 
    185           *result_value = model->evaluate_rphi(q_value, phi_value); 
    186     } 
    187     return PyArray_Return(result);  
    188  } 
    189   
    190  /** 
    191  * Function to call to evaluate model 
    192  * @param args: input numpy array  [x[],y[]] 
    193  * @return: numpy array object  
    194  */ 
    195  static PyObject * evaluateTwoDimXY( [CMODEL]* model,  
    196                               PyArrayObject *x, PyArrayObject *y) 
    197  { 
    198     PyArrayObject *result; 
    199     //check validity of input vectors 
    200     if (x->nd != 1 || x->descr->type_num != PyArray_DOUBLE 
    201         || y->nd != 1 || y->descr->type_num != PyArray_DOUBLE 
    202         || y->dimensions[0] != x->dimensions[0]){ 
    203          
    204         //const char * message= "Invalid array: x->nd=%d,type_num=%d\n",x->nd,x->descr->type_num; 
    205         //PyErr_SetString(PyExc_ValueError , message);  
    206         return NULL; 
    207     } 
    208         result= (PyArrayObject *)PyArray_FromDims(x->nd,(int*)(x->dimensions), PyArray_DOUBLE); 
    209  
    210         if (result == NULL){ 
    211             const char * message= "Could not create result "; 
    212         PyErr_SetString(PyExc_RuntimeError , message); 
    213             return NULL; 
    214         } 
    215          
    216     for (int i = 0; i < x->dimensions[0]; i++) { 
    217       double x_value = *(double *)(x->data + i*x->strides[0]); 
    218       double y_value = *(double *)(y->data + i*y->strides[0]); 
    219       double *result_value = (double *)(result->data + i*result->strides[0]); 
    220       *result_value = (*model)(x_value, y_value); 
    221     } 
    222     return PyArray_Return(result);  
    223  } 
    224   
     118 
     119 
    225120/** 
    226121 * Function to call to evaluate model 
    … …  
    254149                return NULL; 
    255150            } 
    256              
    257151            // We have a vector q, get the q and phi values at which 
    258152            // to evaluate I(q,phi) 
    259             PyObject *q, *phi; 
    260             q = PyList_GET_ITEM(pars,0); 
    261             phi = PyList_GET_ITEM(pars,1); 
    262              
    263             if (PyArray_Check(q) && PyArray_Check(phi)) { 
    264                   return evaluateTwoDim(self->model, (PyArrayObject*)q, (PyArrayObject*)phi);  
    265             } else if (PyArray_Check(q) || PyArray_Check(phi)) { 
    266                 return NULL; 
    267             } else { 
    268                 q_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,0)); 
    269                 phi_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,1)); 
    270                 // Skip zero 
    271                 if (q_value==0) { 
    272                     return Py_BuildValue("d",0.0); 
    273                 } 
    274                     return Py_BuildValue("d",(*(self->model)).evaluate_rphi(q_value,phi_value)); 
    275         } 
     153            q_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,0)); 
     154            phi_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,1)); 
     155            // Skip zero 
     156            if (q_value==0) { 
     157                return Py_BuildValue("d",0.0); 
     158            } 
     159                return Py_BuildValue("d",(*(self->model)).evaluate_rphi(q_value,phi_value)); 
     160 
    276161        } else { 
    277         if (PyArray_Check(pars)) { 
    278                 return evaluateOneDim(self->model, (PyArrayObject*)pars);  
    279     } else { 
    280             // We have a scalar q, we will evaluate I(q) 
     162 
     163                // We have a scalar q, we will evaluate I(q) 
    281164                q_value = [PYTHONCLASS]_readDouble(pars);                
    282             return Py_BuildValue("d",(*(self->model))(q_value)); 
    283             }    
    284         } 
     165                 
     166                return Py_BuildValue("d",(*(self->model))(q_value)); 
     167        }        
    285168} 
    286169 
    … …  
    318201            // We have a vector q, get the qx and qy values at which 
    319202            // to evaluate I(qx,qy) 
    320             PyObject *x, *y; 
    321             x = PyList_GET_ITEM(pars,0); 
    322             y = PyList_GET_ITEM(pars,1); 
    323              
    324             if (PyArray_Check(x) && PyArray_Check(y)) { 
    325                 
    326                     return evaluateTwoDimXY(self->model, (PyArrayObject*)x, (PyArrayObject*)y);  
    327             } else if (PyArray_Check(x) || PyArray_Check(y)) { 
    328                 return NULL; 
    329             } else {     
    330                 qx_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,0)); 
    331                 qy_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,1)); 
    332                 return Py_BuildValue("d",(*(self->model))(qx_value,qy_value)); 
    333             } 
     203            qx_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,0)); 
     204            qy_value = [PYTHONCLASS]_readDouble(PyList_GET_ITEM(pars,1)); 
     205            return Py_BuildValue("d",(*(self->model))(qx_value,qy_value)); 
    334206 
    335207        } else { 
    336                 if (PyArray_Check(pars)) { 
    337                     return evaluateOneDim(self->model, (PyArrayObject*)pars);  
    338         } else { 
    339                     // We have a scalar q, we will evaluate I(q) 
    340                     qx_value = [PYTHONCLASS]_readDouble(pars);           
     208 
     209                // We have a scalar q, we will evaluate I(q) 
     210                qx_value = [PYTHONCLASS]_readDouble(pars);               
    341211                 
    342                     return Py_BuildValue("d",(*(self->model))(qx_value)); 
    343                 } 
     212                return Py_BuildValue("d",(*(self->model))(qx_value)); 
    344213        }        
    345214} 
    … …  
    433302 
    434303 
     304static PyMethodDef module_methods[] = { 
     305    {NULL}  
     306}; 
     307 
    435308/** 
    436309 * Function used to add the model class to a module 
Note: See TracChangeset for help on using the changeset viewer.