Changeset 14221

Timestamp:

01/09/13 10:47:56 (12 years ago)

Author:

Mathieu Morlighem

Message:

CHG: index and segments are now integers

Location:

issm/trunk-jpl/src/wrappers

Files:

• TriMesh/TriMesh.cpp (modified) (1 diff)
• TriMeshProcessRifts/TriMeshProcessRifts.cpp (modified) (1 diff)
• matlab/io/WriteMatlabData.cpp (modified) (2 diffs)
• matlab/io/matlabio.h (modified) (2 diffs)
• python/io/FetchPythonData.cpp (modified) (1 diff)
• python/io/WritePythonData.cpp (modified) (2 diffs)
• python/io/pythonio.h (modified) (2 diffs)

issm/trunk-jpl/src/wrappers/TriMesh/TriMesh.cpp

@@ -22 +22 @@
 
         /* output: */
-        SeqMat<double> *index             = NULL;
+        SeqMat<int>    *index             = NULL;
         SeqVec<double> *x                 = NULL;
         SeqVec<double> *y                 = NULL;
-        SeqMat<double> *segments          = NULL;
-        SeqVec<double> *segmentmarkerlist = NULL;
+        SeqMat<int>    *segments          = NULL;
+        SeqVec<int>    *segmentmarkerlist = NULL;
 
         /*Boot module: */

issm/trunk-jpl/src/wrappers/TriMeshProcessRifts/TriMeshProcessRifts.cpp

@@ -18 +18 @@
         /* input: */
         int     nel,nods;
-        double *index          = NULL;
+        int    *index          = NULL;
         double *x              = NULL;
         double *y              = NULL;
-        double *segments       = NULL;
-        double *segmentmarkers = NULL;
+        int    *segments       = NULL;
+        int    *segmentmarkers = NULL;
         int     num_seg;
 

issm/trunk-jpl/src/wrappers/matlab/io/WriteMatlabData.cpp

@@ -290 +290 @@
 }
 /*}}}*/
+/*FUNCTION WriteData(mxArray** pdataref,SeqMat<int>* matrix){{{*/
+void WriteData(mxArray** pdataref,SeqMat<int>* matrix){
+
+        int      i,j;
+        int      rows,cols;
+        mxArray *dataref     = NULL;
+        int     *matrix_ptr  = NULL;
+        double  *tmatrix_ptr = NULL;
+
+        if(matrix){
+
+                matrix_ptr=matrix->ToSerial();
+                matrix->GetSize(&rows,&cols);
+
+                /*Now transpose the matrix and allocate with Matlab's memory manager: */
+                tmatrix_ptr=(double*)mxMalloc(rows*cols*sizeof(double));
+                for(i=0;i<rows;i++){
+                        for(j=0;j<cols;j++){
+                                tmatrix_ptr[j*rows+i]=(double)matrix_ptr[i*cols+j];
+                        }
+                }
+
+                /*create matlab matrix: */
+                dataref=mxCreateDoubleMatrix(0,0,mxREAL);
+                mxSetM(dataref,rows); 
+                mxSetN(dataref,cols);
+                mxSetPr(dataref,tmatrix_ptr);
+
+                /*Free ressources:*/
+                xDelete<int>(matrix_ptr);
+        }
+        else{
+                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
+        }
+
+        *pdataref=dataref;
+}
+/*}}}*/
+/*FUNCTION WriteData(mxArray** pdataref,SeqVec<int>* vector){{{*/
+void WriteData(mxArray** pdataref,SeqVec<int>* vector){
+
+        mxArray* dataref=NULL;
+        int*     vector_ptr=NULL;
+        double*  vector_matlab=NULL;
+        int      rows;
+
+        if(vector){
+                /*call toolkit routine: */
+                vector_ptr=vector->ToMPISerial();
+                vector->GetSize(&rows);
+
+                /*now create the matlab vector with Matlab's memory manager */
+                vector_matlab=(double*)mxMalloc(rows*sizeof(double));
+                for(int i=0;i<rows;i++) vector_matlab[i]=(double)vector_ptr[i];
+
+                dataref = mxCreateDoubleMatrix(0,0,mxREAL);                         
+                mxSetM(dataref,rows);
+                mxSetN(dataref,1);                                                                                          
+                mxSetPr(dataref,vector_matlab);           
+        }
+        else{
+                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
+        }
+
+        /*Clean-up and return*/
+        xDelete<int>(vector_ptr);
+        *pdataref=dataref;
+}
+/*}}}*/
 /*FUNCTION WriteData(mxArray** pdataref,RiftStruct* riftstruct){{{*/
 void WriteData(mxArray** pdataref,RiftStruct* riftstruct){
@@ -363 +432 @@
 }
 /*}}}*/
+/*FUNCTION SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int M,int N,int* fieldpointer){{{*/
+void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int M,int N,int* fieldpointer){
+
+        mxArray* field = NULL;
+
+        /*Convert field*/
+        WriteData(&field,fieldpointer,M,N);
+
+        /*Assign to structure*/
+        mxSetField(dataref,i,fieldname,field);
+}
+/*}}}*/
 /*FUNCTION SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int field){{{*/
 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int fieldin){

issm/trunk-jpl/src/wrappers/matlab/io/matlabio.h

@@ -17 +17 @@
 #include "../../c/include/include.h"
 
+void WriteData(mxArray** pdataref,SeqMat<int>* matrix);
 void WriteData(mxArray** pdataref,SeqMat<double>* matrix);
 void WriteData(mxArray** pdataref,double* matrix, int M,int N);
 void WriteData(mxArray** pdataref,int*    matrix, int M,int N);
+void WriteData(mxArray** pdataref,SeqVec<int>* vector);
 void WriteData(mxArray** pdataref,SeqVec<double>* vector);
 void WriteData(mxArray** pdataref,double* vector, int M);
@@ -64 +66 @@
 void SetStructureField(mxArray* dataref,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer);
 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer);
+void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int fieldrows,int fieldcols,int*    fieldpointer);
 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int field);
 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,double field);

issm/trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp

@@ -298 +298 @@
         else
                 vector=NULL;
+
+        /*output: */
+        if(pM)*pM=M;
+        if(pvector)*pvector=vector;
+}
+/*}}}*/
+/*FUNCTION FetchData(int** pvector,int* pM, PyObject* py_vector){{{*/
+void FetchData(int** pvector,int* pM,PyObject* py_vector){
+
+        /*output: */
+        int* vector=NULL;
+        int M;
+        int ndim;
+        npy_intp*  dims=NULL;
+
+        /*intermediary:*/
+        long*   lvector=NULL;
+        bool*   bvector=NULL;
+        double* dvector=NULL;
+        int i;
+
+        /*retrieve dimensions: */
+        ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
+        if(ndim!=1)_error_("expecting an Mx1 vector in input!");
+        dims=PyArray_DIMS((PyArrayObject*)py_vector);
+        M=dims[0]; 
+
+        if (M) {
+                if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
+                        /*retrieve internal value: */
+                        dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
+
+                        /*transform into int vector: */
+                        vector=xNew<int>(M);
+                        for(i=0;i<M;i++)vector[i]=(int)lvector[i];
+                }
+
+                else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
+                        /*retrieve internal value: */
+                        lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
+
+                        /*transform into int vector: */
+                        vector=xNew<int>(M);
+                        for(i=0;i<M;i++)vector[i]=(int)lvector[i];
+                }
+
+                else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
+                        /*retrieve internal value: */
+                        bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
+
+                        /*transform into int vector: */
+                        vector=xNew<int>(M);
+                        for(i=0;i<M;i++)vector[i]=(int)bvector[i];
+                }
+
+                else
+                 _error_("unrecognized vector type in input!");
+        }
+        else
+         vector=NULL;
 
         /*output: */

issm/trunk-jpl/src/wrappers/python/io/WritePythonData.cpp

@@ -162 +162 @@
 }
 /*}}}*/
+/*FUNCTION WriteData(PyObject* py_tuple,int index,SeqMat<int>* matrix){{{*/
+void WriteData(PyObject* py_tuple,int index,SeqMat<int>* matrix){
+
+        //FIXME: convert to double for now
+        
+        int M,N;
+        int* buffer=NULL;
+        npy_intp dims[2]={0,0};
+        PyObject* array=NULL;
+
+        matrix->GetSize(&M,&N);
+        buffer=matrix->ToSerial();
+
+        /*convert to double*/
+        double* bufferdouble=xNew<IssmDouble>(M*N);
+        for(int i=0;i<M*N;i++) bufferdouble[i]=(double)buffer[i];
+        xDelete<int>(buffer);
+
+        dims[0]=(npy_intp)M;
+        dims[1]=(npy_intp)N;
+        array=PyArray_SimpleNewFromData(2,dims,NPY_DOUBLE,bufferdouble);
+
+        PyTuple_SetItem(py_tuple, index, array);
+
+}/*}}}*/
+/*FUNCTION WriteData(PyObject* py_tuple,int index,SeqVec<int>* vector){{{*/
+void WriteData(PyObject* py_tuple,int index,SeqVec<int>* vector){
+
+        //FIXME: convert to double for now
+
+        int M;
+        int* buffer=NULL;
+        npy_intp dim=10;
+        PyObject* array=NULL;
+
+        vector->GetSize(&M);
+        buffer=vector->ToMPISerial();
+
+        /*convert to double*/
+        IssmDouble* bufferdouble=xNew<IssmDouble>(M);
+        for(int i=0;i<M;i++) bufferdouble[i]=(double)buffer[i];
+        xDelete<int>(buffer);
+
+        dim=(npy_intp)M;
+        array=PyArray_SimpleNewFromData(1,&dim,NPY_DOUBLE,bufferdouble);
+
+        PyTuple_SetItem(py_tuple, index, array);
+}
+/*}}}*/
 /*FUNCTION WriteData(PyObject* py_tuple,int index,RiftStruct* riftstruct){{{*/
 void WriteData(PyObject* py_tuple,int index,RiftStruct* riftstruct){
@@ -225 +274 @@
 }
 /*}}}*/
+/*FUNCTION PyArrayFromCopiedData(int dimi,int dimj,int* data){{{*/
+PyObject* PyArrayFromCopiedData(int dimi,int dimj,int* data){
+
+        //FIXME: convert to double for now
+
+        double* pydata;
+        npy_intp pydims[2]={0,0};
+
+        /*  note that PyArray_SimpleNewFromData does not copy the data, so that when the original
+                 object (e.g. bamggeom,bamgmesh) is deleted, the data is gone.  */
+
+        pydims[0]=(npy_intp)dimi;
+        pydims[1]=(npy_intp)dimj;
+        pydata=xNew<IssmDouble>(dimi*dimj);
+        //memcpy(pydata,data,dimi*dimj*sizeof(int));
+        for(int i=0;i<dimi*dimj;i++) pydata[i]=(double)data[i];
+        return PyArray_SimpleNewFromData(2,pydims,NPY_DOUBLE,pydata);
+}
+/*}}}*/

issm/trunk-jpl/src/wrappers/python/io/pythonio.h

@@ -25 +25 @@
 void WriteData(PyObject* py_tuple,int index, SeqMat<double>* matrix);
 void WriteData(PyObject* py_tuple,int index, SeqVec<double>* vector);
+void WriteData(PyObject* py_tuple,int index, SeqMat<int>* matrix);
+void WriteData(PyObject* py_tuple,int index, SeqVec<int>* vector);
 void WriteData(PyObject* py_tuple,int index, BamgGeom* bamggeom);
 void WriteData(PyObject* py_tuple,int index, BamgMesh* bamgmesh);
 void WriteData(PyObject* py_tuple,int index, RiftStruct* riftstruct);
 
+void FetchData(int** pvector,int* pM,PyObject* py_ref);
 void FetchData(double** pvector,int* pM,PyObject* py_ref);
 void FetchData(double** pmatrix,int* pM,int *pN,PyObject* py_array);
@@ -47 +50 @@
 PyObject* PyArrayFromCopiedData(int dims[2],double* data);
 PyObject* PyArrayFromCopiedData(int dimi,int dimj,double* data);
+PyObject* PyArrayFromCopiedData(int dimi,int dimj,int* data);
 
 #endif  /* _IO_H_ */