Ice Sheet System Model  4.18
Code documentation
Functions
WriteMatlabData.cpp File Reference
#include "./matlabio.h"
#include "./../../../c/datastructures/datastructures.h"

Go to the source code of this file.

Functions

void WriteData (mxArray **pdataref, double *matrix, int M, int N)
 
void WriteData (mxArray **pdataref, int *matrix, int M, int N)
 
void WriteData (mxArray **pdataref, double *vector, int M)
 
void WriteData (mxArray **pdataref, int *vector, int M)
 
void WriteData (mxArray **pdataref, short *vector, int M)
 
void WriteData (mxArray **pdataref, double scalar)
 
void WriteData (mxArray **pdataref, int integer)
 
void WriteData (mxArray **pdataref, bool boolean)
 
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, IssmDenseMat< double > *matrix)
 
void WriteData (mxArray **pdataref, IssmSeqVec< double > *vector)
 
void WriteData (mxArray **pdataref, RiftStruct *riftstruct)
 
void WriteData (mxArray **pdataref, Contours *contours)
 
void SetStructureField (mxArray *dataref, const char *fieldname, int M, int N, double *fieldpointer)
 
void SetStructureFieldi (mxArray *dataref, int i, const char *fieldname, const char *string)
 
void SetStructureFieldi (mxArray *dataref, int i, const char *fieldname, int M, int N, double *fieldpointer)
 
void SetStructureFieldi (mxArray *dataref, int i, const char *fieldname, int M, int N, int *fieldpointer)
 
void SetStructureFieldi (mxArray *dataref, int i, const char *fieldname, int fieldin)
 
void SetStructureFieldi (mxArray *dataref, int i, const char *fieldname, double fieldin)
 

Function Documentation

◆ WriteData() [1/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() [2/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() [3/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() [4/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() [5/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() [6/16]

void WriteData ( mxArray **  pdataref,
double  scalar 
)

Definition at line 135 of file WriteMatlabData.cpp.

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

◆ WriteData() [7/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() [8/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() [9/16]

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

Definition at line 155 of file WriteMatlabData.cpp.

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

◆ WriteData() [10/16]

void WriteData ( mxArray **  pdataref)

Definition at line 161 of file WriteMatlabData.cpp.

161  {
162 
163  ;
164 
165 }

◆ WriteData() [11/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() [12/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() [13/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() [14/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() [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 }

◆ SetStructureField()

void SetStructureField ( mxArray *  dataref,
const char *  fieldname,
int  M,
int  N,
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,
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 }

◆ SetStructureFieldi() [2/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
int  M,
int  N,
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() [3/5]

void SetStructureFieldi ( mxArray *  dataref,
int  i,
const char *  fieldname,
int  M,
int  N,
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() [4/5]

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

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() [5/5]

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

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 }
BamgGeom::RequiredVertices
double * RequiredVertices
Definition: BamgGeom.h:19
DataSet::Size
int Size()
Definition: DataSet.cpp:399
BamgGeom::Edges
double * Edges
Definition: BamgGeom.h:13
RiftStruct::riftsnumpairs
int * riftsnumpairs
Definition: RiftStruct.h:14
BamgGeom::CrackedEdges
double * CrackedEdges
Definition: BamgGeom.h:23
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
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
RiftStruct::riftstips
int * riftstips
Definition: RiftStruct.h:18
BamgMesh::EdgesOnGeomEdge
double * EdgesOnGeomEdge
Definition: BamgMesh.h:24
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
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
BamgMesh::NodalConnectivity
double * NodalConnectivity
Definition: BamgMesh.h:43
BamgMesh::Vertices
double * Vertices
Definition: BamgMesh.h:12
BamgMesh::SubDomainsSize
int SubDomainsSize[2]
Definition: BamgMesh.h:26
Contour
Definition: Contour.h:15
BamgGeom::SubDomainsSize
int SubDomainsSize[2]
Definition: BamgGeom.h:24
RiftStruct::state
double ** state
Definition: RiftStruct.h:19
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
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
SetStructureField
void SetStructureField(mxArray *dataref, const char *fieldname, int M, int N, double *fieldpointer)
Definition: WriteMatlabData.cpp:441
BamgMesh::SubDomains
double * SubDomains
Definition: BamgMesh.h:27
BamgMesh::EdgesOnGeomEdgeSize
int EdgesOnGeomEdgeSize[2]
Definition: BamgMesh.h:23
BamgMesh::VerticesSize
int VerticesSize[2]
Definition: BamgMesh.h:11
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
BamgGeom::TangentAtEdges
double * TangentAtEdges
Definition: BamgGeom.h:15
BamgMesh::EdgesSize
int EdgesSize[2]
Definition: BamgMesh.h:14
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
BamgMesh::PreviousNumbering
double * PreviousNumbering
Definition: BamgMesh.h:13
IssmSeqVec::GetSize
void GetSize(int *pM)
Definition: IssmSeqVec.h:136
BamgMesh::Edges
double * Edges
Definition: BamgMesh.h:15
RiftStruct::riftssegments
int ** riftssegments
Definition: RiftStruct.h:17
RiftStruct::riftspenaltypairs
double ** riftspenaltypairs
Definition: RiftStruct.h:13
Contour::nods
int nods
Definition: Contour.h:20
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
Contour::closed
bool closed
Definition: Contour.h:23
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
BamgMesh::VerticesOnGeomVertex
double * VerticesOnGeomVertex
Definition: BamgMesh.h:20
Contour::y
doubletype * y
Definition: Contour.h:22
Contour::id
int id
Definition: Contour.h:19
RiftStruct::riftspairs
int ** riftspairs
Definition: RiftStruct.h:12
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
BamgMesh::IssmEdgesSize
int IssmEdgesSize[2]
Definition: BamgMesh.h:36
Contour::x
doubletype * x
Definition: Contour.h:21
BamgGeom::Vertices
double * Vertices
Definition: BamgGeom.h:11
BamgMesh::NodalElementConnectivitySize
int NodalElementConnectivitySize[2]
Definition: BamgMesh.h:44
BamgGeom::RequiredEdges
double * RequiredEdges
Definition: BamgGeom.h:21
BamgMesh::IssmSegments
double * IssmSegments
Definition: BamgMesh.h:39
BamgMesh::ElementConnectivitySize
int ElementConnectivitySize[2]
Definition: BamgMesh.h:40
BamgMesh::CrackedEdges
double * CrackedEdges
Definition: BamgMesh.h:33
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
Generated on Thu Jul 2 2020 08:09:26 for Ice Sheet System Model by   doxygen 1.8.19