Ice Sheet System Model  4.18
Code documentation
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Functions
matlabio.h File Reference
#include "../include/matlabincludes.h"
#include "../../../c/bamg/bamgobjects.h"
#include "../../../c/classes/classes.h"
#include "../../../c/toolkits/toolkits.h"
#include "../../../c/shared/shared.h"

Go to the source code of this file.

Functions

void WriteData (mxArray **pdataref, IssmDenseMat< 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, IssmSeqVec< double > *vector)
 
void WriteData (mxArray **pdataref, double *vector, int M)
 
void WriteData (mxArray **pdataref, short *vector, int M)
 
void WriteData (mxArray **pdataref, int *vector, int M)
 
void WriteData (mxArray **pdataref, int integer)
 
void WriteData (mxArray **pdataref, bool boolean)
 
void WriteData (mxArray **pdataref, double scalar)
 
void WriteData (mxArray **pdataref, const char *string)
 
void WriteData (mxArray **pdataref)
 
void WriteData (mxArray **pdataref, BamgGeom *bamggeom)
 
void WriteData (mxArray **pdataref, BamgMesh *bamgmesh)
 
void WriteData (mxArray **pdataref, RiftStruct *riftstruct)
 
void WriteData (mxArray **pdataref, Contours *contours)
 
void FetchData (double **pmatrix, int *pM, int *pN, const mxArray *dataref)
 
void FetchData (int **pmatrix, int *pM, int *pN, const mxArray *dataref)
 
void FetchData (bool **pmatrix, int *pM, int *pN, const mxArray *dataref)
 
void FetchData (int **pvector, int *pM, const mxArray *dataref)
 
void FetchData (float **pvector, int *pM, const mxArray *dataref)
 
void FetchData (double **pvector, int *pM, const mxArray *dataref)
 
void FetchData (bool **pvector, int *pM, const mxArray *dataref)
 
void FetchData (char **pstring, const mxArray *dataref)
 
void FetchData (double *pscalar, const mxArray *dataref)
 
void FetchData (int *pinteger, const mxArray *dataref)
 
void FetchData (bool *pbool, const mxArray *dataref)
 
void FetchData (BamgGeom **bamggeom, const mxArray *dataref)
 
void FetchData (BamgMesh **bamgmesh, const mxArray *dataref)
 
void FetchData (BamgOpts **bamgopts, const mxArray *dataref)
 
void FetchData (Options **poptions, int istart, int nrhs, const mxArray **pdataref)
 
void FetchData (Contours **pcontours, const mxArray *dataref)
 
void FetchChacoData (int *pnvtxs, int **padjacency, int **pstart, float **pewgts, const mxArray *A_IN, const mxArray *EWGTS_IN)
 
Option * OptionParse (char *name, const mxArray *prhs[])
 
GenericOption< double > * OptionDoubleParse (char *name, const mxArray *prhs[])
 
GenericOption< double * > * OptionDoubleArrayParse (char *name, const mxArray *prhs[])
 
GenericOption< char * > * OptionCharParse (char *name, const mxArray *prhs[])
 
mxArray * mxGetAssignedField (const mxArray *pmxa_array, int number, const char *field)
 
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)
 
void SetStructureFieldi (mxArray *dataref, int i, const char *fieldname, const char *string)
 
int CheckNumMatlabArguments (int nlhs, int NLHS, int nrhs, int NRHS, const char *THISFUNCTION, void(*function)(void))
 
int MatlabMatrixToDoubleMatrix (double **pmatrix, int *pmatrix_rows, int *pmatrix_cols, const mxArray *mxmatrix)
 
void ApiPrintf (const char *string)
 

Function Documentation

◆ WriteData() [1/16]

void WriteData ( mxArray **  pdataref,
IssmDenseMat< double > *  matrix 
)

Definition at line 270 of file WriteMatlabData.cpp.

270  {
271 
272  int i,j;
273  int rows,cols;
274  mxArray *dataref = NULL;
275  double *matrix_ptr = NULL;
276  double *tmatrix_ptr = NULL;
277 
278  if(matrix){
279 
280  matrix_ptr=matrix->ToSerial();
281  matrix->GetSize(&rows,&cols);
282 
283  /*Now transpose the matrix and allocate with Matlab's memory manager: */
284  tmatrix_ptr=(double*)mxMalloc(rows*cols*sizeof(double));
285  for(i=0;i<rows;i++){
286  for(j=0;j<cols;j++){
287  tmatrix_ptr[j*rows+i]=matrix_ptr[i*cols+j];
288  }
289  }
290 
291  /*create matlab matrix: */
292  dataref=mxCreateDoubleMatrix(0,0,mxREAL);
293  mxSetM(dataref,rows);
294  mxSetN(dataref,cols);
295  mxSetPr(dataref,tmatrix_ptr);
296 
297  /*Free ressources:*/
298  xDelete<double>(matrix_ptr);
299  }
300  else{
301  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
302  }
303 
304  *pdataref=dataref;
305 }

◆ WriteData() [2/16]

void WriteData ( mxArray **  pdataref,
double *  matrix,
int  M,
int  N 
)

Definition at line 16 of file WriteMatlabData.cpp.

16  {
17 
18  mxArray *dataref = NULL;
19  double *tmatrix = NULL;
20 
21  if(matrix){
22  /*create the matlab matrixwith Matlab's memory manager */
23  tmatrix=(double*)mxMalloc(M*N*sizeof(double));
24  for(int i=0;i<M;i++){
25  for(int j=0;j<N;j++){
26  tmatrix[j*M+i]=matrix[i*N+j];
27  }
28  }
29  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
30  mxSetM(dataref,(mwSize)M);
31  mxSetN(dataref,(mwSize)N);
32  mxSetPr(dataref,(double*)tmatrix);
33  }
34  else{
35  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
36  }
37  *pdataref=dataref;
38 }

◆ WriteData() [3/16]

void WriteData ( mxArray **  pdataref,
int *  matrix,
int  M,
int  N 
)

Definition at line 41 of file WriteMatlabData.cpp.

41  {
42 
43  mxArray* dataref = NULL;
44  double* tmatrix = NULL;
45 
46  if(matrix){
47  /*convert to double matrix using Matlab's memory manager*/
48  double* tmatrix=(double*)mxMalloc(M*N*sizeof(double));
49  for(int i=0;i<M;i++){
50  for(int j=0;j<N;j++){
51  tmatrix[j*M+i]=(double)matrix[i*N+j];
52  }
53  }
54  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
55  mxSetM(dataref,(mwSize)M);
56  mxSetN(dataref,(mwSize)N);
57  mxSetPr(dataref,(double*)tmatrix);
58  }
59  else{
60  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
61  }
62  *pdataref=dataref;
63 }

◆ WriteData() [4/16]

void WriteData ( mxArray **  pdataref,
IssmSeqVec< double > *  vector 
)

Definition at line 308 of file WriteMatlabData.cpp.

308  {
309 
310  mxArray* dataref=NULL;
311  double* vector_ptr=NULL;
312  double* vector_matlab=NULL;
313  int rows;
314 
315  if(vector){
316  /*call toolkit routine: */
317  vector_ptr=vector->ToMPISerial();
318  vector->GetSize(&rows);
319 
320  /*now create the matlab vector with Matlab's memory manager */
321  vector_matlab=(double*)mxMalloc(rows*sizeof(double));
322  for(int i=0;i<rows;i++) vector_matlab[i]=vector_ptr[i];
323 
324  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
325  mxSetM(dataref,rows);
326  mxSetN(dataref,1);
327  mxSetPr(dataref,vector_matlab);
328  }
329  else{
330  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
331  }
332 
333  /*Clean-up and return*/
334  xDelete<double>(vector_ptr);
335  *pdataref=dataref;
336 }

◆ WriteData() [5/16]

void WriteData ( mxArray **  pdataref,
double *  vector,
int  M 
)

Definition at line 66 of file WriteMatlabData.cpp.

66  {
67 
68  mxArray* dataref = NULL;
69  double* vector_matlab = NULL;
70 
71  if(vector){
72 
73  /*create the matlab vector with Matlab's memory manager */
74  vector_matlab=(double*)mxMalloc(M*sizeof(double));
75  for(int i=0;i<M;i++) vector_matlab[i]=vector[i];
76  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
77  mxSetM(dataref,(mwSize)M);
78  mxSetN(dataref,(mwSize)1);
79  mxSetPr(dataref,vector_matlab);
80  }
81  else{
82  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
83  }
84 
85  *pdataref=dataref;
86 }

◆ WriteData() [6/16]

void WriteData ( mxArray **  pdataref,
short *  vector,
int  M 
)

Definition at line 112 of file WriteMatlabData.cpp.

112  {
113 
114  mxArray* dataref = NULL;
115  double* vector_matlab = NULL;
116 
117  if(vector){
118 
119  /*create the matlab vector with Matlab's memory manager */
120  vector_matlab=(double*)mxMalloc(M*sizeof(double));
121  for(int i=0;i<M;i++) vector_matlab[i]=double(vector[i]);
122  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
123  mxSetM(dataref,(mwSize)M);
124  mxSetN(dataref,(mwSize)1);
125  mxSetPr(dataref,vector_matlab);
126  }
127  else{
128  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
129  }
130 
131  *pdataref=dataref;
132 }

◆ WriteData() [7/16]

void WriteData ( mxArray **  pdataref,
int *  vector,
int  M 
)

Definition at line 89 of file WriteMatlabData.cpp.

89  {
90 
91  mxArray* dataref = NULL;
92  double* vector_matlab = NULL;
93 
94  if(vector){
95 
96  /*create the matlab vector with Matlab's memory manager */
97  vector_matlab=(double*)mxMalloc(M*sizeof(double));
98  for(int i=0;i<M;i++) vector_matlab[i]=double(vector[i]);
99  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
100  mxSetM(dataref,(mwSize)M);
101  mxSetN(dataref,(mwSize)1);
102  mxSetPr(dataref,vector_matlab);
103  }
104  else{
105  dataref = mxCreateDoubleMatrix(0,0,mxREAL);
106  }
107 
108  *pdataref=dataref;
109 }

◆ WriteData() [8/16]

void WriteData ( mxArray **  pdataref,
int  integer 
)

Definition at line 141 of file WriteMatlabData.cpp.

141  {
142 
143  *pdataref=mxCreateDoubleScalar((double)integer);
144 
145 }

◆ WriteData() [9/16]

void WriteData ( mxArray **  pdataref,
bool  boolean 
)

Definition at line 148 of file WriteMatlabData.cpp.

148  {
149 
150  *pdataref=mxCreateDoubleScalar((double)boolean);
151 
152 }

◆ WriteData() [10/16]

void WriteData ( mxArray **  pdataref,
double  scalar 
)

Definition at line 135 of file WriteMatlabData.cpp.

135  {
136 
137  *pdataref=mxCreateDoubleScalar(scalar);
138 }

◆ WriteData() [11/16]

void WriteData ( mxArray **  pdataref,
const char *  string 
)

Definition at line 155 of file WriteMatlabData.cpp.

155  {
156 
157  *pdataref=mxCreateString(string);
158 }

◆ WriteData() [12/16]

void WriteData ( mxArray **  pdataref)

Definition at line 161 of file WriteMatlabData.cpp.

161  {
162 
163  ;
164 
165 }

◆ WriteData() [13/16]

void WriteData ( mxArray **  pdataref,
BamgGeom *  bamggeom 
)

Definition at line 170 of file WriteMatlabData.cpp.

170  {
171 
172  /*Intermediary*/
173  int i;
174  mxArray *dataref = NULL;
175  const int numfields = 8;
176  const char *fnames[numfields];
177  mwSize ndim = 2;
178  mwSize dimensions[2] = {1,1};
179 
180  /*Initialize field names*/
181  i=0;
182  fnames[i++] = "Vertices";
183  fnames[i++] = "Edges";
184  fnames[i++] = "TangentAtEdges";
185  fnames[i++] = "Corners";
186  fnames[i++] = "RequiredVertices";
187  fnames[i++] = "RequiredEdges";
188  fnames[i++] = "CrackedEdges";
189  fnames[i++] = "SubDomains";
190  _assert_(i==numfields);
191 
192  /*Initialize Matlab structure*/
193  dataref=mxCreateStructArray(ndim,dimensions,numfields,fnames);
194 
195  /*set each matlab each field*/
196  i=0;
197  i++; SetStructureField(dataref,"Vertices", bamggeom->VerticesSize[0], bamggeom->VerticesSize[1], bamggeom->Vertices);
198  i++; SetStructureField(dataref,"Edges", bamggeom->EdgesSize[0], bamggeom->EdgesSize[1], bamggeom->Edges);
199  i++; SetStructureField(dataref,"TangentAtEdges", bamggeom->TangentAtEdgesSize[0], bamggeom->TangentAtEdgesSize[1], bamggeom->TangentAtEdges);
200  i++; SetStructureField(dataref,"Corners", bamggeom->CornersSize[0], bamggeom->CornersSize[1], bamggeom->Corners);
201  i++; SetStructureField(dataref,"RequiredVertices",bamggeom->RequiredVerticesSize[0],bamggeom->RequiredVerticesSize[1],bamggeom->RequiredVertices);
202  i++; SetStructureField(dataref,"RequiredEdges", bamggeom->RequiredEdgesSize[0], bamggeom->RequiredEdgesSize[1], bamggeom->RequiredEdges);
203  i++; SetStructureField(dataref,"CrackedEdges", bamggeom->CrackedEdgesSize[0], bamggeom->CrackedEdgesSize[1], bamggeom->CrackedEdges);
204  i++; SetStructureField(dataref,"SubDomains", bamggeom->SubDomainsSize[0], bamggeom->SubDomainsSize[1], bamggeom->SubDomains);
205  _assert_(i==numfields);
206 
207  /*Assign output*/
208  *pdataref=dataref;
209 }

◆ WriteData() [14/16]

void WriteData ( mxArray **  pdataref,
BamgMesh *  bamgmesh 
)

Definition at line 212 of file WriteMatlabData.cpp.

212  {
213 
214  /*Intermediary*/
215  int i;
216  mxArray *dataref = NULL;
217  const int numfields = 16;
218  const char *fnames[numfields];
219  mwSize ndim = 2;
220  mwSize dimensions[2] = {1,1};
221 
222  /*Initialize field names*/
223  i=0;
224  fnames[i++] = "Vertices";
225  fnames[i++] = "Edges";
226  fnames[i++] = "Triangles";
227  fnames[i++] = "IssmEdges";
228  fnames[i++] = "IssmSegments";
229  fnames[i++] = "VerticesOnGeomVertex";
230  fnames[i++] = "VerticesOnGeomEdge";
231  fnames[i++] = "EdgesOnGeomEdge";
232  fnames[i++] = "SubDomains";
233  fnames[i++] = "SubDomainsFromGeom";
234  fnames[i++] = "ElementConnectivity";
235  fnames[i++] = "NodalConnectivity";
236  fnames[i++] = "NodalElementConnectivity";
237  fnames[i++] = "CrackedVertices";
238  fnames[i++] = "CrackedEdges";
239  fnames[i++] = "PreviousNumbering";
240  _assert_(i==numfields);
241 
242  /*Initialize Matlab structure*/
243  dataref=mxCreateStructArray(ndim,dimensions,numfields,fnames);
244 
245  /*set each matlab each field*/
246  i=0;
247  i++; SetStructureField(dataref,"Vertices",bamgmesh->VerticesSize[0], bamgmesh->VerticesSize[1],bamgmesh->Vertices);
248  i++; SetStructureField(dataref,"Edges", bamgmesh->EdgesSize[0],bamgmesh->EdgesSize[1], bamgmesh->Edges);
249  i++; SetStructureField(dataref,"Triangles", bamgmesh->TrianglesSize[0],bamgmesh->TrianglesSize[1], bamgmesh->Triangles);
250  i++; SetStructureField(dataref,"IssmEdges", bamgmesh->IssmEdgesSize[0],bamgmesh->IssmEdgesSize[1], bamgmesh->IssmEdges);
251  i++; SetStructureField(dataref,"IssmSegments",bamgmesh->IssmSegmentsSize[0], bamgmesh->IssmSegmentsSize[1],bamgmesh->IssmSegments);
252  i++; SetStructureField(dataref,"VerticesOnGeomVertex",bamgmesh->VerticesOnGeomVertexSize[0],bamgmesh->VerticesOnGeomVertexSize[1], bamgmesh->VerticesOnGeomVertex);
253  i++; SetStructureField(dataref,"VerticesOnGeomEdge",bamgmesh->VerticesOnGeomEdgeSize[0],bamgmesh->VerticesOnGeomEdgeSize[1], bamgmesh->VerticesOnGeomEdge);
254  i++; SetStructureField(dataref,"EdgesOnGeomEdge", bamgmesh->EdgesOnGeomEdgeSize[0], bamgmesh->EdgesOnGeomEdgeSize[1],bamgmesh->EdgesOnGeomEdge);
255  i++; SetStructureField(dataref,"SubDomains",bamgmesh->SubDomainsSize[0], bamgmesh->SubDomainsSize[1],bamgmesh->SubDomains);
256  i++; SetStructureField(dataref,"SubDomainsFromGeom", bamgmesh->SubDomainsFromGeomSize[0], bamgmesh->SubDomainsFromGeomSize[1],bamgmesh->SubDomainsFromGeom);
257  i++; SetStructureField(dataref,"ElementConnectivity",bamgmesh->ElementConnectivitySize[0],bamgmesh->ElementConnectivitySize[1], bamgmesh->ElementConnectivity);
258  i++; SetStructureField(dataref,"NodalConnectivity",bamgmesh->NodalConnectivitySize[0],bamgmesh->NodalConnectivitySize[1], bamgmesh->NodalConnectivity);
259  i++; SetStructureField(dataref,"NodalElementConnectivity", bamgmesh->NodalElementConnectivitySize[0], bamgmesh->NodalElementConnectivitySize[1],bamgmesh->NodalElementConnectivity);
260  i++; SetStructureField(dataref,"CrackedVertices", bamgmesh->CrackedVerticesSize[0],bamgmesh->CrackedVerticesSize[1], bamgmesh->CrackedVertices);
261  i++; SetStructureField(dataref,"CrackedEdges",bamgmesh->CrackedEdgesSize[0], bamgmesh->CrackedEdgesSize[1],bamgmesh->CrackedEdges);
262  i++; SetStructureField(dataref,"PreviousNumbering",bamgmesh->VerticesSize[0],1,bamgmesh->PreviousNumbering);
263  _assert_(i==numfields);
264 
265  /*Assign output*/
266  *pdataref=dataref;
267 }

◆ WriteData() [15/16]

void WriteData ( mxArray **  pdataref,
RiftStruct *  riftstruct 
)

Definition at line 339 of file WriteMatlabData.cpp.

339  {
340 
341  /*Intermediary*/
342  int i;
343  mxArray *dataref = NULL;
344  const int numfields = 10;
345  const char *fnames[numfields];
346  mwSize ndim = 2;
347  mwSize dimensions[2] = {1,1};
348 
349  /*Initialize field names*/
350  i=0;
351  fnames[i++] = "numsegs";
352  fnames[i++] = "segments";
353  fnames[i++] = "pairs";
354  fnames[i++] = "tips";
355  fnames[i++] = "penaltypairs";
356  fnames[i++] = "fill";
357  fnames[i++] = "friction";
358  fnames[i++] = "fraction";
359  fnames[i++] = "fractionincrement";
360  fnames[i++] = "state";
361  _assert_(i==numfields);
362 
363  /*Initialize matlab structure of dimension numrifts*/
364  dimensions[0]=riftstruct->numrifts;
365  dataref=mxCreateStructArray(ndim,dimensions,numfields,fnames);
366 
367  /*set each matlab each field*/
368  for(int i=0;i<riftstruct->numrifts;i++){
369  SetStructureFieldi(dataref,i,"numsegs" ,riftstruct->riftsnumsegments[i]);
370  SetStructureFieldi(dataref,i,"segments" ,riftstruct->riftsnumsegments[i] ,3,riftstruct->riftssegments[i]);
371  SetStructureFieldi(dataref,i,"pairs" ,riftstruct->riftsnumpairs[i] ,2,riftstruct->riftspairs[i]);
372  SetStructureFieldi(dataref,i,"tips" ,1 ,2,&riftstruct->riftstips[2*i]);
373  SetStructureFieldi(dataref,i,"penaltypairs" ,riftstruct->riftsnumpenaltypairs[i],7,riftstruct->riftspenaltypairs[i]);
374  SetStructureFieldi(dataref,i,"fill" ,"Ice");
375  SetStructureFieldi(dataref,i,"friction" ,0);
376  SetStructureFieldi(dataref,i,"fraction" ,0.);
377  SetStructureFieldi(dataref,i,"fractionincrement",0.1);
378  SetStructureFieldi(dataref,i,"state" ,riftstruct->riftsnumpenaltypairs[i],1,riftstruct->state[i]);
379  }
380 
381  /*Assign output*/
382  *pdataref=dataref;
383 }

◆ WriteData() [16/16]

void WriteData ( mxArray **  pdataref,
Contours *  contours 
)

Definition at line 386 of file WriteMatlabData.cpp.

386  {
387 
388  /*Intermediary*/
389 
390  int i;
391  mxArray *dataref = NULL;
392  const int numfields = 6;
393  const char *fnames[numfields];
394  mwSize ndim = 2;
395  mwSize dimensions[2] = {1,1};
396  char id[100];
397 
398  /*Initialize field names*/
399  i=0;
400  fnames[i++] = "name";
401  fnames[i++] = "nods";
402  fnames[i++] = "density";
403  fnames[i++] = "x";
404  fnames[i++] = "y";
405  fnames[i++] = "closed";
406  _assert_(i==numfields);
407 
408  /*Initialize matlab structure of dimension numrifts*/
409  dimensions[0]=contours->Size();
410  dataref=mxCreateStructArray(ndim,dimensions,numfields,fnames);
411 
412  /*set each matlab each field*/
413  for(int i=0;i<contours->Size();i++){
414  Contour<IssmPDouble>* contour=(Contour<IssmPDouble>*)contours->GetObjectByOffset(i);
415 
416  /*create a name for this contour from the contour id and set it: */
417  sprintf(id,"%i",contour->id);
418  SetStructureFieldi(dataref,i,"name",id);
419 
420  /*number of nods: */
421  SetStructureFieldi(dataref,i,"nods" ,contour->nods);
422 
423  /*density: */
424  SetStructureFieldi(dataref,i,"density" ,1);
425 
426  /*x and y: */
427  SetStructureFieldi(dataref,i,"x" ,contour->nods, 1,contour->x);
428  SetStructureFieldi(dataref,i,"y" ,contour->nods, 1,contour->y);
429 
430  /*closed: */
431  SetStructureFieldi(dataref,i,"closed" ,(int)contour->closed);
432  }
433 
434  /*Assign output*/
435  *pdataref=dataref;
436 }

◆ FetchData() [1/16]

void FetchData ( double **  pmatrix,
int *  pM,
int *  pN,
const mxArray *  dataref 
)

Definition at line 15 of file FetchMatlabData.cpp.

15  {/*{{{*/
16 
17  double* outmatrix=NULL;
18  int outmatrix_rows,outmatrix_cols;
19 
20  if(mxIsEmpty(dataref) ){
21  /*Nothing to pick up. Just initialize matrix pointer to NULL: */
22  outmatrix_rows=0;
23  outmatrix_cols=0;
24  outmatrix=NULL;
25  }
26  else if( mxIsClass(dataref,"double") ||
27  mxIsClass(dataref,"single") ||
28  mxIsClass(dataref,"int16") ||
29  mxIsClass(dataref,"int8") ||
30  mxIsClass(dataref,"uint8")){
31  /*Check dataref is not pointing to NaN: */
32  if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){
33  outmatrix_rows=0;
34  outmatrix_cols=0;
35  outmatrix=NULL;
36  }
37  else{
38  if(!mxIsClass(dataref,"double") && !mxIsClass(dataref,"single")){
39  _printf_("Warning: converting matlab data from '" << mxGetClassName(dataref) << "' to 'double'\n");
40  }
41  /*Convert matlab matrix to double* matrix: */
42  MatlabMatrixToDoubleMatrix(&outmatrix,&outmatrix_rows,&outmatrix_cols,dataref);
43  }
44  }
45  else{
46  /*This is an error: we don't have the correct input!: */
47  _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
48  }
49 
50  /*Assign output pointers:*/
51  *pmatrix=outmatrix;
52  if (pM)*pM=outmatrix_rows;
53  if (pN)*pN=outmatrix_cols;
54 
55 }

◆ FetchData() [2/16]

void FetchData ( int **  pmatrix,
int *  pM,
int *  pN,
const mxArray *  dataref 
)

Definition at line 57 of file FetchMatlabData.cpp.

57  {/*{{{*/
58 
59  int i,outmatrix_rows,outmatrix_cols;
60  double *doublematrix=NULL;
61  int *outmatrix=NULL;
62 
63  if(mxIsEmpty(dataref) ){
64  /*Nothing to pick up. Just initialize matrix pointer to NULL: */
65  outmatrix_rows=0;
66  outmatrix_cols=0;
67  outmatrix=NULL;
68  }
69  else if( mxIsClass(dataref,"double") ||
70  mxIsClass(dataref,"single") ||
71  mxIsClass(dataref,"int16") ||
72  mxIsClass(dataref,"int8") ||
73  mxIsClass(dataref,"uint8")){
74 
75  /*Check dataref is not pointing to NaN: */
76  if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){
77  outmatrix_rows=0;
78  outmatrix_cols=0;
79  outmatrix=NULL;
80  }
81  else{
82  if(!mxIsClass(dataref,"double") && !mxIsClass(dataref,"single")){
83  _printf_("Warning: converting matlab data from '" << mxGetClassName(dataref) << "' to 'double'\n");
84  }
85  /*Convert matlab matrix to double* matrix: */
86  MatlabMatrixToDoubleMatrix(&doublematrix,&outmatrix_rows,&outmatrix_cols,dataref);
87 
88  /*Convert double matrix into integer matrix: */
89  outmatrix=xNew<int>(outmatrix_rows*outmatrix_cols);
90  for(i=0;i<outmatrix_rows*outmatrix_cols;i++)outmatrix[i]=(int)doublematrix[i];
91  }
92  }
93  else{
94  /*This is an error: we don't have the correct input!: */
95  _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
96  }
97 
98  /*Assign output pointers:*/
99  *pmatrix=outmatrix;
100  if (pM)*pM=outmatrix_rows;
101  if (pN)*pN=outmatrix_cols;
102 }

◆ FetchData() [3/16]

void FetchData ( bool **  pmatrix,
int *  pM,
int *  pN,
const mxArray *  dataref 
)

Definition at line 104 of file FetchMatlabData.cpp.

104  {/*{{{*/
105 
106  int i,outmatrix_rows,outmatrix_cols;
107  double *doublematrix=NULL;
108  bool *outmatrix=NULL;
109 
110  if(mxIsEmpty(dataref) ){
111  /*Nothing to pick up. Just initialize matrix pointer to NULL: */
112  outmatrix_rows=0;
113  outmatrix_cols=0;
114  outmatrix=NULL;
115  }
116  else if (mxIsClass(dataref,"double") ){
117 
118  /*Check dataref is not pointing to NaN: */
119  if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){
120  outmatrix_rows=0;
121  outmatrix_cols=0;
122  outmatrix=NULL;
123  }
124  else{
125 
126  /*Convert matlab matrix to double* matrix: */
127  MatlabMatrixToDoubleMatrix(&doublematrix,&outmatrix_rows,&outmatrix_cols,dataref);
128 
129  /*Convert double matrix into integer matrix: */
130  outmatrix=xNew<bool>(outmatrix_rows*outmatrix_cols);
131  for(i=0;i<outmatrix_rows;i++)outmatrix[i]=(bool)doublematrix[i];
132  }
133  }
134  else{
135  /*This is an error: we don't have the correct input!: */
136  _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
137  }
138 
139  /*Assign output pointers:*/
140  *pmatrix=outmatrix;
141  if (pM)*pM=outmatrix_rows;
142  if (pN)*pN=outmatrix_cols;
143 }

◆ FetchData() [4/16]

void FetchData ( int **  pvector,
int *  pM,
const mxArray *  dataref 
)

Definition at line 166 of file FetchMatlabData.cpp.

166  {/*{{{*/
167 
168  int i;
169  double *doublevector = NULL;
170  int *outvector = NULL;
171  int outvector_rows;
172 
173  if(mxIsEmpty(dataref)){
174  /*Nothing to pick up. Just initialize matrix pointer to NULL: */
175  outvector_rows=0;
176  outvector=NULL;
177  }
178  else if (mxIsClass(dataref,"double") ){
179 
180  /*Convert matlab vector to double* vector: */
181  FetchData(&doublevector,&outvector_rows,dataref);
182 
183  /*Convert double vector into integer vector: */
184  outvector=xNew<int>(outvector_rows);
185  for(i=0;i<outvector_rows;i++)outvector[i]=(int)doublevector[i];
186  }
187  else{
188  /*This is an error: we don't have the correct input!: */
189  _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
190  }
191 
192  /*Assign output pointers:*/
193  *pvector=outvector;
194  if (pM)*pM=outvector_rows;
195 }

◆ FetchData() [5/16]

void FetchData ( float **  pvector,
int *  pM,
const mxArray *  dataref 
)

Definition at line 228 of file FetchMatlabData.cpp.

228  {/*{{{*/
229 
230  int i;
231  double *doublevector = NULL;
232  float *outvector = NULL;
233  int outvector_rows;
234 
235  if(mxIsEmpty(dataref)){
236  /*Nothing to pick up. Just initialize matrix pointer to NULL: */
237  outvector_rows=0;
238  outvector=NULL;
239  }
240  else if (mxIsClass(dataref,"double") ){
241 
242  /*Convert matlab vector to double* vector: */
243  FetchData(&doublevector,&outvector_rows,dataref);
244 
245  /*Convert double vector into float vector: */
246  outvector=xNew<float>(outvector_rows);
247  for(i=0;i<outvector_rows;i++)outvector[i]=(float)doublevector[i];
248  }
249  else{
250  /*This is an error: we don't have the correct input!: */
251  _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
252  }
253 
254  /*Assign output pointers:*/
255  *pvector=outvector;
256  if (pM)*pM=outvector_rows;
257 }

◆ FetchData() [6/16]

void FetchData ( double **  pvector,
int *  pM,
const mxArray *  dataref 
)

Definition at line 145 of file FetchMatlabData.cpp.

145  {/*{{{*/
146 
147  double* outvector=NULL;
148  int M,N;
149 
150  /*Use Fetch matrix*/
151  FetchData(&outvector,&M,&N,dataref) ;
152 
153  /*Check that it is a vector*/
154  if(M*N>0 && (M!=1 && N!=1)){
155  _error_("input vector of size " << M << "x" << N << " should have only one column");
156  }
157 
158  /*Transpose Row vectors*/
159  if(M==1 && N>1) M=N;
160 
161  /*Assign output pointers:*/
162  *pvector=outvector;
163  if(pM)*pM=M;
164 }

◆ FetchData() [7/16]

void FetchData ( bool **  pvector,
int *  pM,
const mxArray *  dataref 
)

Definition at line 197 of file FetchMatlabData.cpp.

197  {/*{{{*/
198 
199  int i;
200  double *doublevector = NULL;
201  bool *outvector = NULL;
202  int outvector_rows;
203 
204  if(mxIsEmpty(dataref)){
205  /*Nothing to pick up. Just initialize matrix pointer to NULL: */
206  outvector_rows=0;
207  outvector=NULL;
208  }
209  else if (mxIsClass(dataref,"double") ){
210 
211  /*Convert matlab vector to double* vector: */
212  FetchData(&doublevector,&outvector_rows,dataref);
213 
214  /*Convert double vector into integer vector: */
215  outvector=xNew<bool>(outvector_rows);
216  for(i=0;i<outvector_rows;i++)outvector[i]=(bool)doublevector[i];
217  }
218  else{
219  /*This is an error: we don't have the correct input!: */
220  _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
221  }
222 
223  /*Assign output pointers:*/
224  *pvector=outvector;
225  if (pM)*pM=outvector_rows;
226 }

◆ FetchData() [8/16]

void FetchData ( char **  pstring,
const mxArray *  dataref 
)

Definition at line 259 of file FetchMatlabData.cpp.

259  {/*{{{*/
260 
261  char* outstring=NULL;
262 
263  /*Ok, the string should be coming directly from the matlab workspace: */
264  if (!mxIsClass(dataref,"char")){
265  _error_("input data_type is not a string!");
266  }
267  else{
268  /*Recover the string:*/
269  int stringlen;
270 
271  stringlen = mxGetM(dataref)*mxGetN(dataref)+1;
272  outstring =xNew<char>(stringlen);
273  mxGetString(dataref,outstring,stringlen);
274  }
275 
276  /*Assign output pointers:*/
277  *pstring=outstring;
278 }/*}}}*/

◆ FetchData() [9/16]

void FetchData ( double *  pscalar,
const mxArray *  dataref 
)

Definition at line 279 of file FetchMatlabData.cpp.

279  {/*{{{*/
280 
281  double scalar;
282 
283  if (!mxIsClass(dataref,"double")){
284  _error_("input data_type is not a double!");
285  }
286  else{
287  /*Recover the double: */
288  scalar=mxGetScalar(dataref);
289  }
290 
291  /*Assign output pointers:*/
292  *pscalar=scalar;
293 }

◆ FetchData() [10/16]

void FetchData ( int *  pinteger,
const mxArray *  dataref 
)

Definition at line 295 of file FetchMatlabData.cpp.

295  {/*{{{*/
296 
297  int integer;
298 
299  if (!mxIsClass(dataref,"double")){
300  _error_("input data_type is not a scalar!");
301  }
302  else{
303  /*Recover the double: */
304  integer=(int)mxGetScalar(dataref);
305  }
306 
307  /*Assign output pointers:*/
308  *pinteger=integer;
309 }

◆ FetchData() [11/16]

void FetchData ( bool *  pbool,
const mxArray *  dataref 
)

Definition at line 311 of file FetchMatlabData.cpp.

311  {/*{{{*/
312 
313  bool* mxbool_ptr=NULL;
314 
315  if (mxIsClass(dataref,"logical")){
316  if(mxGetM(dataref)!=1) _error_("input data is not of size 1x1");
317  if(mxGetN(dataref)!=1) _error_("input data is not of size 1x1");
318  mxbool_ptr=mxGetLogicals(dataref);
319  }
320  else{
321  _error_("input data_type is not a bool!");
322  }
323 
324  *pboolean=*mxbool_ptr;
325 }

◆ FetchData() [12/16]

void FetchData ( BamgGeom **  bamggeom,
const mxArray *  dataref 
)

Definition at line 329 of file FetchMatlabData.cpp.

329  {/*{{{*/
330 
331  /*Initialize output*/
332  BamgGeom* bamggeom=new BamgGeom();
333 
334  /*Fetch all fields*/
335  FetchData(&bamggeom->Vertices,&bamggeom->VerticesSize[0],&bamggeom->VerticesSize[1],mxGetAssignedField(dataref,0,"Vertices"));
336  FetchData(&bamggeom->Edges, &bamggeom->EdgesSize[0], &bamggeom->EdgesSize[1], mxGetAssignedField(dataref,0,"Edges"));
337  FetchData(&bamggeom->Corners, &bamggeom->CornersSize[0], &bamggeom->CornersSize[1], mxGetAssignedField(dataref,0,"Corners"));
338  FetchData(&bamggeom->RequiredVertices,&bamggeom->RequiredVerticesSize[0],&bamggeom->RequiredVerticesSize[1],mxGetAssignedField(dataref,0,"RequiredVertices"));
339  FetchData(&bamggeom->RequiredEdges, &bamggeom->RequiredEdgesSize[0], &bamggeom->RequiredEdgesSize[1], mxGetAssignedField(dataref,0,"RequiredEdges"));
340  FetchData(&bamggeom->CrackedEdges,&bamggeom->CrackedEdgesSize[0],&bamggeom->CrackedEdgesSize[1],mxGetAssignedField(dataref,0,"CrackedEdges"));
341  FetchData(&bamggeom->SubDomains,&bamggeom->SubDomainsSize[0],&bamggeom->SubDomainsSize[1],mxGetAssignedField(dataref,0,"SubDomains"));
342 
343  /*Assign output pointers:*/
344  *pbamggeom=bamggeom;
345 }

◆ FetchData() [13/16]

void FetchData ( BamgMesh **  bamgmesh,
const mxArray *  dataref 
)

Definition at line 347 of file FetchMatlabData.cpp.

347  {/*{{{*/
348 
349  /*Initialize output*/
350  BamgMesh* bamgmesh=new BamgMesh();
351 
352  /*Fetch all fields*/
353  FetchData(&bamgmesh->Vertices,&bamgmesh->VerticesSize[0],&bamgmesh->VerticesSize[1],mxGetAssignedField(dataref,0,"Vertices"));
354  FetchData(&bamgmesh->Edges, &bamgmesh->EdgesSize[0], &bamgmesh->EdgesSize[1], mxGetAssignedField(dataref,0,"Edges"));
355  FetchData(&bamgmesh->Triangles, &bamgmesh->TrianglesSize[0], &bamgmesh->TrianglesSize[1], mxGetAssignedField(dataref,0,"Triangles"));
356  FetchData(&bamgmesh->CrackedEdges,&bamgmesh->CrackedEdgesSize[0],&bamgmesh->CrackedEdgesSize[1],mxGetAssignedField(dataref,0,"CrackedEdges"));
357  FetchData(&bamgmesh->VerticesOnGeomEdge,&bamgmesh->VerticesOnGeomEdgeSize[0],&bamgmesh->VerticesOnGeomEdgeSize[1],mxGetAssignedField(dataref,0,"VerticesOnGeomEdge"));
358  FetchData(&bamgmesh->VerticesOnGeomVertex,&bamgmesh->VerticesOnGeomVertexSize[0],&bamgmesh->VerticesOnGeomVertexSize[1],mxGetAssignedField(dataref,0,"VerticesOnGeomVertex"));
359  FetchData(&bamgmesh->EdgesOnGeomEdge, &bamgmesh->EdgesOnGeomEdgeSize[0], &bamgmesh->EdgesOnGeomEdgeSize[1], mxGetAssignedField(dataref,0,"EdgesOnGeomEdge"));
360  FetchData(&bamgmesh->IssmSegments,&bamgmesh->IssmSegmentsSize[0],&bamgmesh->IssmSegmentsSize[1],mxGetAssignedField(dataref,0,"IssmSegments"));
361 
362  /*Assign output pointers:*/
363  *pbamgmesh=bamgmesh;
364 }

◆ FetchData() [14/16]

void FetchData ( BamgOpts **  bamgopts,
const mxArray *  dataref 
)

Definition at line 366 of file FetchMatlabData.cpp.

366  {/*{{{*/
367 
368  /*Initialize output*/
369  BamgOpts* bamgopts=new BamgOpts();
370 
371  /*Fetch all fields*/
372  FetchData(&bamgopts->anisomax,mxGetField(dataref,0,"anisomax"));
373  FetchData(&bamgopts->cutoff,mxGetField(dataref,0,"cutoff"));
374  FetchData(&bamgopts->coeff,mxGetField(dataref,0,"coeff"));
375  FetchData(&bamgopts->errg,mxGetField(dataref,0,"errg"));
376  FetchData(&bamgopts->gradation,mxGetField(dataref,0,"gradation"));
377  FetchData(&bamgopts->Hessiantype,mxGetField(dataref,0,"Hessiantype"));
378  FetchData(&bamgopts->maxnbv,mxGetField(dataref,0,"maxnbv"));
379  FetchData(&bamgopts->maxsubdiv,mxGetField(dataref,0,"maxsubdiv"));
380  FetchData(&bamgopts->Metrictype,mxGetField(dataref,0,"Metrictype"));
381  FetchData(&bamgopts->nbjacobi,mxGetField(dataref,0,"nbjacobi"));
382  FetchData(&bamgopts->nbsmooth,mxGetField(dataref,0,"nbsmooth"));
383  FetchData(&bamgopts->omega,mxGetField(dataref,0,"omega"));
384  FetchData(&bamgopts->power,mxGetField(dataref,0,"power"));
385  FetchData(&bamgopts->verbose,mxGetField(dataref,0,"verbose"));
386 
387  FetchData(&bamgopts->Crack,mxGetField(dataref,0,"Crack"));
388  FetchData(&bamgopts->KeepVertices,mxGetField(dataref,0,"KeepVertices"));
389  FetchData(&bamgopts->splitcorners,mxGetField(dataref,0,"splitcorners"));
390 
391  FetchData(&bamgopts->hmin,mxGetField(dataref,0,"hmin"));
392  FetchData(&bamgopts->hmax,mxGetField(dataref,0,"hmax"));
393  FetchData(&bamgopts->hminVertices,&bamgopts->hminVerticesSize[0],&bamgopts->hminVerticesSize[1],mxGetField(dataref,0,"hminVertices"));
394  FetchData(&bamgopts->hmaxVertices,&bamgopts->hmaxVerticesSize[0],&bamgopts->hmaxVerticesSize[1],mxGetField(dataref,0,"hmaxVertices"));
395  FetchData(&bamgopts->hVertices,&bamgopts->hVerticesLength,mxGetField(dataref,0,"hVertices"));
396  FetchData(&bamgopts->metric,&bamgopts->metricSize[0],&bamgopts->metricSize[1],mxGetField(dataref,0,"metric"));
397  FetchData(&bamgopts->field,&bamgopts->fieldSize[0],&bamgopts->fieldSize[1],mxGetField(dataref,0,"field"));
398  FetchData(&bamgopts->err,&bamgopts->errSize[0],&bamgopts->errSize[1],mxGetField(dataref,0,"err"));
399 
400  /*Additional checks*/
401  bamgopts->Check();
402 
403  /*Assign output pointers:*/
404  *pbamgopts=bamgopts;
405 }

◆ FetchData() [15/16]

void FetchData ( Options **  poptions,
int  istart,
int  nrhs,
const mxArray **  pdataref 
)

Definition at line 407 of file FetchMatlabData.cpp.

407  {/*{{{*/
408 
409  char *name = NULL;
410  Option *option = NULL;
411 
412  /*Initialize output*/
413  Options* options=new Options();
414 
415  /*Fetch all options*/
416  for (int i=istart; i<nrhs; i=i+2){
417  if (!mxIsClass(pdataref[i],"char")) _error_("Argument " << i+1 << " must be name of option");
418 
419  FetchData(&name,pdataref[i]);
420  if(i+1 == nrhs) _error_("Argument " << i+2 << " must exist and be value of option \"" << name << "\".");
421 
422  option=(Option*)OptionParse(name,&pdataref[i+1]);
423  options->AddOption(option);
424  option=NULL;
425  }
426 
427  /*Assign output pointers:*/
428  *poptions=options;
429 }

◆ FetchData() [16/16]

void FetchData ( Contours **  pcontours,
const mxArray *  dataref 
)

Definition at line 431 of file FetchMatlabData.cpp.

431  {/*{{{*/
432 
433  int numcontours,index,test1,test2;
434  char *contourname = NULL;
435  Contours *contours = NULL;
436  Contour<double> *contouri = NULL;
437 
438  if(mxIsClass(dataref,"char")){
439  FetchData(&contourname,dataref);
440  contours=ExpRead<double>(contourname);
441  }
442  else if(mxIsClass(dataref,"struct")){
443 
444  contours=new Contours();
445  numcontours=mxGetNumberOfElements(dataref);
446 
447  for(int i=0;i<numcontours;i++){
448 
449  contouri=new Contour<double>();
450 
451  index = mxGetFieldNumber(dataref,"nods");
452  if(index==-1) _error_("input structure does not have a 'nods' field");
453  FetchData(&contouri->nods,mxGetFieldByNumber(dataref,i,index));
454 
455  index = mxGetFieldNumber(dataref,"x");
456  if(index==-1) _error_("input structure does not have a 'x' field");
457  FetchData(&contouri->x,&test1,&test2,mxGetFieldByNumber(dataref,i,index));
458  if(test1!=contouri->nods || test2!=1) _error_("field x should be of size ["<<contouri->nods<<" 1]");
459 
460  index = mxGetFieldNumber(dataref,"y");
461  if(index==-1) _error_("input structure does not have a 'y' field");
462  FetchData(&contouri->y,&test1,&test2,mxGetFieldByNumber(dataref,i,index));
463  if(test1!=contouri->nods || test2!=1) _error_("field y should be of size ["<<contouri->nods<<" 1]");
464 
465  contours->AddObject(contouri);
466  }
467  }
468  else{
469  _error_("Contour is neither a string nor a structure and cannot be loaded ("<<mxGetClassName(dataref)<<" not supported)");
470  }
471 
472  /*clean-up and assign output pointer*/
473  xDelete<char>(contourname);
474  *pcontours=contours;
475 }

◆ FetchChacoData()

void FetchChacoData ( int *  pnvtxs,
int **  padjacency,
int **  pstart,
float **  pewgts,
const mxArray *  A_IN,
const mxArray *  EWGTS_IN 
)

Definition at line 477 of file FetchMatlabData.cpp.

477  {/*{{{*/
478 
479  /*Fetch adjacency matrix: */
480  int nvtxs = mxGetN(A_IN);
481  mwIndex* mwstart = mxGetJc(A_IN);
482  mwIndex* mwadjacency = mxGetIr(A_IN);
483  int nzmax = mxGetNzmax(A_IN);
484 
485  int* start = xNew<int>(nvtxs+1);
486  for(int i=0;i<nvtxs+1;i++) start[i]=(int)mwstart[i];
487 
488  int* adjacency = xNew<int>(nzmax);
489  for(int i=0; i<nzmax; i++) adjacency[i]= (int)mwadjacency[i];
490 
491  /*Get edges weights*/
492  int nedges = start[nvtxs];
493  float* ewgts = NULL;
494  if(!mxIsEmpty(EWGTS_IN)){
495  ewgts = xNewZeroInit<float>(nedges);
496  double* doublepointer = mxGetPr(A_IN);
497  for(int i = 0; i<nedges;i++) ewgts[i] = (float)doublepointer[i];
498  }
499 
500  /*Assign output pointers*/
501  *pnvtxs = nvtxs;
502  *padjacency = adjacency;
503  *pstart = start;
504  *pewgts = ewgts;
505 }

◆ OptionParse()

Option* OptionParse ( char *  name,
const mxArray *  prhs[] 
)

Definition at line 606 of file FetchMatlabData.cpp.

606  { /*{{{*/
607 
608  /*Initialize output*/
609  Option *option = NULL;
610 
611  /*parse the value according to the matlab data type */
612  if (mxIsClass(prhs[0],"double") && (mxGetNumberOfElements(prhs[0])==1)){
613  option=(Option*)OptionDoubleParse(name,prhs);
614  }
615  else if(mxIsClass(prhs[0],"double") && (mxGetNumberOfElements(prhs[0])>1)){
616  option=(Option*)OptionDoubleArrayParse(name,prhs);
617  }
618  else if(mxIsClass(prhs[0],"char")){
619  option=(Option*)OptionCharParse(name,prhs);
620  }
621  else {
622  _error_("Second argument value of option \""<< name <<"\" is of unrecognized class \""<< mxGetClassName(prhs[0]) <<"\".");
623  }
624 
625  return option;
626 }/*}}}*/

◆ OptionDoubleParse()

GenericOption<double>* OptionDoubleParse ( char *  name,
const mxArray *  prhs[] 
)

Definition at line 627 of file FetchMatlabData.cpp.

627  { /*{{{*/
628 
629  /*Initialize option*/
630  GenericOption<double>* option=new GenericOption<double>();
631 
632  /*Copy name*/
633  option->name =xNew<char>(strlen(name)+1);
634  memcpy(option->name,name,(strlen(name)+1)*sizeof(char));
635 
636  /*Fetch data and initialize size*/
637  FetchData(&option->value,prhs[0]);
638  option->size[0] = 1;
639  option->size[1] = 1;
640 
641  return option;
642 }/*}}}*/

◆ OptionDoubleArrayParse()

GenericOption<double*>* OptionDoubleArrayParse ( char *  name,
const mxArray *  prhs[] 
)

Definition at line 643 of file FetchMatlabData.cpp.

643  { /*{{{*/
644 
645  /*Initialize option*/
646  GenericOption<double*> * option=new GenericOption<double*>();
647 
648  /*Copy name*/
649  option->name =xNew<char>(strlen(name)+1);
650  memcpy(option->name,name,(strlen(name)+1)*sizeof(char));
651 
652  /*check and parse the value */
653  if (!mxIsClass(prhs[0],"double")){
654  _error_("Value of option \"" << option->name << "\" must be class \"double\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
655  }
656 
657  /*Fetch data and initialize size*/
658  FetchData(&option->value,&option->size[0],&option->size[1],prhs[0]);
659 
660  return option;
661 }/*}}}*/

◆ OptionCharParse()

GenericOption<char*>* OptionCharParse ( char *  name,
const mxArray *  prhs[] 
)

Definition at line 662 of file FetchMatlabData.cpp.

662  { /*{{{*/
663 
664  /*Initialize option*/
665  GenericOption<char*>* option=new GenericOption<char*>();
666 
667  /*Copy name*/
668  option->name =xNew<char>(strlen(name)+1);
669  memcpy(option->name,name,(strlen(name)+1)*sizeof(char));
670 
671  /*check and parse the value */
672  if(!mxIsClass(prhs[0],"char")){
673  _error_("Value of option \"" << option->name << "\" must be class \"char\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
674  }
675 
676  /*Fetch data and initialize size*/
677  FetchData(&option->value,prhs[0]);
678  option->size[0] = strlen(name);
679  option->size[1] = 1;
680 
681  return(option);
682 }/*}}}*/

◆ mxGetAssignedField()

mxArray* mxGetAssignedField ( const mxArray *  pmxa_array,
int  number,
const char *  field 
)

Definition at line 572 of file FetchMatlabData.cpp.

572  {/*{{{*/
573 
574  /*Output*/
575  mxArray *mxfield = NULL;
576 
577  if(mxIsStruct(pmxa_array)){
578  mxfield = mxGetField(pmxa_array,number,field);
579  }
580  else{
581  /*This is an object, mxGetField returns NULL in old version of matlab (we do not have access to them)*/
582 
583  /*Intermediaries*/
584  mxArray *inputs[2];
585  mwSize ndim = 2;
586  mwSize onebyone[2] = {1,1};
587 
588  /*create index structure used in the assignment (index.type='.' and index.subs='x' for field x*/
589  const char *fnames[2];
590  fnames[0] = "type"; fnames[1] = "subs";
591  mxArray* pindex=mxCreateStructArray( ndim,onebyone,2,fnames);
592  mxSetField( pindex, 0, "type",mxCreateString("."));
593  mxSetField( pindex, 0, "subs",mxCreateString(field));
594  inputs[0]=(mxArray*)pmxa_array; //this is the model
595  inputs[1]=pindex;
596 
597  mexCallMATLAB( 1, &mxfield, 2, (mxArray**)inputs, "subsref");
598  }
599 
600  if(mxfield == NULL) _error_("Could not find field "<< field <<" in structure");
601 
602  return mxfield;
603 }/*}}}*/

◆ SetStructureField()

void SetStructureField ( mxArray *  dataref,
const char *  fieldname,
int  fieldrows,
int  fieldcols,
double *  fieldpointer 
)

Definition at line 441 of file WriteMatlabData.cpp.

441  {
442 
443  mxArray* field = NULL;
444 
445  /*Convert field*/
446  WriteData(&field,fieldpointer,M,N);
447 
448  /*Assign to structure*/
449  mxSetField(dataref,0,fieldname,field);
450 }

◆ SetStructureFieldi() [1/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
int  fieldrows,
int  fieldcols,
double *  fieldpointer 
)

Definition at line 465 of file WriteMatlabData.cpp.

465  {
466 
467  mxArray* field = NULL;
468 
469  /*Convert field*/
470  WriteData(&field,fieldpointer,M,N);
471 
472  /*Assign to structure*/
473  mxSetField(dataref,i,fieldname,field);
474 }

◆ SetStructureFieldi() [2/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
int  fieldrows,
int  fieldcols,
int *  fieldpointer 
)

Definition at line 477 of file WriteMatlabData.cpp.

477  {
478 
479  mxArray* field = NULL;
480 
481  /*Convert field*/
482  WriteData(&field,fieldpointer,M,N);
483 
484  /*Assign to structure*/
485  mxSetField(dataref,i,fieldname,field);
486 }

◆ SetStructureFieldi() [3/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
int  field 
)

Definition at line 489 of file WriteMatlabData.cpp.

489  {
490 
491  mxArray* field = NULL;
492 
493  /*Convert field*/
494  WriteData(&field,fieldin);
495 
496  /*Assign to structure*/
497  mxSetField(dataref,i,fieldname,field);
498 }

◆ SetStructureFieldi() [4/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
double  field 
)

Definition at line 501 of file WriteMatlabData.cpp.

501  {
502 
503  mxArray* field = NULL;
504 
505  /*Convert field*/
506  WriteData(&field,fieldin);
507 
508  /*Assign to structure*/
509  mxSetField(dataref,i,fieldname,field);
510 }

◆ SetStructureFieldi() [5/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
const char *  string 
)

Definition at line 453 of file WriteMatlabData.cpp.

453  {
454 
455  mxArray* field = NULL;
456 
457  /*Convert field*/
458  WriteData(&field,string);
459 
460  /*Assign to structure*/
461  mxSetField(dataref,i,fieldname,field);
462 }

◆ CheckNumMatlabArguments()

int CheckNumMatlabArguments ( int  nlhs,
int  NLHS,
int  nrhs,
int  NRHS,
const char *  THISFUNCTION,
void(*)(void)  function 
)

Definition at line 7 of file CheckNumMatlabArguments.cpp.

7  {
8 
9  /*checks on arguments on the matlab side: */
10  if (nrhs==0 && nlhs==0) {
11  /*unless NLHS=0 and NRHS=0, we are just asking for documentation: */
12  if (NRHS==0 && NLHS==0)return 1;
13  /* special case: */
14  function();
15  _error_("usage: see above");
16  }
17  else if (nlhs!=NLHS || nrhs!=NRHS ) {
18  function();
19  _error_("usage error.");
20  }
21  return 1;
22 }

◆ MatlabMatrixToDoubleMatrix()

int MatlabMatrixToDoubleMatrix ( double **  pmatrix,
int *  pmatrix_rows,
int *  pmatrix_cols,
const mxArray *  mxmatrix 
)

Definition at line 509 of file FetchMatlabData.cpp.

509  {/*{{{*/
510 
511  /*Get Matrix size*/
512  int rows=mxGetM(mxmatrix);
513  int cols=mxGetN(mxmatrix);
514 
515  /*Return of Matrix is empty*/
516  if(rows*cols == 0){
517  *pmatrix = NULL;
518  *pmatrix_rows = rows;
519  *pmatrix_cols = cols;
520  return 1;
521  }
522 
523  /*Initialize output*/
524  double* matrix=xNewZeroInit<double>(rows*cols);
525 
526  /*First check if we are dealing with a sparse matrix: */
527  if(mxIsSparse(mxmatrix)){
528 
529  /*Dealing with sparse matrix: recover size first: */
530  double* pmxmatrix=(double*)mxGetPr(mxmatrix);
531 
532  /*Now, get ir,jc and pr: */
533  mwIndex* ir=mxGetIr(mxmatrix);
534  mwIndex* jc=mxGetJc(mxmatrix);
535 
536  /*Now, start inserting data into double* matrix: */
537  int count=0;
538  for(int i=0;i<cols;i++){
539  for(int j=0;j<(jc[i+1]-jc[i]);j++){
540  matrix[rows*ir[count]+i]=pmxmatrix[count];
541  count++;
542  }
543  }
544  }
545  else if(mxIsClass(mxmatrix,"double")){
546  double* pmxmatrix=(double*)mxGetPr(mxmatrix);
547  for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) matrix[cols*i+j]=(double)pmxmatrix[rows*j+i];
548  }
549  else if(mxIsClass(mxmatrix,"single")){
550  float *pmxmatrix=(float*)mxGetPr(mxmatrix);
551  for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) matrix[cols*i+j]=(double)pmxmatrix[rows*j+i];
552  }
553  else if(mxIsClass(mxmatrix,"int16")){
554  short int *pmxmatrix=(short*)mxGetPr(mxmatrix);
555  for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) matrix[cols*i+j]=(double)pmxmatrix[rows*j+i];
556  }
557  else if(mxIsClass(mxmatrix,"uint8")){
558  char *pmxmatrix=(char*)mxGetPr(mxmatrix);
559  for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) matrix[cols*i+j]=(double)pmxmatrix[rows*j+i];
560  }
561  else{
562  _error_("Matlab matrix type "<<mxGetClassName(mxmatrix)<<" Not implemented yet");
563  }
564 
565  /*Assign output pointer: */
566  *pmatrix=matrix;
567  *pmatrix_rows=rows;
568  *pmatrix_cols=cols;
569 
570  return 1;
571 }/*}}}*/

◆ ApiPrintf()

void ApiPrintf ( const char *  string)

Definition at line 13 of file ApiPrintf.cpp.

13  {
14  printf("%s",string);
15 }
BamgGeom::RequiredVertices
double * RequiredVertices
Definition: BamgGeom.h:19
DataSet::Size
int Size()
Definition: DataSet.cpp:399
BamgOpts::cutoff
double cutoff
Definition: BamgOpts.h:14
BamgGeom::Edges
double * Edges
Definition: BamgGeom.h:13
RiftStruct::riftsnumpairs
int * riftsnumpairs
Definition: RiftStruct.h:14
GenericOption::size
int size[2]
Definition: GenericOption.h:27
BamgGeom::CrackedEdges
double * CrackedEdges
Definition: BamgGeom.h:23
FetchData
void FetchData(double **pmatrix, int *pM, int *pN, const mxArray *dataref)
Definition: FetchMatlabData.cpp:15
Options
Definition: Options.h:9
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
BamgOpts::power
double power
Definition: BamgOpts.h:25
BamgGeom::CornersSize
int CornersSize[2]
Definition: BamgGeom.h:16
IssmSeqVec::ToMPISerial
doubletype * ToMPISerial(void)
Definition: IssmSeqVec.h:207
BamgMesh::VerticesOnGeomVertexSize
int VerticesOnGeomVertexSize[2]
Definition: BamgMesh.h:19
RiftStruct::riftsnumpenaltypairs
int * riftsnumpenaltypairs
Definition: RiftStruct.h:15
BamgOpts::err
double * err
Definition: BamgOpts.h:47
RiftStruct::riftstips
int * riftstips
Definition: RiftStruct.h:18
BamgMesh::EdgesOnGeomEdge
double * EdgesOnGeomEdge
Definition: BamgMesh.h:24
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
GenericOption::name
char * name
Definition: GenericOption.h:25
BamgOpts::maxsubdiv
double maxsubdiv
Definition: BamgOpts.h:20
BamgMesh::NodalConnectivitySize
int NodalConnectivitySize[2]
Definition: BamgMesh.h:42
BamgMesh::NodalElementConnectivity
double * NodalElementConnectivity
Definition: BamgMesh.h:45
IssmDenseMat::ToSerial
doubletype * ToSerial(void)
Definition: IssmDenseMat.h:215
NRHS
#define NRHS
Definition: BamgConvertMesh.h:52
BamgGeom::Corners
double * Corners
Definition: BamgGeom.h:17
BamgMesh::VerticesOnGeomEdgeSize
int VerticesOnGeomEdgeSize[2]
Definition: BamgMesh.h:21
BamgGeom::TangentAtEdgesSize
int TangentAtEdgesSize[2]
Definition: BamgGeom.h:14
BamgGeom::RequiredEdgesSize
int RequiredEdgesSize[2]
Definition: BamgGeom.h:20
BamgOpts::verbose
int verbose
Definition: BamgOpts.h:26
BamgOpts::Crack
int Crack
Definition: BamgOpts.h:29
BamgMesh::NodalConnectivity
double * NodalConnectivity
Definition: BamgMesh.h:43
OptionParse
Option * OptionParse(char *name, const mxArray *prhs[])
Definition: FetchMatlabData.cpp:606
BamgMesh::Vertices
double * Vertices
Definition: BamgMesh.h:12
Contours
Declaration of Contours class.
Definition: Contours.h:10
BamgMesh::SubDomainsSize
int SubDomainsSize[2]
Definition: BamgMesh.h:26
BamgOpts::field
double * field
Definition: BamgOpts.h:45
BamgOpts::Hessiantype
int Hessiantype
Definition: BamgOpts.h:18
Contour
Definition: Contour.h:15
BamgMesh
Definition: BamgMesh.h:7
BamgGeom::SubDomainsSize
int SubDomainsSize[2]
Definition: BamgGeom.h:24
RiftStruct::state
double ** state
Definition: RiftStruct.h:19
BamgOpts::coeff
double coeff
Definition: BamgOpts.h:15
GenericOption::value
OptionType value
Definition: GenericOption.h:26
BamgOpts::nbjacobi
int nbjacobi
Definition: BamgOpts.h:22
BamgOpts::omega
double omega
Definition: BamgOpts.h:24
BamgMesh::CrackedVertices
double * CrackedVertices
Definition: BamgMesh.h:31
BamgMesh::ElementConnectivity
double * ElementConnectivity
Definition: BamgMesh.h:41
IssmDenseMat::GetSize
void GetSize(int *pM, int *pN)
Definition: IssmDenseMat.h:165
BamgOpts::metricSize
int metricSize[2]
Definition: BamgOpts.h:42
BamgGeom::SubDomains
double * SubDomains
Definition: BamgGeom.h:25
SetStructureFieldi
void SetStructureFieldi(mxArray *dataref, int i, const char *fieldname, const char *string)
Definition: WriteMatlabData.cpp:453
BamgOpts::hVertices
double * hVertices
Definition: BamgOpts.h:41
SetStructureField
void SetStructureField(mxArray *dataref, const char *fieldname, int M, int N, double *fieldpointer)
Definition: WriteMatlabData.cpp:441
BamgOpts::KeepVertices
int KeepVertices
Definition: BamgOpts.h:30
BamgMesh::SubDomains
double * SubDomains
Definition: BamgMesh.h:27
BamgMesh::EdgesOnGeomEdgeSize
int EdgesOnGeomEdgeSize[2]
Definition: BamgMesh.h:23
BamgOpts::gradation
double gradation
Definition: BamgOpts.h:17
BamgMesh::VerticesSize
int VerticesSize[2]
Definition: BamgMesh.h:11
BamgOpts::nbsmooth
int nbsmooth
Definition: BamgOpts.h:23
BamgMesh::CrackedVerticesSize
int CrackedVerticesSize[2]
Definition: BamgMesh.h:30
BamgGeom::CrackedEdgesSize
int CrackedEdgesSize[2]
Definition: BamgGeom.h:22
BamgMesh::VerticesOnGeomEdge
double * VerticesOnGeomEdge
Definition: BamgMesh.h:22
BamgOpts::fieldSize
int fieldSize[2]
Definition: BamgOpts.h:44
BamgGeom::TangentAtEdges
double * TangentAtEdges
Definition: BamgGeom.h:15
BamgMesh::EdgesSize
int EdgesSize[2]
Definition: BamgMesh.h:14
mxGetAssignedField
mxArray * mxGetAssignedField(const mxArray *pmxa_array, int number, const char *field)
Definition: FetchMatlabData.cpp:572
OptionDoubleParse
GenericOption< double > * OptionDoubleParse(char *name, const mxArray *prhs[])
Definition: FetchMatlabData.cpp:627
BamgOpts::hmaxVerticesSize
int hmaxVerticesSize[2]
Definition: BamgOpts.h:38
RiftStruct::riftsnumsegments
int * riftsnumsegments
Definition: RiftStruct.h:16
BamgMesh::SubDomainsFromGeom
double * SubDomainsFromGeom
Definition: BamgMesh.h:29
WriteData
void WriteData(mxArray **pdataref, double *matrix, int M, int N)
Definition: WriteMatlabData.cpp:16
BamgGeom::RequiredVerticesSize
int RequiredVerticesSize[2]
Definition: BamgGeom.h:18
BamgOpts::hmaxVertices
double * hmaxVertices
Definition: BamgOpts.h:39
BamgOpts::hmax
double hmax
Definition: BamgOpts.h:35
BamgMesh::PreviousNumbering
double * PreviousNumbering
Definition: BamgMesh.h:13
IssmSeqVec::GetSize
void GetSize(int *pM)
Definition: IssmSeqVec.h:136
BamgOpts
Definition: BamgOpts.h:8
BamgMesh::Edges
double * Edges
Definition: BamgMesh.h:15
RiftStruct::riftssegments
int ** riftssegments
Definition: RiftStruct.h:17
RiftStruct::riftspenaltypairs
double ** riftspenaltypairs
Definition: RiftStruct.h:13
BamgOpts::errSize
int errSize[2]
Definition: BamgOpts.h:46
Contour::nods
int nods
Definition: Contour.h:20
BamgOpts::splitcorners
int splitcorners
Definition: BamgOpts.h:31
BamgMesh::SubDomainsFromGeomSize
int SubDomainsFromGeomSize[2]
Definition: BamgMesh.h:28
BamgMesh::IssmSegmentsSize
int IssmSegmentsSize[2]
Definition: BamgMesh.h:38
RiftStruct::numrifts
int numrifts
Definition: RiftStruct.h:11
BamgOpts::maxnbv
int maxnbv
Definition: BamgOpts.h:19
Contour::closed
bool closed
Definition: Contour.h:23
BamgOpts::metric
double * metric
Definition: BamgOpts.h:43
Option
Definition: Option.h:13
NLHS
#define NLHS
Definition: BamgConvertMesh.h:50
BamgGeom::VerticesSize
int VerticesSize[2]
Definition: BamgGeom.h:10
BamgMesh::TrianglesSize
int TrianglesSize[2]
Definition: BamgMesh.h:16
BamgGeom::EdgesSize
int EdgesSize[2]
Definition: BamgGeom.h:12
BamgGeom
Definition: BamgGeom.h:7
BamgMesh::VerticesOnGeomVertex
double * VerticesOnGeomVertex
Definition: BamgMesh.h:20
Contour::y
doubletype * y
Definition: Contour.h:22
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Contour::id
int id
Definition: Contour.h:19
RiftStruct::riftspairs
int ** riftspairs
Definition: RiftStruct.h:12
BamgOpts::hmin
double hmin
Definition: BamgOpts.h:34
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
BamgOpts::Check
void Check(void)
Definition: BamgOpts.cpp:50
BamgMesh::IssmEdgesSize
int IssmEdgesSize[2]
Definition: BamgMesh.h:36
Contour::x
doubletype * x
Definition: Contour.h:21
BamgOpts::errg
double errg
Definition: BamgOpts.h:16
BamgGeom::Vertices
double * Vertices
Definition: BamgGeom.h:11
BamgOpts::hVerticesLength
int hVerticesLength
Definition: BamgOpts.h:40
OptionDoubleArrayParse
GenericOption< double * > * OptionDoubleArrayParse(char *name, const mxArray *prhs[])
Definition: FetchMatlabData.cpp:643
OptionCharParse
GenericOption< char * > * OptionCharParse(char *name, const mxArray *prhs[])
Definition: FetchMatlabData.cpp:662
BamgMesh::NodalElementConnectivitySize
int NodalElementConnectivitySize[2]
Definition: BamgMesh.h:44
BamgGeom::RequiredEdges
double * RequiredEdges
Definition: BamgGeom.h:21
BamgOpts::anisomax
double anisomax
Definition: BamgOpts.h:13
BamgOpts::Metrictype
int Metrictype
Definition: BamgOpts.h:21
BamgMesh::IssmSegments
double * IssmSegments
Definition: BamgMesh.h:39
MatlabMatrixToDoubleMatrix
int MatlabMatrixToDoubleMatrix(double **pmatrix, int *pmatrix_rows, int *pmatrix_cols, const mxArray *mxmatrix)
Definition: FetchMatlabData.cpp:509
BamgMesh::ElementConnectivitySize
int ElementConnectivitySize[2]
Definition: BamgMesh.h:40
BamgMesh::CrackedEdges
double * CrackedEdges
Definition: BamgMesh.h:33
Options::AddOption
int AddOption(Option *in_oobject)
Definition: Options.cpp:33
BamgOpts::hminVerticesSize
int hminVerticesSize[2]
Definition: BamgOpts.h:36
BamgMesh::Triangles
double * Triangles
Definition: BamgMesh.h:17
BamgMesh::IssmEdges
double * IssmEdges
Definition: BamgMesh.h:37
BamgMesh::CrackedEdgesSize
int CrackedEdgesSize[2]
Definition: BamgMesh.h:32
GenericOption
Definition: GenericOption.h:22
BamgOpts::hminVertices
double * hminVertices
Definition: BamgOpts.h:37
Generated on Thu Jul 2 2020 08:09:26 for Ice Sheet System Model by   doxygen 1.8.19