Ice Sheet System Model  4.18
Code documentation
WriteMatlabData.cpp
Go to the documentation of this file.
1 /* \file WriteData.c:
2  * \brief: general interface for writing data
3  */
4 
5 #ifdef HAVE_CONFIG_H
6  #include <config.h>
7 #else
8 #error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
9 #endif
10 
11 #include "./matlabio.h"
12 #include "./../../../c/datastructures/datastructures.h"
13 
14 /*Primitive data types*/
15 /*FUNCTION WriteData(mxArray** pdataref,double* matrix, int M,int N){{{*/
16 void WriteData(mxArray** pdataref,double* matrix, int M,int N){
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 }
39 /*}}}*/
40 /*FUNCTION WriteData(mxArray** pdataref,int* matrix, int M,int N){{{*/
41 void WriteData(mxArray** pdataref,int* matrix, int M,int N){
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 }
64 /*}}}*/
65 /*FUNCTION WriteData(mxArray** pdataref,double* vector, int M){{{*/
66 void WriteData(mxArray** pdataref,double* vector, int M){
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 }
87 /*}}}*/
88 /*FUNCTION WriteData(mxArray** pdataref,int* vector, int M){{{*/
89 void WriteData(mxArray** pdataref,int* vector, int M){
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 }
110 /*}}}*/
111 /*FUNCTION WriteData(mxArray** pdataref,short* vector, int M){{{*/
112 void WriteData(mxArray** pdataref,short* vector, int M){
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 }
133 /*}}}*/
134 /*FUNCTION WriteData(mxArray** pdataref,double scalar){{{*/
135 void WriteData(mxArray** pdataref,double scalar){
136 
137  *pdataref=mxCreateDoubleScalar(scalar);
138 }
139 /*}}}*/
140 /*FUNCTION WriteData(mxArray** pdataref,int integer){{{*/
141 void WriteData(mxArray** pdataref,int integer){
142 
143  *pdataref=mxCreateDoubleScalar((double)integer);
144 
145 }
146 /*}}}*/
147 /*FUNCTION WriteData(mxArray** pdataref,int boolean){{{*/
148 void WriteData(mxArray** pdataref,bool boolean){
149 
150  *pdataref=mxCreateDoubleScalar((double)boolean);
151 
152 }
153 /*}}}*/
154 /*FUNCTION WriteData(mxArray** pdataref,char* string){{{*/
155 void WriteData(mxArray** pdataref,const char* string){
156 
157  *pdataref=mxCreateString(string);
158 }
159 /*}}}*/
160 /*FUNCTION WriteData(mxArray** pdataref){{{*/
161 void WriteData(mxArray** pdataref){
162 
163  ;
164 
165 }
166 /*}}}*/
167 
168 /*ISSM objects*/
169 /*FUNCTION WriteData(mxArray** pdataref,BamgGeom* bamggeom){{{*/
170 void WriteData(mxArray** pdataref,BamgGeom* bamggeom){
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 }
210 /*}}}*/
211 /*FUNCTION WriteData(mxArray** pdataref,BamgMesh* bamgmesh){{{*/
212 void WriteData(mxArray** pdataref,BamgMesh* bamgmesh){
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 }
268 /*}}}*/
269 /*FUNCTION WriteData(mxArray** pdataref,IssmDenseMat<double>* matrix){{{*/
270 void WriteData(mxArray** pdataref,IssmDenseMat<double>* matrix){
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 }
306 /*}}}*/
307 /*FUNCTION WriteData(mxArray** pdataref,IssmSeqVec<double>* vector){{{*/
308 void WriteData(mxArray** pdataref,IssmSeqVec<double>* vector){
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 }
337 /*}}}*/
338 /*FUNCTION WriteData(mxArray** pdataref,RiftStruct* riftstruct){{{*/
339 void WriteData(mxArray** pdataref,RiftStruct* riftstruct){
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 }
384 /*}}}*/
385 /*FUNCTION WriteData(mxArray** pdataref,Contours* contours){{{*/
386 void WriteData(mxArray** pdataref,Contours* contours){
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 }
437 /*}}}*/
438 
439 /*Toolkit*/
440 /*FUNCTION SetStructureField(mxArray* dataref,const char* fieldname,int M,int N,double* fieldpointer){{{*/
441 void SetStructureField(mxArray* dataref,const char* fieldname,int M,int N,double* fieldpointer){
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 }
451 /*}}}*/
452 /*FUNCTION SetStructureFieldi(mxArray* dataref,const char* fieldname,const char* string) {{{*/
453 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,const char* string){
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 }
463 /*}}}*/
464 /*FUNCTION SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int M,int N,double* fieldpointer){{{*/
465 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int M,int N,double* fieldpointer){
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 }
475 /*}}}*/
476 /*FUNCTION SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int M,int N,int* fieldpointer){{{*/
477 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int M,int N,int* fieldpointer){
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 }
487 /*}}}*/
488 /*FUNCTION SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int field){{{*/
489 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,int fieldin){
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 }
499 /*}}}*/
500 /*FUNCTION SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,double field){{{*/
501 void SetStructureFieldi(mxArray* dataref,int i,const char* fieldname,double fieldin){
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 }
511 /*}}}*/
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
IssmDenseMat
Definition: IssmDenseMat.h:39
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
Contours
Declaration of Contours class.
Definition: Contours.h:10
IssmSeqVec
Definition: IssmSeqVec.h:31
BamgMesh::SubDomainsSize
int SubDomainsSize[2]
Definition: BamgMesh.h:26
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
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
matlabio.h
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
BamgGeom
Definition: BamgGeom.h:7
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
RiftStruct
Definition: RiftStruct.h:8
Generated on Thu Jul 2 2020 08:09:22 for Ice Sheet System Model by   doxygen 1.8.19