Ice Sheet System Model  4.18
Code documentation
TriaRef.cpp
Go to the documentation of this file.
1 
5 /*Headers:*/
6 /*{{{*/
7 #ifdef HAVE_CONFIG_H
8  #include <config.h>
9 #else
10 #error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
11 #endif
12 
13 #include "../classes.h"
14 #include "../../shared/shared.h"
15 /*}}}*/
16 
17 /*Element macros*/
18 #define NUMNODESP0 1
19 #define NUMNODESP1 3
20 #define NUMNODESP1b 4
21 #define NUMNODESP2 6
22 #define NUMNODESP2b 7
23 #define NUMNODESMAX 7
24 
25 /*Object constructors and destructor*/
26 TriaRef::TriaRef(){/*{{{*/
27 }
28 /*}}}*/
29 TriaRef::~TriaRef(){/*{{{*/
30 }
31 /*}}}*/
32 
33 /*Reference Element numerics*/
34 void TriaRef::GetInputDerivativeValue(IssmDouble* p, IssmDouble* plist,IssmDouble* xyz_list, Gauss* gauss,int finiteelement){/*{{{*/
35  /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter derivative value at gaussian
36  * point specified by gauss_basis:
37  * dp/dx=plist[0]*dh1/dx+plist[1]*dh2/dx+plist[2]*dh3/dx
38  * dp/dx=plist[0]*dh1/dx+plist[1]*dh2/dx+plist[2]*dh3/dx
39  *
40  * p is a vector already allocated.
41  *
42  * WARNING: For a significant gain in performance, it is better to use
43  * static memory allocation instead of dynamic.
44  */
45 
46  /*Allocate derivatives of basis functions*/
47  IssmDouble dbasis[2*NUMNODESMAX];
48 
49  /*Fetch number of nodes for this finite element*/
50  int numnodes = this->NumberofNodes(finiteelement);
51  _assert_(numnodes<=NUMNODESMAX);
52 
53  /*Get basis functions derivatives at this point*/
54  GetNodalFunctionsDerivatives(&dbasis[0],xyz_list,gauss,finiteelement);
55 
56  /*Calculate parameter for this Gauss point*/
57  IssmDouble dpx=0.;
58  IssmDouble dpy=0.;
59  for(int i=0;i<numnodes;i++) dpx += dbasis[0*numnodes+i]*plist[i];
60  for(int i=0;i<numnodes;i++) dpy += dbasis[1*numnodes+i]*plist[i];
61 
62  /*Assign values*/
63  p[0]=dpx;
64  p[1]=dpy;
65 
66 }
67 /*}}}*/
68 void TriaRef::GetInputValue(IssmDouble* p, IssmDouble* plist, Gauss* gauss,int finiteelement){/*{{{*/
69  /* WARNING: For a significant gain in performance, it is better to use
70  * static memory allocation instead of dynamic.*/
71 
72  /*Allocate basis functions*/
73  IssmDouble basis[NUMNODESMAX];
74 
75  /*Fetch number of nodes for this finite element*/
76  int numnodes = this->NumberofNodes(finiteelement);
77  _assert_(numnodes<=NUMNODESMAX);
78 
79  /*Get basis functions at this point*/
80  GetNodalFunctions(&basis[0],gauss,finiteelement);
81 
82  /*Calculate parameter for this Gauss point*/
83  IssmDouble value =0.;
84  for(int i=0;i<numnodes;i++) value += basis[i]*plist[i];
85 
86  /*Assign output pointer*/
87  *p = value;
88 }
89 /*}}}*/
90 void TriaRef::GetJacobian(IssmDouble* J, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
91  /*The Jacobian is constant over the element, discard the gaussian points.
92  * J is assumed to have been allocated of size 2x2.*/
93 
94  IssmDouble x1 = xyz_list[3*0+0];
95  IssmDouble y1 = xyz_list[3*0+1];
96  IssmDouble x2 = xyz_list[3*1+0];
97  IssmDouble y2 = xyz_list[3*1+1];
98  IssmDouble x3 = xyz_list[3*2+0];
99  IssmDouble y3 = xyz_list[3*2+1];
100 
101  J[2*0+0] = 0.5*(x2-x1);
102  J[2*1+0] = SQRT3/6.0*(2*x3-x1-x2);
103  J[2*0+1] = 0.5*(y2-y1);
104  J[2*1+1] = SQRT3/6.0*(2*y3-y1-y2);
105 }
106 /*}}}*/
107 void TriaRef::GetJacobianDeterminant(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
108  /*The Jacobian determinant is constant over the element, discard the gaussian points.
109  * J is assumed to have been allocated of size 2x2.*/
110  IssmDouble J[2][2];
111 
112  /*Get Jacobian*/
113  GetJacobian(&J[0][0],xyz_list,gauss);
114 
115  /*Get Determinant*/
116  Matrix2x2Determinant(Jdet,&J[0][0]);
117  if(*Jdet<0) _error_("negative jacobian determinant!");
118 
119 }
120 /*}}}*/
121 void TriaRef::GetJacobianDeterminant3D(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
122  /*The Jacobian determinant is constant over the element, discard the gaussian points.
123  * J is assumed to have been allocated of size 2x2.*/
124  IssmDouble J[2][2];
125 
126  /*Get Jacobian*/
127  GetJacobian(&J[0][0],xyz_list,gauss);
128 
129  /*Get Determinant*/
130  Matrix2x2Determinant(Jdet,&J[0][0]);
131 
132 }
133 /*}}}*/
134 void TriaRef::GetJacobianInvert(IssmDouble* Jinv, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
135 
136  /*Jacobian*/
137  IssmDouble J[2][2];
138 
139  /*Call Jacobian routine to get the jacobian:*/
140  GetJacobian(&J[0][0], xyz_list, gauss);
141 
142  /*Invert Jacobian matrix: */
143  Matrix2x2Invert(Jinv,&J[0][0]);
144 
145 }
146 /*}}}*/
147 void TriaRef::GetNodalFunctions(IssmDouble* basis,Gauss* gauss_in,int finiteelement){/*{{{*/
148  /*This routine returns the values of the nodal functions at the gaussian point.*/
149 
150  _assert_(basis);
151 
152  /*Cast gauss to GaussTria*/
153  _assert_(gauss_in->Enum()==GaussTriaEnum);
154  GaussTria* gauss = xDynamicCast<GaussTria*>(gauss_in);
155 
156  switch(finiteelement){
157  case NoneEnum:
158  return;
159  case P0Enum: case P0DGEnum:
160  basis[0]=1.;
161  return;
162  case P1Enum: case P1DGEnum:
163  basis[0]=gauss->coord1;
164  basis[1]=gauss->coord2;
165  basis[2]=gauss->coord3;
166  return;
167  case P1bubbleEnum: case P1bubblecondensedEnum:
168  /*Corner nodes*/
169  basis[0]=gauss->coord1;
170  basis[1]=gauss->coord2;
171  basis[2]=gauss->coord3;
172  /*bubble*/
173  basis[3]=27.*gauss->coord1*gauss->coord2*gauss->coord3;
174  return;
175  case P2Enum:
176  /*Corner nodes*/
177  basis[0]=gauss->coord1*(2.*gauss->coord1-1.);
178  basis[1]=gauss->coord2*(2.*gauss->coord2-1.);
179  basis[2]=gauss->coord3*(2.*gauss->coord3-1.);
180  /*Mid-sides*/
181  basis[3]=4.*gauss->coord3*gauss->coord2;
182  basis[4]=4.*gauss->coord3*gauss->coord1;
183  basis[5]=4.*gauss->coord1*gauss->coord2;
184  return;
185  case P2bubbleEnum: case P2bubblecondensedEnum:
186  /*Corner nodes*/
187  basis[0]=gauss->coord1*(2.*gauss->coord1-1.);
188  basis[1]=gauss->coord2*(2.*gauss->coord2-1.);
189  basis[2]=gauss->coord3*(2.*gauss->coord3-1.);
190  /*Mid-sides*/
191  basis[3]=4.*gauss->coord3*gauss->coord2;
192  basis[4]=4.*gauss->coord3*gauss->coord1;
193  basis[5]=4.*gauss->coord1*gauss->coord2;
194  /*bubble*/
195  basis[6]=27.*gauss->coord1*gauss->coord2*gauss->coord3;
196  return;
197  default:
198  _error_("Element type "<<EnumToStringx(finiteelement)<<" not supported yet");
199  }
200 }
201 /*}}}*/
202 void TriaRef::GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, Gauss* gauss,int finiteelement){/*{{{*/
203 
204  /*This routine returns the values of the nodal functions derivatives (with respect to the
205  * actual coordinate system): */
206  IssmDouble Jinv[2][2];
207 
208  /*Fetch number of nodes for this finite element*/
209  int numnodes = this->NumberofNodes(finiteelement);
210 
211  /*Get nodal functions derivatives in reference triangle*/
212  IssmDouble dbasis_ref[2*NUMNODESMAX];
213  GetNodalFunctionsDerivativesReference(dbasis_ref,gauss,finiteelement);
214 
215  /*Get Jacobian invert: */
216  GetJacobianInvert(&Jinv[0][0], xyz_list, gauss);
217 
218  /*Build dbasis:
219  * [dhi/dx]= Jinv*[dhi/dr]
220  * [dhi/dy] [dhi/ds]
221  */
222  for(int i=0;i<numnodes;i++){
223  dbasis[numnodes*0+i] = Jinv[0][0]*dbasis_ref[0*numnodes+i]+Jinv[0][1]*dbasis_ref[1*numnodes+i];
224  dbasis[numnodes*1+i] = Jinv[1][0]*dbasis_ref[0*numnodes+i]+Jinv[1][1]*dbasis_ref[1*numnodes+i];
225  }
226 
227 }
228 /*}}}*/
229 void TriaRef::GetSegmentJacobianDeterminant(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
230  /*The Jacobian determinant is constant over the element, discard the gaussian points.
231  * J is assumed to have been allocated*/
232 
233  IssmDouble x1 = xyz_list[3*0+0];
234  IssmDouble y1 = xyz_list[3*0+1];
235  IssmDouble x2 = xyz_list[3*1+0];
236  IssmDouble y2 = xyz_list[3*1+1];
237 
238  *Jdet = .5*sqrt(pow(x2-x1,2) + pow(y2-y1,2));
239  if(*Jdet<0) _error_("negative jacobian determinant!");
240 
241 }
242 /*}}}*/
243 void TriaRef::GetSegmentNodalFunctions(IssmDouble* basis,Gauss* gauss,int index1,int index2,int finiteelement){/*{{{*/
244  /*This routine returns the values of the nodal functions at the gaussian point.*/
245 
246  _assert_(index1>=0 && index1<3);
247  _assert_(index2>=0 && index2<3);
248 
249  /*Fetch number of nodes for this finite element*/
250  int numnodes = this->NumberofNodes(finiteelement);
251 
252  /*Get nodal functions*/
253  IssmDouble* triabasis=xNew<IssmDouble>(numnodes);
254  GetNodalFunctions(triabasis,gauss,finiteelement);
255 
256  switch(finiteelement){
257  case P0Enum: case P0DGEnum:
258  basis[0]=triabasis[0];
259  xDelete<IssmDouble>(triabasis);
260  return;
261  case P1Enum: case P1DGEnum:
262  basis[0]=triabasis[index1];
263  basis[1]=triabasis[index2];
264  xDelete<IssmDouble>(triabasis);
265  return;
266  case P1bubbleEnum: case P1bubblecondensedEnum:
267  basis[0]=triabasis[index1];
268  basis[1]=triabasis[index2];
269  xDelete<IssmDouble>(triabasis);
270  return;
271  case P2Enum:
272  _assert_(index2<index1);
273  basis[0]=triabasis[index1];
274  basis[1]=triabasis[index2];
275  basis[2]=triabasis[3+index2-1];
276  xDelete<IssmDouble>(triabasis);
277  return;
278  default:
279  _error_("Element type "<<EnumToStringx(finiteelement)<<" not supported yet");
280  }
281 
282  /*Clean up*/
283  xDelete<IssmDouble>(triabasis);
284 }
285 /*}}}*/
286 void TriaRef::GetSegmentNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list_tria,Gauss* gauss,int index1,int index2,int finiteelement){/*{{{*/
287  /*This routine returns the values of the nodal functions at the gaussian point.*/
288 
289  _assert_(index1>=0 && index1<3);
290  _assert_(index2>=0 && index2<3);
291 
292  /*Fetch number of nodes for this finite element*/
293  int numnodes = this->NumberofNodes(finiteelement);
294 
295  /*Get nodal functions*/
296  IssmDouble* dtriabasis=xNew<IssmDouble>(2*numnodes);
297  GetNodalFunctionsDerivatives(dtriabasis,xyz_list_tria,gauss,finiteelement);
298 
299  switch(finiteelement){
300  case P1Enum: case P1DGEnum:
301  dbasis[2*0+0] = dtriabasis[numnodes*0+index1];
302  dbasis[2*0+1] = dtriabasis[numnodes*1+index1];
303  dbasis[2*1+0] = dtriabasis[numnodes*0+index2];
304  dbasis[2*1+1] = dtriabasis[numnodes*1+index2];
305  break;
306  default:
307  _error_("Element type "<<EnumToStringx(finiteelement)<<" not supported yet");
308  }
309 
310  /*Clean up*/
311  xDelete<IssmDouble>(dtriabasis);
312 }
313 /*}}}*/
314 void TriaRef::GetNodalFunctionsDerivativesReference(IssmDouble* dbasis,Gauss* gauss_in,int finiteelement){/*{{{*/
315  /*This routine returns the values of the nodal functions derivatives (with respect to the
316  * natural coordinate system) at the gaussian point. */
317 
318  _assert_(dbasis && gauss_in);
319 
320  /*Cast gauss to GaussTria*/
321  _assert_(gauss_in->Enum()==GaussTriaEnum);
322  GaussTria* gauss = xDynamicCast<GaussTria*>(gauss_in);
323 
324  switch(finiteelement){
325  case P0Enum: case P0DGEnum:
326  /*Nodal function 1*/
327  dbasis[NUMNODESP0*0+0] = 0.;
328  dbasis[NUMNODESP0*1+0] = 0.;
329  return;
330  case P1Enum: case P1DGEnum:
331  /*Nodal function 1*/
332  dbasis[NUMNODESP1*0+0] = -0.5;
333  dbasis[NUMNODESP1*1+0] = -SQRT3/6.;
334  /*Nodal function 2*/
335  dbasis[NUMNODESP1*0+1] = 0.5;
336  dbasis[NUMNODESP1*1+1] = -SQRT3/6.;
337  /*Nodal function 3*/
338  dbasis[NUMNODESP1*0+2] = 0;
339  dbasis[NUMNODESP1*1+2] = SQRT3/3.;
340  return;
341  case P1bubbleEnum: case P1bubblecondensedEnum:
342  /*Nodal function 1*/
343  dbasis[NUMNODESP1b*0+0] = -0.5;
344  dbasis[NUMNODESP1b*1+0] = -SQRT3/6.;
345  /*Nodal function 2*/
346  dbasis[NUMNODESP1b*0+1] = 0.5;
347  dbasis[NUMNODESP1b*1+1] = -SQRT3/6.;
348  /*Nodal function 3*/
349  dbasis[NUMNODESP1b*0+2] = 0;
350  dbasis[NUMNODESP1b*1+2] = SQRT3/3.;
351  /*Nodal function 4*/
352  dbasis[NUMNODESP1b*0+3] = 27.*(-.5*gauss->coord2*gauss->coord3 + .5*gauss->coord1*gauss->coord3);
353  dbasis[NUMNODESP1b*1+3] = 27.*SQRT3*(-1./6.*gauss->coord2*gauss->coord3 - 1./6.*gauss->coord1*gauss->coord3 +1./3.*gauss->coord1*gauss->coord2);
354  return;
355  case P2Enum:
356  /*Nodal function 1*/
357  dbasis[NUMNODESP2*0+0] = -2.*gauss->coord1 + 0.5;
358  dbasis[NUMNODESP2*1+0] = -2.*SQRT3/3.*gauss->coord1 + SQRT3/6.;
359  /*Nodal function 2*/
360  dbasis[NUMNODESP2*0+1] = +2.*gauss->coord2 - 0.5;
361  dbasis[NUMNODESP2*1+1] = -2.*SQRT3/3.*gauss->coord2 + SQRT3/6.;
362  /*Nodal function 3*/
363  dbasis[NUMNODESP2*0+2] = 0.;
364  dbasis[NUMNODESP2*1+2] = +4.*SQRT3/3.*gauss->coord3 - SQRT3/3.;
365  /*Nodal function 4*/
366  dbasis[NUMNODESP2*0+3] = +2.*gauss->coord3;
367  dbasis[NUMNODESP2*1+3] = +4.*SQRT3/3.*gauss->coord2 - 2.*SQRT3/3.*gauss->coord3;
368  /*Nodal function 5*/
369  dbasis[NUMNODESP2*0+4] = -2.*gauss->coord3;
370  dbasis[NUMNODESP2*1+4] = +4.*SQRT3/3.*gauss->coord1 - 2.*SQRT3/3.*gauss->coord3;
371  /*Nodal function 6*/
372  dbasis[NUMNODESP2*0+5] = 2.*(gauss->coord1-gauss->coord2);
373  dbasis[NUMNODESP2*1+5] = -2.*SQRT3/3.*(gauss->coord1+gauss->coord2);
374  return;
375  case P2bubbleEnum: case P2bubblecondensedEnum:
376  /*Nodal function 1*/
377  dbasis[NUMNODESP2b*0+0] = -2.*gauss->coord1 + 0.5;
378  dbasis[NUMNODESP2b*1+0] = -2.*SQRT3/3.*gauss->coord1 + SQRT3/6.;
379  /*Nodal function 2*/
380  dbasis[NUMNODESP2b*0+1] = +2.*gauss->coord2 - 0.5;
381  dbasis[NUMNODESP2b*1+1] = -2.*SQRT3/3.*gauss->coord2 + SQRT3/6.;
382  /*Nodal function 3*/
383  dbasis[NUMNODESP2b*0+2] = 0.;
384  dbasis[NUMNODESP2b*1+2] = +4.*SQRT3/3.*gauss->coord3 - SQRT3/3.;
385  /*Nodal function 4*/
386  dbasis[NUMNODESP2b*0+3] = +2.*gauss->coord3;
387  dbasis[NUMNODESP2b*1+3] = +4.*SQRT3/3.*gauss->coord2 - 2.*SQRT3/3.*gauss->coord3;
388  /*Nodal function 5*/
389  dbasis[NUMNODESP2b*0+4] = -2.*gauss->coord3;
390  dbasis[NUMNODESP2b*1+4] = +4.*SQRT3/3.*gauss->coord1 - 2.*SQRT3/3.*gauss->coord3;
391  /*Nodal function 6*/
392  dbasis[NUMNODESP2b*0+5] = 2.*(gauss->coord1-gauss->coord2);
393  dbasis[NUMNODESP2b*1+5] = -2.*SQRT3/3.*(gauss->coord1+gauss->coord2);
394  /*Nodal function 7*/
395  dbasis[NUMNODESP2b*0+6] = 27.*(-.5*gauss->coord2*gauss->coord3 + .5*gauss->coord1*gauss->coord3);
396  dbasis[NUMNODESP2b*1+6] = 27.*SQRT3*(-1./6.*gauss->coord2*gauss->coord3 - 1./6.*gauss->coord1*gauss->coord3 +1./3.*gauss->coord1*gauss->coord2);
397  return;
398  default:
399  _error_("Element type "<<EnumToStringx(finiteelement)<<" not supported yet");
400  }
401 
402 }
403 /*}}}*/
404 void TriaRef::NodeOnEdgeIndices(int* pnumindices,int** pindices,int index,int finiteelement){/*{{{*/
405 
406  /*Output*/
407  int numindices;
408  int* indices = NULL;
409 
410  switch(finiteelement){
411  case P1Enum: case P1DGEnum: case P1bubbleEnum: case P1bubblecondensedEnum:
412  numindices = 2;
413  indices = xNew<int>(numindices);
414  switch(index){
415  case 0:
416  indices[0] = 1;
417  indices[1] = 2;
418  break;
419  case 1:
420  indices[0] = 2;
421  indices[1] = 0;
422  break;
423  case 2:
424  indices[0] = 0;
425  indices[1] = 1;
426  break;
427  default:
428  _error_("Edge index provided ("<<index<<") is not between 0 and 2");
429  }
430  break;
431  case P2Enum:
432  numindices = 3;
433  indices = xNew<int>(numindices);
434  switch(index){
435  case 0:
436  indices[0] = 1;
437  indices[1] = 2;
438  indices[2] = 3;
439  break;
440  case 1:
441  indices[0] = 2;
442  indices[1] = 0;
443  indices[2] = 4;
444  break;
445  case 2:
446  indices[0] = 0;
447  indices[1] = 1;
448  indices[2] = 5;
449  break;
450  default:
451  _error_("Edge index provided ("<<index<<") is not between 0 and 2");
452  }
453  break;
454  default:
455  _error_("Element type "<<EnumToStringx(finiteelement)<<" not supported yet");
456  }
457 
458  /*Assign output pointer*/
459  *pnumindices = numindices;
460  *pindices = indices;
461 }
462 /*}}}*/
463 int TriaRef::NumberofNodes(int finiteelement){/*{{{*/
464 
465  switch(finiteelement){
466  case NoneEnum: return 0;
467  case P0Enum: return NUMNODESP0;
468  case P0DGEnum: return NUMNODESP0;
469  case P1Enum: return NUMNODESP1;
470  case P1DGEnum: return NUMNODESP1;
471  case P1bubbleEnum: return NUMNODESP1b;
472  case P1bubblecondensedEnum: return NUMNODESP1b;
473  case P2Enum: return NUMNODESP2;
474  case P2bubbleEnum: return NUMNODESP2b;
475  case P2bubblecondensedEnum: return NUMNODESP2b;
476  case P1P1Enum: return NUMNODESP1*2;
477  case P1P1GLSEnum: return NUMNODESP1*2;
478  case MINIcondensedEnum: return NUMNODESP1b+NUMNODESP1;
479  case MINIEnum: return NUMNODESP1b+NUMNODESP1;
480  case TaylorHoodEnum: return NUMNODESP2+NUMNODESP1;
481  case LATaylorHoodEnum: return NUMNODESP2;
482  case XTaylorHoodEnum: return NUMNODESP2+NUMNODESP1;
483  case CrouzeixRaviartEnum: return NUMNODESP2b+NUMNODESP1;
484  case LACrouzeixRaviartEnum: return NUMNODESP2b;
485  default: _error_("Element type "<<EnumToStringx(finiteelement)<<" not supported yet");
486  }
487 
488  return -1;
489 }
490 /*}}}*/
491 int TriaRef::PressureInterpolation(int fe_stokes){/*{{{*/
492 
493  switch(fe_stokes){
494  case P1P1Enum: return P1Enum;
495  case P1P1GLSEnum: return P1Enum;
496  case MINIcondensedEnum: return P1Enum;
497  case MINIEnum: return P1Enum;
498  case TaylorHoodEnum: return P1Enum;
499  case LATaylorHoodEnum: return NoneEnum;
500  case XTaylorHoodEnum: return P1Enum;
501  case CrouzeixRaviartEnum: return P1DGEnum;
502  case LACrouzeixRaviartEnum: return NoneEnum;
503  default: _error_("Element type "<<EnumToStringx(fe_stokes)<<" not supported yet");
504  }
505 
506  return -1;
507 }
508 /*}}}*/
509 int TriaRef::TensorInterpolation(int fe_stokes){/*{{{*/
510  /*This routine returns the values of the nodal functions at the gaussian point.*/
511 
512  switch(fe_stokes){
513  case XTaylorHoodEnum: return P1DGEnum;
514  default: _error_("Element type "<<EnumToStringx(fe_stokes)<<" not supported yet");
515  }
516 }
517 /*}}}*/
518 int TriaRef::VelocityInterpolation(int fe_stokes){/*{{{*/
519 
520  switch(fe_stokes){
521  case P1P1Enum: return P1Enum;
522  case P1P1GLSEnum: return P1Enum;
523  case MINIcondensedEnum: return P1bubbleEnum;
524  case MINIEnum: return P1bubbleEnum;
525  case TaylorHoodEnum: return P2Enum;
526  case LATaylorHoodEnum: return P2Enum;
527  case XTaylorHoodEnum: return P2Enum;
528  case CrouzeixRaviartEnum: return P2bubbleEnum;
529  case LACrouzeixRaviartEnum: return P2bubbleEnum;
530  default: _error_("Element type "<<EnumToStringx(fe_stokes)<<" not supported yet");
531  }
532 
533  return -1;
534 }
535 /*}}}*/
CrouzeixRaviartEnum
@ CrouzeixRaviartEnum
Definition: EnumDefinitions.h:1023
TriaRef::GetJacobianDeterminant
void GetJacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:107
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
TriaRef::GetJacobianInvert
void GetJacobianInvert(IssmDouble *Jinv, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:134
TriaRef::GetSegmentJacobianDeterminant
void GetSegmentJacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:229
TriaRef::GetJacobianDeterminant3D
void GetJacobianDeterminant3D(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:121
MINIEnum
@ MINIEnum
Definition: EnumDefinitions.h:1156
P0Enum
@ P0Enum
Definition: EnumDefinitions.h:661
Matrix2x2Invert
void Matrix2x2Invert(IssmDouble *Ainv, IssmDouble *A)
Definition: MatrixUtils.cpp:329
GaussTria::coord1
IssmDouble coord1
Definition: GaussTria.h:22
NUMNODESP2
#define NUMNODESP2
Definition: TriaRef.cpp:21
P1DGEnum
@ P1DGEnum
Definition: EnumDefinitions.h:1215
TriaRef::TriaRef
TriaRef()
Definition: TriaRef.cpp:26
P1bubblecondensedEnum
@ P1bubblecondensedEnum
Definition: EnumDefinitions.h:1219
GaussTria::coord3
IssmDouble coord3
Definition: GaussTria.h:24
TriaRef::GetSegmentNodalFunctions
void GetSegmentNodalFunctions(IssmDouble *basis, Gauss *gauss, int index1, int index2, int finiteelement)
Definition: TriaRef.cpp:243
TriaRef::~TriaRef
~TriaRef()
Definition: TriaRef.cpp:29
TriaRef::VelocityInterpolation
int VelocityInterpolation(int fe_stokes)
Definition: TriaRef.cpp:518
NUMNODESP1
#define NUMNODESP1
Definition: TriaRef.cpp:19
P0DGEnum
@ P0DGEnum
Definition: EnumDefinitions.h:1214
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
Matrix2x2Determinant
void Matrix2x2Determinant(IssmDouble *Adet, IssmDouble *A)
Definition: MatrixUtils.cpp:322
TaylorHoodEnum
@ TaylorHoodEnum
Definition: EnumDefinitions.h:1299
GaussTria
Definition: GaussTria.h:12
TriaRef::PressureInterpolation
int PressureInterpolation(int fe_stokes)
Definition: TriaRef.cpp:491
LATaylorHoodEnum
@ LATaylorHoodEnum
Definition: EnumDefinitions.h:1139
NUMNODESMAX
#define NUMNODESMAX
Definition: TriaRef.cpp:23
GaussTria::coord2
IssmDouble coord2
Definition: GaussTria.h:23
TriaRef::GetNodalFunctions
void GetNodalFunctions(IssmDouble *basis, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:147
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
P2bubbleEnum
@ P2bubbleEnum
Definition: EnumDefinitions.h:1224
TriaRef::GetNodalFunctionsDerivativesReference
void GetNodalFunctionsDerivativesReference(IssmDouble *dbasis, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:314
P1P1Enum
@ P1P1Enum
Definition: EnumDefinitions.h:1216
MINIcondensedEnum
@ MINIcondensedEnum
Definition: EnumDefinitions.h:1157
Gauss::Enum
virtual int Enum(void)=0
TriaRef::GetInputDerivativeValue
void GetInputDerivativeValue(IssmDouble *pp, IssmDouble *plist, IssmDouble *xyz_list, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:34
TriaRef::NodeOnEdgeIndices
void NodeOnEdgeIndices(int *pnumindices, int **pindices, int index, int finiteelement)
Definition: TriaRef.cpp:404
P1bubbleEnum
@ P1bubbleEnum
Definition: EnumDefinitions.h:1218
TriaRef::GetNodalFunctionsDerivatives
void GetNodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:202
TriaRef::TensorInterpolation
int TensorInterpolation(int fe_stokes)
Definition: TriaRef.cpp:509
LACrouzeixRaviartEnum
@ LACrouzeixRaviartEnum
Definition: EnumDefinitions.h:1138
NoneEnum
@ NoneEnum
Definition: EnumDefinitions.h:1202
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
NUMNODESP2b
#define NUMNODESP2b
Definition: TriaRef.cpp:22
P2bubblecondensedEnum
@ P2bubblecondensedEnum
Definition: EnumDefinitions.h:1225
TriaRef::GetSegmentNodalFunctionsDerivatives
void GetSegmentNodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list_tria, Gauss *gauss, int index1, int index2, int finiteelement)
Definition: TriaRef.cpp:286
TriaRef::GetInputValue
void GetInputValue(IssmDouble *pp, IssmDouble *plist, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:68
GaussTriaEnum
@ GaussTriaEnum
Definition: EnumDefinitions.h:1081
TriaRef::NumberofNodes
int NumberofNodes(int finiteelement)
Definition: TriaRef.cpp:463
P2Enum
@ P2Enum
Definition: EnumDefinitions.h:1223
NUMNODESP0
#define NUMNODESP0
Definition: TriaRef.cpp:18
P1P1GLSEnum
@ P1P1GLSEnum
Definition: EnumDefinitions.h:1217
TriaRef::GetJacobian
void GetJacobian(IssmDouble *J, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:90
SQRT3
#define SQRT3
Definition: constants.h:10
Gauss
Definition: Gauss.h:8
XTaylorHoodEnum
@ XTaylorHoodEnum
Definition: EnumDefinitions.h:1329
NUMNODESP1b
#define NUMNODESP1b
Definition: TriaRef.cpp:20
Generated on Thu Jul 2 2020 08:09:17 for Ice Sheet System Model by   doxygen 1.8.19