source: issm/oecreview/Archive/16554-17801/ISSM-16839-16840.diff@ 17802

Last change on this file since 17802 was 17802, checked in by Mathieu Morlighem, 11 years ago

Added archives
File size: 18.4 KB
RevLine 
[17802]1Index: ../trunk-jpl/src/c/analyses/ThermalAnalysis.h
2===================================================================
3--- ../trunk-jpl/src/c/analyses/ThermalAnalysis.h (revision 16839)
4+++ ../trunk-jpl/src/c/analyses/ThermalAnalysis.h (revision 16840)
5@@ -21,10 +21,15 @@
6
7 /*Finite element Analysis*/
8 ElementMatrix* CreateKMatrix(Element* element);
9+ ElementMatrix* CreateKMatrixVolume(Element* element);
10+ ElementMatrix* CreateKMatrixShelf(Element* element);
11 ElementVector* CreatePVector(Element* element);
12 ElementVector* CreatePVectorVolume(Element* element);
13 ElementVector* CreatePVectorSheet(Element* element);
14 ElementVector* CreatePVectorShelf(Element* element);
15+ void GetBConduct(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss);
16+ void GetBAdvec(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss);
17+ void GetBAdvecprime(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss);
18 void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
19 void InputUpdateFromSolution(IssmDouble* solution,Element* element);
20 };
21Index: ../trunk-jpl/src/c/analyses/ThermalAnalysis.cpp
22===================================================================
23--- ../trunk-jpl/src/c/analyses/ThermalAnalysis.cpp (revision 16839)
24+++ ../trunk-jpl/src/c/analyses/ThermalAnalysis.cpp (revision 16840)
25@@ -112,8 +112,191 @@
26
27 /*Finite Element Analysis*/
28 ElementMatrix* ThermalAnalysis::CreateKMatrix(Element* element){/*{{{*/
29- _error_("not implemented yet");
30+
31+ /*compute all stiffness matrices for this element*/
32+ ElementMatrix* Ke1=CreateKMatrixVolume(element);
33+ ElementMatrix* Ke2=CreateKMatrixShelf(element);
34+ ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
35+
36+ /*clean-up and return*/
37+ delete Ke1;
38+ delete Ke2;
39+ return Ke;
40 }/*}}}*/
41+ElementMatrix* ThermalAnalysis::CreateKMatrixVolume(Element* element){/*{{{*/
42+
43+ /*Intermediaries */
44+ int stabilization;
45+ IssmDouble Jdet,dt,u,v,w,um,vm,wm,vel;
46+ IssmDouble h,hx,hy,hz,vx,vy,vz;
47+ IssmDouble tau_parameter,diameter;
48+ IssmDouble D_scalar;
49+ IssmDouble* xyz_list = NULL;
50+
51+ /*Fetch number of nodes and dof for this finite element*/
52+ int numnodes = element->GetNumberOfNodes();
53+
54+ /*Initialize Element vector and other vectors*/
55+ ElementMatrix* Ke = element->NewElementMatrix();
56+ IssmDouble* basis = xNew<IssmDouble>(numnodes);
57+ IssmDouble* dbasis = xNew<IssmDouble>(3*numnodes);
58+ IssmDouble* B = xNew<IssmDouble>(3*numnodes);
59+ IssmDouble* Bprime = xNew<IssmDouble>(3*numnodes);
60+ IssmDouble D[3][3]={0.};
61+ IssmDouble K[3][3];
62+
63+ /*Retrieve all inputs and parameters*/
64+ element->GetVerticesCoordinates(&xyz_list);
65+ element->FindParam(&dt,TimesteppingTimeStepEnum);
66+ element->FindParam(&stabilization,ThermalStabilizationEnum);
67+ IssmDouble rho_water = element->GetMaterialParameter(MaterialsRhoWaterEnum);
68+ IssmDouble rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum);
69+ IssmDouble gravity = element->GetMaterialParameter(ConstantsGEnum);
70+ IssmDouble heatcapacity = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
71+ IssmDouble thermalconductivity = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
72+ IssmDouble kappa = thermalconductivity/(rho_ice*heatcapacity);
73+ Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
74+ Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
75+ Input* vz_input = element->GetInput(VzEnum); _assert_(vz_input);
76+ Input* vxm_input = element->GetInput(VxMeshEnum); _assert_(vxm_input);
77+ Input* vym_input = element->GetInput(VyMeshEnum); _assert_(vym_input);
78+ Input* vzm_input = element->GetInput(VzMeshEnum); _assert_(vzm_input);
79+ if(stabilization==2) diameter=element->MinEdgeLength(xyz_list);
80+
81+ /* Start looping on the number of gaussian points: */
82+ Gauss* gauss=element->NewGauss(2);
83+ for(int ig=gauss->begin();ig<gauss->end();ig++){
84+ gauss->GaussPoint(ig);
85+
86+ element->JacobianDeterminant(&Jdet,xyz_list,gauss);
87+ D_scalar=gauss->weight*Jdet*kappa;
88+ if(dt!=0.) D_scalar=D_scalar*dt;
89+
90+ /*Conduction: */
91+ GetBConduct(B,element,xyz_list,gauss);
92+ D[0][0]=D_scalar;
93+ D[1][1]=D_scalar;
94+ D[2][2]=D_scalar;
95+ TripleMultiply(B,3,numnodes,1,
96+ &D[0][0],3,3,0,
97+ B,3,numnodes,0,
98+ &Ke->values[0],1);
99+
100+ /*Advection: */
101+ GetBAdvec(B,element,xyz_list,gauss);
102+ GetBAdvecprime(Bprime,element,xyz_list,gauss);
103+ vx_input->GetInputValue(&u,gauss); vxm_input->GetInputValue(&um,gauss); vx=u-um;
104+ vy_input->GetInputValue(&v,gauss); vym_input->GetInputValue(&vm,gauss); vy=v-vm;
105+ vz_input->GetInputValue(&w,gauss); vzm_input->GetInputValue(&wm,gauss); vz=w-wm;
106+ D[0][0]=D_scalar*vx;
107+ D[1][1]=D_scalar*vy;
108+ D[2][2]=D_scalar*vz;
109+ TripleMultiply(B,3,numnodes,1,
110+ &D[0][0],3,3,0,
111+ Bprime,3,numnodes,0,
112+ &Ke->values[0],1);
113+
114+ /*Transient: */
115+ if(dt!=0.){
116+ element->NodalFunctions(basis,gauss);
117+
118+ TripleMultiply(basis,numnodes,1,0,
119+ &D_scalar,1,1,0,
120+ basis,1,numnodes,0,
121+ &Ke->values[0],1);
122+ }
123+
124+ /*Artifficial diffusivity*/
125+ if(stabilization==1){
126+ element->ElementSizes(&hx,&hy,&hz);
127+ vel=sqrt(vx*vx + vy*vy + vz*vz)+1.e-14;
128+ h=sqrt( pow(hx*vx/vel,2) + pow(hy*vy/vel,2) + pow(hz*vz/vel,2));
129+ K[0][0]=h/(2.*vel)*fabs(vx*vx); K[0][1]=h/(2.*vel)*fabs(vx*vy); K[0][2]=h/(2.*vel)*fabs(vx*vz);
130+ K[1][0]=h/(2.*vel)*fabs(vy*vx); K[1][1]=h/(2.*vel)*fabs(vy*vy); K[1][2]=h/(2.*vel)*fabs(vy*vz);
131+ K[2][0]=h/(2.*vel)*fabs(vz*vx); K[2][1]=h/(2.*vel)*fabs(vz*vy); K[2][2]=h/(2.*vel)*fabs(vz*vz);
132+ for(int i=0;i<3;i++) for(int j=0;j<3;j++) K[i][j] = D_scalar*K[i][j];
133+
134+ GetBAdvecprime(Bprime,element,xyz_list,gauss);
135+
136+ TripleMultiply(Bprime,3,numnodes,1,
137+ &K[0][0],3,3,0,
138+ Bprime,3,numnodes,0,
139+ &Ke->values[0],1);
140+ }
141+ else if(stabilization==2){
142+ element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
143+ tau_parameter=element->StabilizationParameter(u-um,v-vm,w-wm,diameter,kappa);
144+ for(int i=0;i<numnodes;i++){
145+ for(int j=0;j<numnodes;j++){
146+ Ke->values[i*numnodes+j]+=tau_parameter*D_scalar*
147+ ((u-um)*dbasis[0*3+i]+(v-vm)*dbasis[1*3+i]+(w-wm)*dbasis[2*3+i])*((u-um)*dbasis[0*3+j]+(v-vm)*dbasis[1*3+j]+(w-wm)*dbasis[2*3+j]);
148+ }
149+ }
150+ if(dt!=0.){
151+ for(int i=0;i<numnodes;i++){
152+ for(int j=0;j<numnodes;j++){
153+ Ke->values[i*numnodes+j]+=tau_parameter*D_scalar*basis[j]*((u-um)*dbasis[0*3+i]+(v-vm)*dbasis[1*3+i]+(w-wm)*dbasis[2*3+i]);
154+ }
155+ }
156+ }
157+ }
158+ }
159+
160+ /*Clean up and return*/
161+ delete gauss;
162+ return Ke;
163+}/*}}}*/
164+ElementMatrix* ThermalAnalysis::CreateKMatrixShelf(Element* element){/*{{{*/
165+
166+ /*Initialize Element matrix and return if necessary*/
167+ if(!element->IsOnBed() || !element->IsFloating()) return NULL;
168+
169+ IssmDouble dt,Jdet,D;
170+ IssmDouble *xyz_list_base = NULL;
171+
172+ /*Get basal element*/
173+ if(!element->IsOnBed() || !element->IsFloating()) return NULL;
174+
175+ /*Fetch number of nodes for this finite element*/
176+ int numnodes = element->GetNumberOfNodes();
177+
178+ /*Initialize vectors*/
179+ ElementMatrix* Ke = element->NewElementMatrix();
180+ IssmDouble* basis = xNew<IssmDouble>(numnodes);
181+
182+ /*Retrieve all inputs and parameters*/
183+ element->GetVerticesCoordinatesBase(&xyz_list_base);
184+ element->FindParam(&dt,TimesteppingTimeStepEnum);
185+ IssmDouble gravity = element->GetMaterialParameter(ConstantsGEnum);
186+ IssmDouble rho_water = element->GetMaterialParameter(MaterialsRhoWaterEnum);
187+ IssmDouble rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum);
188+ IssmDouble heatcapacity = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
189+ IssmDouble mixed_layer_capacity= element->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
190+ IssmDouble thermal_exchange_vel= element->GetMaterialParameter(MaterialsThermalExchangeVelocityEnum);
191+
192+ /* Start looping on the number of gaussian points: */
193+ Gauss* gauss=element->NewGaussBase(2);
194+ for(int ig=gauss->begin();ig<gauss->end();ig++){
195+ gauss->GaussPoint(ig);
196+
197+ element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
198+ element->NodalFunctions(basis,gauss);
199+
200+ D=gauss->weight*Jdet*rho_water*mixed_layer_capacity*thermal_exchange_vel/(heatcapacity*rho_ice);
201+ if(reCast<bool,IssmDouble>(dt)) D=dt*D;
202+ TripleMultiply(basis,numnodes,1,0,
203+ &D,1,1,0,
204+ basis,1,numnodes,0,
205+ &Ke->values[0],1);
206+
207+ }
208+
209+ /*Clean up and return*/
210+ delete gauss;
211+ xDelete<IssmDouble>(basis);
212+ xDelete<IssmDouble>(xyz_list_base);
213+ return Ke;
214+}/*}}}*/
215 ElementVector* ThermalAnalysis::CreatePVector(Element* element){/*{{{*/
216
217 /*compute all load vectors for this element*/
218@@ -262,6 +445,93 @@
219 void ThermalAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
220 element->GetSolutionFromInputsOneDof(solution,TemperatureEnum);
221 }/*}}}*/
222+void ThermalAnalysis::GetBConduct(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
223+ /*Compute B matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 5*NDOF1.
224+ * For node i, Bi' can be expressed in the actual coordinate system
225+ * by:
226+ * Bi_conduct=[ dh/dx ]
227+ * [ dh/dy ]
228+ * [ dh/dz ]
229+ * where h is the interpolation function for node i.
230+ *
231+ * We assume B has been allocated already, of size: 3x(NDOF1*numnodes)
232+ */
233+
234+ /*Fetch number of nodes for this finite element*/
235+ int numnodes = element->GetNumberOfNodes();
236+
237+ /*Get nodal functions derivatives*/
238+ IssmDouble* dbasis=xNew<IssmDouble>(3*numnodes);
239+ element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
240+
241+ /*Build B: */
242+ for(int i=0;i<numnodes;i++){
243+ B[numnodes*0+i] = dbasis[0*numnodes+i];
244+ B[numnodes*1+i] = dbasis[1*numnodes+i];
245+ B[numnodes*2+i] = dbasis[2*numnodes+i];
246+ }
247+
248+ /*Clean-up*/
249+ xDelete<IssmDouble>(dbasis);
250+}/*}}}*/
251+void ThermalAnalysis::GetBAdvec(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
252+ /*Compute B matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 5*NDOF1.
253+ * For node i, Bi' can be expressed in the actual coordinate system
254+ * by:
255+ * Bi_advec =[ h ]
256+ * [ h ]
257+ * [ h ]
258+ * where h is the interpolation function for node i.
259+ *
260+ * We assume B has been allocated already, of size: 3x(NDOF1*NUMNODESP1)
261+ */
262+
263+ /*Fetch number of nodes for this finite element*/
264+ int numnodes = element->GetNumberOfNodes();
265+
266+ /*Get nodal functions*/
267+ IssmDouble* basis=xNew<IssmDouble>(numnodes);
268+ element->NodalFunctions(basis,gauss);
269+
270+ /*Build B: */
271+ for(int i=0;i<numnodes;i++){
272+ B[numnodes*0+i] = basis[i];
273+ B[numnodes*1+i] = basis[i];
274+ B[numnodes*2+i] = basis[i];
275+ }
276+
277+ /*Clean-up*/
278+ xDelete<IssmDouble>(basis);
279+}/*}}}*/
280+void ThermalAnalysis::GetBAdvecprime(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
281+ /*Compute B matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 5*NDOF1.
282+ * For node i, Bi' can be expressed in the actual coordinate system
283+ * by:
284+ * Biprime_advec=[ dh/dx ]
285+ * [ dh/dy ]
286+ * [ dh/dz ]
287+ * where h is the interpolation function for node i.
288+ *
289+ * We assume B has been allocated already, of size: 3x(NDOF1*numnodes)
290+ */
291+
292+ /*Fetch number of nodes for this finite element*/
293+ int numnodes = element->GetNumberOfNodes();
294+
295+ /*Get nodal functions derivatives*/
296+ IssmDouble* dbasis=xNew<IssmDouble>(3*numnodes);
297+ element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
298+
299+ /*Build B: */
300+ for(int i=0;i<numnodes;i++){
301+ B[numnodes*0+i] = dbasis[0*numnodes+i];
302+ B[numnodes*1+i] = dbasis[1*numnodes+i];
303+ B[numnodes*2+i] = dbasis[2*numnodes+i];
304+ }
305+
306+ /*Clean-up*/
307+ xDelete<IssmDouble>(dbasis);
308+}/*}}}*/
309 void ThermalAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
310
311 bool converged;
312Index: ../trunk-jpl/src/c/analyses/MeltingAnalysis.cpp
313===================================================================
314--- ../trunk-jpl/src/c/analyses/MeltingAnalysis.cpp (revision 16839)
315+++ ../trunk-jpl/src/c/analyses/MeltingAnalysis.cpp (revision 16840)
316@@ -72,7 +72,48 @@
317
318 /*Finite Element Analysis*/
319 ElementMatrix* MeltingAnalysis::CreateKMatrix(Element* element){/*{{{*/
320- _error_("not implemented yet");
321+
322+ /*Get basal element*/
323+ if(!element->IsOnBed()) return NULL;
324+ Element* basalelement = element->SpawnBasalElement();
325+
326+ /*Intermediaries */
327+ IssmDouble D,Jdet;
328+ IssmDouble *xyz_list = NULL;
329+
330+ /*Fetch number of nodes and dof for this finite element*/
331+ int numnodes = basalelement->GetNumberOfNodes();
332+
333+ /*Initialize Element vector*/
334+ ElementMatrix* Ke = basalelement->NewElementMatrix(NoneApproximationEnum);
335+ IssmDouble* basis = xNew<IssmDouble>(numnodes);
336+
337+ /*Retrieve all inputs and parameters*/
338+ basalelement->GetVerticesCoordinates(&xyz_list);
339+ IssmDouble latentheat = element->GetMaterialParameter(MaterialsLatentheatEnum);
340+ IssmDouble heatcapacity = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
341+
342+ /* Start looping on the number of gaussian points: */
343+ Gauss* gauss=basalelement->NewGauss(2);
344+ for(int ig=gauss->begin();ig<gauss->end();ig++){
345+ gauss->GaussPoint(ig);
346+
347+ basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
348+ basalelement->NodalFunctions(basis,gauss);
349+ D=latentheat/heatcapacity*gauss->weight*Jdet;
350+
351+ TripleMultiply(basis,1,numnodes,1,
352+ &D,1,1,0,
353+ basis,1,numnodes,0,
354+ &Ke->values[0],1);
355+ }
356+
357+ /*Clean up and return*/
358+ xDelete<IssmDouble>(xyz_list);
359+ xDelete<IssmDouble>(basis);
360+ delete gauss;
361+ basalelement->DeleteMaterials(); delete basalelement;
362+ return Ke;
363 }/*}}}*/
364 ElementVector* MeltingAnalysis::CreatePVector(Element* element){/*{{{*/
365 return NULL;
366Index: ../trunk-jpl/src/c/classes/Elements/Element.h
367===================================================================
368--- ../trunk-jpl/src/c/classes/Elements/Element.h (revision 16839)
369+++ ../trunk-jpl/src/c/classes/Elements/Element.h (revision 16840)
370@@ -48,6 +48,7 @@
371 virtual ElementVector* CreatePVector(void)=0;
372 virtual void CreateJacobianMatrix(Matrix<IssmDouble>* Jff)=0;
373 virtual void DeleteMaterials(void)=0;
374+ virtual void ElementSizes(IssmDouble* phx,IssmDouble* phy,IssmDouble* phz)=0;
375 virtual void EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure)=0;
376 virtual IssmDouble EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure)=0;
377 virtual IssmDouble EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure)=0;
378Index: ../trunk-jpl/src/c/classes/Elements/Tria.h
379===================================================================
380--- ../trunk-jpl/src/c/classes/Elements/Tria.h (revision 16839)
381+++ ../trunk-jpl/src/c/classes/Elements/Tria.h (revision 16840)
382@@ -78,6 +78,7 @@
383 void CreateJacobianMatrix(Matrix<IssmDouble>* Jff);
384 void DeleteMaterials(void);
385 void Delta18oParameterization(void);
386+ void ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){_error_("not implemented yet");};
387 void EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){_error_("not implemented yet");};
388 void FindParam(int* pvalue,int paramenum);
389 void FindParam(IssmDouble* pvalue,int paramenum);
390Index: ../trunk-jpl/src/c/classes/Elements/Penta.cpp
391===================================================================
392--- ../trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 16839)
393+++ ../trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 16840)
394@@ -1209,8 +1209,8 @@
395 return this->element_type;
396 }
397 /*}}}*/
398-/*FUNCTION Penta::GetElementSizes{{{*/
399-void Penta::GetElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){
400+/*FUNCTION Penta::ElementSizes{{{*/
401+void Penta::ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){
402
403 IssmDouble xyz_list[NUMVERTICES][3];
404 IssmDouble xmin,ymin,zmin;
405@@ -3980,7 +3980,7 @@
406 /*Artificial diffusivity*/
407 if(stabilization==1){
408 /*Build K: */
409- GetElementSizes(&hx,&hy,&hz);
410+ ElementSizes(&hx,&hy,&hz);
411 vel=sqrt(vx*vx + vy*vy + vz*vz)+1.e-14;
412 h=sqrt( pow(hx*vx/vel,2) + pow(hy*vy/vel,2) + pow(hz*vz/vel,2));
413
414@@ -4209,7 +4209,7 @@
415 /*Artifficial diffusivity*/
416 if(stabilization==1){
417 /*Build K: */
418- GetElementSizes(&hx,&hy,&hz);
419+ ElementSizes(&hx,&hy,&hz);
420 vel=sqrt(vx*vx + vy*vy + vz*vz)+1.e-14;
421 h=sqrt( pow(hx*vx/vel,2) + pow(hy*vy/vel,2) + pow(hz*vz/vel,2));
422
423Index: ../trunk-jpl/src/c/classes/Elements/Penta.h
424===================================================================
425--- ../trunk-jpl/src/c/classes/Elements/Penta.h (revision 16839)
426+++ ../trunk-jpl/src/c/classes/Elements/Penta.h (revision 16840)
427@@ -74,6 +74,7 @@
428 void ComputeStressTensor();
429 void Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
430 void DeleteMaterials(void){_error_("not implemented yet");};
431+ void ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);
432 void FindParam(int* pvalue,int paramenum);
433 void FindParam(IssmDouble* pvalue,int paramenum);
434 int FiniteElement(void);
435@@ -220,7 +221,6 @@
436 void GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating);
437 IssmDouble GetGroundedPortion(IssmDouble* xyz_list);
438 int GetElementType(void);
439- void GetElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);
440 Input* GetInput(int inputenum);
441 void GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
442 void GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
443Index: ../trunk-jpl/src/c/classes/Elements/Seg.h
444===================================================================
445--- ../trunk-jpl/src/c/classes/Elements/Seg.h (revision 16839)
446+++ ../trunk-jpl/src/c/classes/Elements/Seg.h (revision 16840)
447@@ -83,6 +83,7 @@
448 ElementVector* CreatePVectorL2Projection(void);
449 void CreateJacobianMatrix(Matrix<IssmDouble>* Jff){_error_("not implemented yet");};
450 void Delta18oParameterization(void){_error_("not implemented yet");};
451+ void ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){_error_("not implemented yet");};
452 void EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){_error_("not implemented yet");};
453 IssmDouble EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){_error_("not implemented");};
454 IssmDouble EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){_error_("not implemented");};
Note: See TracBrowser for help on using the repository browser.