Ice Sheet System Model  4.18
Code documentation
Tria.cpp
Go to the documentation of this file.
1 
4 /*Headers:*/
5 /*{{{*/
6 #ifdef HAVE_CONFIG_H
7  #include <config.h>
8 #else
9 #error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
10 #endif
11 
12 #include <stdio.h>
13 #include <string.h>
14 #include <math.h>
15 //#include <gsl_cblas.h>
16 #include "../classes.h"
17 #include "../Inputs2/TriaInput2.h"
18 #include "../Inputs2/PentaInput2.h"
19 #include "../Inputs2/ControlInput2.h"
20 #include "../Inputs2/DatasetInput2.h"
21 #include "../Inputs2/TransientInput2.h"
22 #include "../../shared/shared.h"
23 #ifdef _HAVE_GIA_
24 #include "../../modules/GiaDeflectionCorex/GiaDeflectionCorex.h"
25 #endif
26 /*}}}*/
27 
28 /*Element macros*/
29 #define NUMVERTICES 3
30 #define NUMVERTICES1D 2
31 
32 /*Constructors/destructor/copy*/
33 Tria::Tria(int tria_id,int tria_sid,int tria_lid,IoModel* iomodel,int nummodels)/*{{{*/
34  :ElementHook(nummodels,tria_id,NUMVERTICES,iomodel){
35 
36  this->iscollapsed = 0;
37 
38  /*id: */
39  this->id = tria_id;
40  this->sid = tria_sid;
41  this->lid = tria_lid;
42 
43  /*this->parameters: we still can't point to it, it may not even exist. Configure will handle this.*/
44  this->parameters = NULL;
45 
46  /*initialize pointers:*/
47  this->nodes = NULL;
48  this->vertices = NULL;
49  this->material = NULL;
50  if(nummodels>0){
51  this->element_type_list=xNew<int>(nummodels);
52  for(int i=0;i<nummodels;i++) this->element_type_list[i] = 0;
53  }
54  else this->element_type_list = NULL;
55 
56  /*surface and base*/
57  IssmDouble sum;
58  this->isonsurface = false;
59  this->isonbase = false;
60  switch(iomodel->domaintype){
61  case Domain2DverticalEnum:
62  _assert_(iomodel->Data("md.mesh.vertexonsurface"));
63  _assert_(iomodel->Data("md.mesh.vertexonbase"));
64  sum = 0.;
65  for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonsurface")[reCast<int>(iomodel->elements[(tria_id-1)*NUMVERTICES+i])-1];
66  _assert_(sum>=0 && sum<3);
67  if(sum>1.) this->isonsurface = true;
68  sum = 0.;
69  for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonbase")[reCast<int>(iomodel->elements[(tria_id-1)*NUMVERTICES+i])-1];
70  _assert_(sum>=0 && sum<3);
71  if(sum>1.) this->isonbase = true;
72  break;
73  case Domain2DhorizontalEnum:
74  case Domain3DsurfaceEnum:
75  this->isonsurface = true;
76  this->isonbase = true;
77  break;
78  default: _error_("mesh "<<EnumToStringx(iomodel->domaintype)<<" not supported yet");
79  }
80 
81 }/*}}}*/
82 Tria::~Tria(){/*{{{*/
83  this->parameters=NULL;
84 }
85 /*}}}*/
86 Object* Tria::copy() {/*{{{*/
87 
88  int i;
89  Tria* tria=NULL;
90 
91  tria=new Tria();
92 
93  tria->iscollapsed=this->iscollapsed;
94 
95  //deal with TriaRef mother class
96  int nanalyses = this->numanalyses;
97  if(nanalyses > 0){
98  tria->element_type_list=xNew<int>(nanalyses);
99  for(i=0;i<nanalyses;i++){
100  if (this->element_type_list[i]) tria->element_type_list[i]=this->element_type_list[i];
101  else tria->element_type_list[i] = 0;
102  }
103  }
104  else tria->element_type_list = NULL;
105  tria->element_type=this->element_type;
106  tria->numanalyses=nanalyses;
107 
108  //deal with ElementHook mother class
109  if (this->hnodes){
110  tria->hnodes=xNew<Hook*>(tria->numanalyses);
111  for(i=0;i<tria->numanalyses;i++){
112  if (this->hnodes[i]) tria->hnodes[i] = (Hook*)(this->hnodes[i]->copy());
113  else tria->hnodes[i] = NULL;
114  }
115  }
116  else tria->hnodes = NULL;
117 
118  tria->hvertices = (Hook*)this->hvertices->copy();
119  if(this->hmaterial)tria->hmaterial = (Hook*)this->hmaterial->copy();
120  tria->hneighbors = NULL;
121 
122  /*deal with Tria fields: */
123  tria->id = this->id;
124  tria->sid = this->sid;
125  tria->lid = this->lid;
126  tria->isonbase = this->isonbase;
127  tria->isonsurface = this->isonsurface;
128 
129  /*point parameters: */
130  tria->parameters=this->parameters;
131 
132  /*recover objects: */
133  if (this->nodes){
134  unsigned int num_nodes = 3;
135  tria->nodes = xNew<Node*>(num_nodes); //we cannot rely on an analysis_counter to tell us which analysis_type we are running, so we just copy the nodes.
136  for(i=0;i<num_nodes;i++) if(this->nodes[i]) tria->nodes[i]=this->nodes[i]; else tria->nodes[i] = NULL;
137  }
138  else tria->nodes = NULL;
139 
140  tria->vertices = (Vertex**)this->hvertices->deliverp();
141  if(this->hmaterial)tria->material = (Material*)this->hmaterial->delivers();
142 
143  return tria;
144 }
145 /*}}}*/
146 void Tria::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
147 
148  MARSHALLING_ENUM(TriaEnum);
149  MARSHALLING(this->iscollapsed);
150  MARSHALLING(this->isonsurface);
151  MARSHALLING(this->isonbase);
152 
153  /*Call parent classes: */
154  ElementHook::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
155  Element::MarshallElement(pmarshalled_data,pmarshalled_data_size,marshall_direction,this->numanalyses);
156  TriaRef::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
157 
158  vertices = (Vertex**)this->hvertices->deliverp();
159  material = (Material*)this->hmaterial->delivers();
160 
161 }
162 /*}}}*/
163 
164 /*Other*/
165 void Tria::AddBasalInput2(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
166 
167  /*Call inputs method*/
168  _assert_(this->inputs2);
169 
170  int domaintype;
171  parameters->FindParam(&domaintype,DomainTypeEnum);
172  switch(domaintype){
173  case Domain2DhorizontalEnum:
174  this->AddInput2(input_enum,values,interpolation_enum);
175  break;
176  case Domain2DverticalEnum:{
177  _error_("not implemented yet");
178  }
179  break;
180  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
181  }
182 
183 }
184 /*}}}*/
185 void Tria::AddInput2(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
186 
187  /*Intermediaries*/
188  int vertexlids[NUMVERTICES];
189 
190  /*Call inputs method*/
191  if(!this->inputs2){
192  int* temp = xNew<int>(3);
193  _error_("inputs2 not set");
194  }
195  _assert_(this->inputs2);
196  switch(interpolation_enum){
197  case P1Enum:
198  for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
199  inputs2->SetTriaInput(input_enum,interpolation_enum,NUMVERTICES,vertexlids,values);
200  break;
201  case P1DGEnum:
202  for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
203  inputs2->SetTriaInput(input_enum,interpolation_enum,this->lid,NUMVERTICES,values);
204  break;
205  default:
206  inputs2->SetTriaInput(input_enum,interpolation_enum,this->lid,this->GetNumberOfNodes(interpolation_enum),values);
207  }
208 
209 }
210 /*}}}*/
211 void Tria::AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id){/*{{{*/
212 
213  /*Intermediaries*/
214  int vertexlids[NUMVERTICES];
215 
216  _assert_(iomodel->elements);
217  for(int i=0;i<NUMVERTICES;i++){
218  int vertexid =reCast<int>(iomodel->elements[NUMVERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
219  vertexlids[i]=iomodel->my_vertices_lids[vertexid-1];
220  }
221 
222  /*Call inputs method*/
223  switch(interpolation_enum){
224  case P1Enum:
225  inputs2->SetTriaControlInput(input_enum,TriaInput2Enum,interpolation_enum,id,NUMVERTICES,vertexlids,values,values_min,values_max);
226  break;
227  default:
228  _error_("Cannot add \""<<EnumToStringx(input_enum)<<"\" interpolation "<<EnumToStringx(interpolation_enum)<<" not supported");
229  }
230 
231 }
232 /*}}}*/
233 void Tria::DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum){/*{{{*/
234 
235  /*Intermediaries*/
236  int vertexsids[NUMVERTICES];
237  int vertexlids[NUMVERTICES];
238  IssmDouble nodeinputs[NUMVERTICES];
239 
240  /*Some sanity checks*/
241  if(num_inputs<1) _error_("Cannot create a DatasetInput of size <1");
242  if(M!=iomodel->numberofvertices) _error_("Input size not supported yet");
243  if(N!=num_inputs) _error_("Sizes are not consistent");
244 
245  /*Get indices*/
246  _assert_(iomodel->elements);
247  for(int i=0;i<NUMVERTICES;i++){
248  vertexsids[i] = reCast<int>(iomodel->elements[NUMVERTICES*this->Sid()+i])-1;
249  vertexlids[i] = iomodel->my_vertices_lids[vertexsids[i]];
250  }
251 
252  /*Create inputs and add to DataSetInput*/
253  for(int i=0;i<num_inputs;i++){
254  for(int j=0;j<NUMVERTICES;j++) nodeinputs[j]=array[vertexsids[j]*N+i];
255  inputs2->SetTriaDatasetInput(input_enum,individual_enums[i],P1Enum,NUMVERTICES,vertexlids,nodeinputs);
256  }
257 }
258 /*}}}*/
259 void Tria::AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part){/*{{{*/
260 
261  bool already = false;
262  int i,j;
263  int partition[NUMVERTICES];
264  int offsetsid[NUMVERTICES];
265  int offsetdof[NUMVERTICES];
266  IssmDouble area;
267  IssmDouble mean;
268 
269  /*First, get the area: */
270  area=this->GetArea();
271 
272  /*Figure out the average for this element: */
273  this->GetVerticesSidList(&offsetsid[0]);
274  this->GetVerticesPidList(&offsetdof[0]);
275  mean=0;
276  for(i=0;i<NUMVERTICES;i++){
277  partition[i]=reCast<int>(qmu_part[offsetsid[i]]);
278  mean=mean+1.0/NUMVERTICES*vertex_response[offsetdof[i]];
279  }
280 
281  /*Add contribution: */
282  for(i=0;i<NUMVERTICES;i++){
283  already=false;
284  for(j=0;j<i;j++){
285  if (partition[i]==partition[j]){
286  already=true;
287  break;
288  }
289  }
290  if(!already){
291  partition_contributions->SetValue(partition[i],mean*area,ADD_VAL);
292  partition_areas->SetValue(partition[i],area,ADD_VAL);
293  };
294  }
295 }
296 /*}}}*/
297 void Tria::CalvingRateVonmises(){/*{{{*/
298 
299  IssmDouble xyz_list[NUMVERTICES][3];
300  IssmDouble epsilon[3]; /* epsilon=[exx,eyy,exy];*/
301  IssmDouble calvingratex[NUMVERTICES];
302  IssmDouble calvingratey[NUMVERTICES];
303  IssmDouble calvingrate[NUMVERTICES];
304  IssmDouble lambda1,lambda2,ex,ey,vx,vy,vel;
305  IssmDouble sigma_vm[NUMVERTICES];
306  IssmDouble B,sigma_max,sigma_max_floating,sigma_max_grounded,n;
307  IssmDouble epse_2,groundedice,bed,sealevel; // added sealevel
308 
309 
310  /* Get node coordinates and dof list: */
311  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
312 
313  /*Retrieve all inputs and parameters we will need*/
314  Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
315  Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
316  Input2* B_input = this->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
317  Input2* gr_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
318  Input2* bs_input = this->GetInput2(BaseEnum); _assert_(bs_input);
319  Input2* smax_fl_input = this->GetInput2(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
320  Input2* smax_gr_input = this->GetInput2(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
321  Input2* n_input = this->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
322  Input2* sl_input = this->GetInput2(SealevelEnum); _assert_(sl_input);
323 
324 
325 
326  /* Start looping on the number of vertices: */
327  GaussTria* gauss=new GaussTria();
328  for(int iv=0;iv<NUMVERTICES;iv++){
329  gauss->GaussVertex(iv);
330 
331  /*Get velocity components and thickness*/
332  B_input->GetInputValue(&B,gauss);
333  n_input->GetInputValue(&n,gauss);
334  vx_input->GetInputValue(&vx,gauss);
335  vy_input->GetInputValue(&vy,gauss);
336  gr_input->GetInputValue(&groundedice,gauss);
337  bs_input->GetInputValue(&bed,gauss);
338  smax_fl_input->GetInputValue(&sigma_max_floating,gauss);
339  smax_gr_input->GetInputValue(&sigma_max_grounded,gauss);
340  vel=sqrt(vx*vx+vy*vy)+1.e-14;
341  sl_input->GetInputValue(&sealevel,gauss);
342 
343  /*Compute strain rate and viscosity: */
344  this->StrainRateSSA(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
345 
346  /*Get Eigen values*/
347  Matrix2x2Eigen(&lambda1,&lambda2,&ex,&ey,epsilon[0],epsilon[2],epsilon[1]);
348  _assert_(!xIsNan<IssmDouble>(lambda1));
349  _assert_(!xIsNan<IssmDouble>(lambda2));
350 
351  /*Process Eigen values (only account for extension)*/
352  lambda1 = max(lambda1,0.);
353  lambda2 = max(lambda2,0.);
354 
355  /*Calculate sigma_vm*/
356  epse_2 = 1./2. *(lambda1*lambda1 + lambda2*lambda2);
357  sigma_vm[iv] = sqrt(3.) * B * pow(epse_2,1./(2.*n));
358 
359  /*OLD (keep for a little bit)*/
360  //sigma_max = 800.e+3; //IUGG previous test
361  //sigma_max = 1000.e+3; //GRL
362  //if(groundedice<0) sigma_max=150.e+3;
363 
364  /*Tensile stress threshold*/
365  if(groundedice<0)
366  sigma_max = sigma_max_floating;
367  else
368  sigma_max = sigma_max_grounded;
369  /*Assign values*/
370  if(bed>sealevel){ // Changed 0. to sealevel
371  calvingratex[iv]=0.;
372  calvingratey[iv]=0.;
373  }
374  else{
375  calvingratex[iv]=vx*sigma_vm[iv]/sigma_max;
376  calvingratey[iv]=vy*sigma_vm[iv]/sigma_max;
377  }
378  calvingrate[iv] =sqrt(calvingratex[iv]*calvingratex[iv] + calvingratey[iv]*calvingratey[iv]);
379 
380  }
381 
382  /*Add input*/
383  this->AddInput2(CalvingratexEnum,&calvingratex[0],P1DGEnum);
384  this->AddInput2(CalvingrateyEnum,&calvingratey[0],P1DGEnum);
385  this->AddInput2(CalvingCalvingrateEnum,&calvingrate[0],P1DGEnum);
386  this->AddInput2(SigmaVMEnum,&sigma_vm[0],P1DGEnum);
387 
388  /*Clean up and return*/
389  delete gauss;
390 }
391 /*}}}*/
392 void Tria::CalvingCrevasseDepth(){/*{{{*/
393 
394  IssmDouble xyz_list[NUMVERTICES][3];
395  IssmDouble calvingrate[NUMVERTICES];
396  IssmDouble vx,vy,vel;
397  IssmDouble water_height, bed,Ho,thickness,surface;
398  IssmDouble surface_crevasse[NUMVERTICES], basal_crevasse[NUMVERTICES], crevasse_depth[NUMVERTICES], H_surf, H_surfbasal;
399  IssmDouble B, strainparallel, straineffective,n;
400  IssmDouble s_xx,s_xy,s_yy,s1,s2,stmp;
401  int crevasse_opening_stress;
402 
403  /* Get node coordinates and dof list: */
404  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
405 
406  /*retrieve the type of crevasse_opening_stress*/
407  this->parameters->FindParam(&crevasse_opening_stress,CalvingCrevasseDepthEnum);
408 
409  IssmDouble rho_ice = this->FindParam(MaterialsRhoIceEnum);
410  IssmDouble rho_seawater = this->FindParam(MaterialsRhoSeawaterEnum);
411  IssmDouble rho_freshwater = this->FindParam(MaterialsRhoFreshwaterEnum);
412  IssmDouble constant_g = this->FindParam(ConstantsGEnum);
413 
414  Input2* H_input = this->GetInput2(ThicknessEnum); _assert_(H_input);
415  Input2* bed_input = this->GetInput2(BedEnum); _assert_(bed_input);
416  Input2* surface_input = this->GetInput2(SurfaceEnum); _assert_(surface_input);
417  Input2* strainrateparallel_input = this->GetInput2(StrainRateparallelEnum); _assert_(strainrateparallel_input);
418  Input2* strainrateeffective_input = this->GetInput2(StrainRateeffectiveEnum); _assert_(strainrateeffective_input);
419  Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
420  Input2* vy_input = this->GetInput2(VxEnum); _assert_(vy_input);
421  Input2* waterheight_input = this->GetInput2(WaterheightEnum); _assert_(waterheight_input);
422  Input2* s_xx_input = this->GetInput2(DeviatoricStressxxEnum); _assert_(s_xx_input);
423  Input2* s_xy_input = this->GetInput2(DeviatoricStressxyEnum); _assert_(s_xy_input);
424  Input2* s_yy_input = this->GetInput2(DeviatoricStressyyEnum); _assert_(s_yy_input);
425  Input2* B_input = this->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
426  Input2* n_input = this->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
427 
428  /*Loop over all elements of this partition*/
429  GaussTria* gauss=new GaussTria();
430  for (int iv=0;iv<NUMVERTICES;iv++){
431  gauss->GaussVertex(iv);
432 
433  H_input->GetInputValue(&thickness,gauss);
434  bed_input->GetInputValue(&bed,gauss);
435  surface_input->GetInputValue(&surface,gauss);
436  strainrateparallel_input->GetInputValue(&strainparallel,gauss);
437  strainrateeffective_input->GetInputValue(&straineffective,gauss);
438  vx_input->GetInputValue(&vx,gauss);
439  vy_input->GetInputValue(&vy,gauss);
440  waterheight_input->GetInputValue(&water_height,gauss);
441  s_xx_input->GetInputValue(&s_xx,gauss);
442  s_xy_input->GetInputValue(&s_xy,gauss);
443  s_yy_input->GetInputValue(&s_yy,gauss);
444  B_input->GetInputValue(&B,gauss);
445  n_input->GetInputValue(&n,gauss);
446 
447  vel=sqrt(vx*vx+vy*vy)+1.e-14;
448 
449  s1=(s_xx+s_yy)/2.+sqrt(pow((s_xx-s_yy)/2.,2)+pow(s_xy,2));
450  s2=(s_xx+s_yy)/2.-sqrt(pow((s_xx-s_yy)/2.,2)+pow(s_xy,2));
451  if(fabs(s2)>fabs(s1)){stmp=s2; s2=s1; s1=stmp;}
452 
453  Ho = thickness - (rho_seawater/rho_ice) * (-bed);
454  if(Ho<0.) Ho=0.;
455 
456  if(crevasse_opening_stress==0){ /*Otero2010: balance between the tensile deviatoric stress and ice overburden pressure*/
457  surface_crevasse[iv] = B * strainparallel * pow(straineffective, ((1 / n)-1)) / (rho_ice * constant_g);
458  basal_crevasse[iv] = (rho_ice/(rho_seawater-rho_ice)) * (B * strainparallel * pow(straineffective,((1/n)-1)) / (rho_ice*constant_g) - Ho);
459  }
460  else if(crevasse_opening_stress==1){ /*Benn2017,Todd2018: maximum principal stress */
461  surface_crevasse[iv] = s1 / (rho_ice*constant_g);
462  basal_crevasse[iv] = (rho_ice/(rho_seawater-rho_ice))* (s1/ (rho_ice*constant_g)-Ho);
463  }
464 
465  /* some constraints */
466  if (surface_crevasse[iv]<0.) {
467  surface_crevasse[iv]=0.;
468  water_height = 0.;
469  }
470  if (basal_crevasse[iv]<0.) basal_crevasse[iv]=0.;
471  if (bed>0.) basal_crevasse[iv] = 0.;
472 
473  //if (surface_crevasse[iv]<water_height){
474  // water_height = surface_crevasse[iv];
475  //}
476 
477  /* add water in surface crevasse */
478  surface_crevasse[iv] = surface_crevasse[iv] + (rho_freshwater/rho_ice)*water_height; /* surface crevasse + water */
479  crevasse_depth[iv] = surface_crevasse[iv] + (rho_freshwater/rho_ice)*water_height + basal_crevasse[iv]; /* surface crevasse + basal crevasse + water */
480 
481  }
482 
483  this->AddInput2(SurfaceCrevasseEnum,&surface_crevasse[0],P1DGEnum);
484  this->AddInput2(BasalCrevasseEnum,&basal_crevasse[0],P1DGEnum);
485  this->AddInput2(CrevasseDepthEnum,&crevasse_depth[0],P1DGEnum);
486 
487  delete gauss;
488 }
489 /*}}}*/
490 void Tria::CalvingRateLevermann(){/*{{{*/
491 
492  IssmDouble xyz_list[NUMVERTICES][3];
493  IssmDouble vx,vy,vel;
494  IssmDouble strainparallel;
495  IssmDouble propcoeff,bed;
496  IssmDouble strainperpendicular;
497  IssmDouble calvingratex[NUMVERTICES];
498  IssmDouble calvingratey[NUMVERTICES];
499  IssmDouble calvingrate[NUMVERTICES];
500 
501  /* Get node coordinates and dof list: */
502  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
503 
504  /*Retrieve all inputs and parameters we will need*/
505  Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
506  Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
507  Input2* bs_input = this->GetInput2(BaseEnum); _assert_(bs_input);
508  Input2* strainparallel_input=this->GetInput2(StrainRateparallelEnum); _assert_(strainparallel_input);
509  Input2* strainperpendicular_input=this->GetInput2(StrainRateperpendicularEnum);_assert_(strainperpendicular_input);
510  Input2* levermanncoeff_input=this->GetInput2(CalvinglevermannCoeffEnum); _assert_(levermanncoeff_input);
511 
512  /* Start looping on the number of vertices: */
513  GaussTria* gauss=new GaussTria();
514  for (int iv=0;iv<NUMVERTICES;iv++){
515  gauss->GaussVertex(iv);
516 
517  /* Get the value we need*/
518  vx_input->GetInputValue(&vx,gauss);
519  vy_input->GetInputValue(&vy,gauss);
520  vel=vx*vx+vy*vy;
521  strainparallel_input->GetInputValue(&strainparallel,gauss);
522  strainperpendicular_input->GetInputValue(&strainperpendicular,gauss);
523  levermanncoeff_input->GetInputValue(&propcoeff,gauss);
524  bs_input->GetInputValue(&bed,gauss);
525 
526  /*Calving rate proportionnal to the positive product of the strain rate along the ice flow direction and the strain rate perpendicular to the ice flow */
527  if(strainparallel>0. && strainperpendicular>0. && bed<=0.){
528  calvingrate[iv]=propcoeff*strainparallel*strainperpendicular;
529  }
530  else
531  calvingrate[iv]=0.;
532 
533  calvingratex[iv]=calvingrate[iv]*vx/(sqrt(vel)+1.e-14);
534  calvingratey[iv]=calvingrate[iv]*vy/(sqrt(vel)+1.e-14);
535  }
536 
537  /*Add input*/
538  this->AddInput2(CalvingratexEnum,&calvingratex[0],P1DGEnum);
539  this->AddInput2(CalvingrateyEnum,&calvingratey[0],P1DGEnum);
540  this->AddInput2(CalvingCalvingrateEnum,&calvingrate[0],P1DGEnum);
541 
542  /*Clean up and return*/
543  delete gauss;
544 
545 }
546 /*}}}*/
547 void Tria::CalvingFluxLevelset(){/*{{{*/
548 
549  /*Make sure there is an ice front here*/
550  if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)){
551  IssmDouble flux_per_area=0;
552  this->AddInput2(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum);
553  }
554  else{
555  int domaintype,index1,index2;
556  const IssmPDouble epsilon = 1.e-15;
557  IssmDouble s1,s2;
558  IssmDouble gl[NUMVERTICES];
559  IssmDouble xyz_front[2][3];
560 
561  IssmDouble *xyz_list = NULL;
562  this->GetVerticesCoordinates(&xyz_list);
563 
564  /*Recover parameters and values*/
565  parameters->FindParam(&domaintype,DomainTypeEnum);
566  Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
567 
568  /*Be sure that values are not zero*/
569  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
570  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
571  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
572 
573  if(domaintype==Domain2DverticalEnum){
574  _error_("not implemented");
575  }
576  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
577  int pt1 = 0;
578  int pt2 = 1;
579  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
580 
581  /*Portion of the segments*/
582  s1=gl[2]/(gl[2]-gl[1]);
583  s2=gl[2]/(gl[2]-gl[0]);
584  if(gl[2]<0.){
585  pt1 = 1; pt2 = 0;
586  }
587  xyz_front[pt2][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
588  xyz_front[pt2][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
589  xyz_front[pt2][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
590  xyz_front[pt1][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
591  xyz_front[pt1][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
592  xyz_front[pt1][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
593  }
594  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
595 
596  /*Portion of the segments*/
597  s1=gl[0]/(gl[0]-gl[1]);
598  s2=gl[0]/(gl[0]-gl[2]);
599  if(gl[0]<0.){
600  pt1 = 1; pt2 = 0;
601  }
602 
603  xyz_front[pt1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
604  xyz_front[pt1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
605  xyz_front[pt1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
606  xyz_front[pt2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
607  xyz_front[pt2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
608  xyz_front[pt2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
609  }
610  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
611 
612  /*Portion of the segments*/
613  s1=gl[1]/(gl[1]-gl[0]);
614  s2=gl[1]/(gl[1]-gl[2]);
615  if(gl[1]<0.){
616  pt1 = 1; pt2 = 0;
617  }
618 
619  xyz_front[pt2][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
620  xyz_front[pt2][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
621  xyz_front[pt2][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
622  xyz_front[pt1][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
623  xyz_front[pt1][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
624  xyz_front[pt1][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
625  }
626  else{
627  _error_("case not possible");
628  }
629 
630  }
631  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
632 
633  /*Some checks in debugging mode*/
634  _assert_(s1>=0 && s1<=1.);
635  _assert_(s2>=0 && s2<=1.);
636 
637  /*Get normal vector*/
638  IssmDouble normal[3];
639  this->NormalSection(&normal[0],&xyz_front[0][0]);
640  normal[0] = -normal[0];
641  normal[1] = -normal[1];
642 
643  /*Get inputs*/
644  IssmDouble flux = 0.;
645  IssmDouble area = 0.;
646  IssmDouble calvingratex,calvingratey,thickness,Jdet,flux_per_area;
647  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
648  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
649  Input2* calvingratex_input=NULL;
650  Input2* calvingratey_input=NULL;
651  if(domaintype==Domain2DhorizontalEnum){
652  calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
653  calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
654  }
655  else{
656  calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
657  calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
658  }
659 
660  /*Start looping on Gaussian points*/
661  Gauss* gauss=this->NewGauss(xyz_list,&xyz_front[0][0],3);
662  for(int ig=gauss->begin();ig<gauss->end();ig++){
663 
664  gauss->GaussPoint(ig);
665  thickness_input->GetInputValue(&thickness,gauss);
666  calvingratex_input->GetInputValue(&calvingratex,gauss);
667  calvingratey_input->GetInputValue(&calvingratey,gauss);
668  this->JacobianDeterminantSurface(&Jdet,&xyz_front[0][0],gauss);
669 
670  flux += rho_ice*Jdet*gauss->weight*thickness*(calvingratex*normal[0] + calvingratey*normal[1]);
671  area += Jdet*gauss->weight*thickness;
672 
673  flux_per_area=flux/area;
674  }
675 
676  this->AddInput2(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum);
677 
678  /*Clean up and return*/
679  delete gauss;
680  }
681 }
682 /*}}}*/
683 void Tria::CalvingMeltingFluxLevelset(){/*{{{*/
684 
685  /*Make sure there is an ice front here*/
686  if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)){
687  IssmDouble flux_per_area=0;
688  this->AddInput2(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum);
689  }
690  else{
691  int domaintype,index1,index2;
692  const IssmPDouble epsilon = 1.e-15;
693  IssmDouble s1,s2;
694  IssmDouble gl[NUMVERTICES];
695  IssmDouble xyz_front[2][3];
696 
697 
698  IssmDouble *xyz_list = NULL;
699  this->GetVerticesCoordinates(&xyz_list);
700 
701  /*Recover parameters and values*/
702  parameters->FindParam(&domaintype,DomainTypeEnum);
703  Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
704 
705  /*Be sure that values are not zero*/
706  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
707  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
708  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
709 
710  if(domaintype==Domain2DverticalEnum){
711  _error_("not implemented");
712  }
713  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
714  int pt1 = 0;
715  int pt2 = 1;
716  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
717 
718  /*Portion of the segments*/
719  s1=gl[2]/(gl[2]-gl[1]);
720  s2=gl[2]/(gl[2]-gl[0]);
721  if(gl[2]<0.){
722  pt1 = 1; pt2 = 0;
723  }
724  xyz_front[pt2][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
725  xyz_front[pt2][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
726  xyz_front[pt2][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
727  xyz_front[pt1][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
728  xyz_front[pt1][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
729  xyz_front[pt1][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
730  }
731  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
732 
733  /*Portion of the segments*/
734  s1=gl[0]/(gl[0]-gl[1]);
735  s2=gl[0]/(gl[0]-gl[2]);
736  if(gl[0]<0.){
737  pt1 = 1; pt2 = 0;
738  }
739 
740  xyz_front[pt1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
741  xyz_front[pt1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
742  xyz_front[pt1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
743  xyz_front[pt2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
744  xyz_front[pt2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
745  xyz_front[pt2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
746  }
747  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
748 
749  /*Portion of the segments*/
750  s1=gl[1]/(gl[1]-gl[0]);
751  s2=gl[1]/(gl[1]-gl[2]);
752  if(gl[1]<0.){
753  pt1 = 1; pt2 = 0;
754  }
755 
756  xyz_front[pt2][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
757  xyz_front[pt2][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
758  xyz_front[pt2][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
759  xyz_front[pt1][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
760  xyz_front[pt1][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
761  xyz_front[pt1][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
762  }
763  else{
764  _error_("case not possible");
765  }
766 
767  }
768  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
769 
770  /*Some checks in debugging mode*/
771  _assert_(s1>=0 && s1<=1.);
772  _assert_(s2>=0 && s2<=1.);
773 
774  /*Get normal vector*/
775  IssmDouble normal[3];
776  this->NormalSection(&normal[0],&xyz_front[0][0]);
777  normal[0] = -normal[0];
778  normal[1] = -normal[1];
779 
780  /*Get inputs*/
781  IssmDouble flux = 0.;
782  IssmDouble area = 0.;
783  IssmDouble calvingratex,calvingratey,vx,vy,vel,meltingrate,meltingratex,meltingratey,thickness,Jdet,flux_per_area;
784  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
785  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
786  Input2* calvingratex_input=NULL;
787  Input2* calvingratey_input=NULL;
788  Input2* vx_input=NULL;
789  Input2* vy_input=NULL;
790  Input2* meltingrate_input=NULL;
791  if(domaintype==Domain2DhorizontalEnum){
792  calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
793  calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
794  vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
795  vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
796  meltingrate_input=this->GetInput2(CalvingMeltingrateEnum); _assert_(meltingrate_input);
797  }
798  else{
799  calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
800  calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
801  }
802 
803  /*Start looping on Gaussian points*/
804  Gauss* gauss=this->NewGauss(xyz_list,&xyz_front[0][0],3);
805  for(int ig=gauss->begin();ig<gauss->end();ig++){
806 
807  gauss->GaussPoint(ig);
808  thickness_input->GetInputValue(&thickness,gauss);
809  calvingratex_input->GetInputValue(&calvingratex,gauss);
810  calvingratey_input->GetInputValue(&calvingratey,gauss);
811  vx_input->GetInputValue(&vx,gauss);
812  vy_input->GetInputValue(&vy,gauss);
813  vel=vx*vx+vy*vy;
814  meltingrate_input->GetInputValue(&meltingrate,gauss);
815  meltingratex=meltingrate*vx/(sqrt(vel)+1.e-14);
816  meltingratey=meltingrate*vy/(sqrt(vel)+1.e-14);
817  this->JacobianDeterminantSurface(&Jdet,&xyz_front[0][0],gauss);
818 
819  flux += rho_ice*Jdet*gauss->weight*thickness*((calvingratex+meltingratex)*normal[0] + (calvingratey+meltingratey)*normal[1]);
820  area += Jdet*gauss->weight*thickness;
821 
822  flux_per_area=flux/area;
823  }
824 
825  this->AddInput2(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum);
826 
827  /*Clean up and return*/
828  delete gauss;
829  }
830 }
831 /*}}}*/
832 IssmDouble Tria::CharacteristicLength(void){/*{{{*/
833 
834  return sqrt(2*this->GetArea());
835 }
836 /*}}}*/
837 void Tria::ComputeBasalStress(void){/*{{{*/
838  _error_("Not Implemented yet");
839 }
840 /*}}}*/
841 void Tria::ComputeDeviatoricStressTensor(){/*{{{*/
842 
843  IssmDouble xyz_list[NUMVERTICES][3];
844  IssmDouble viscosity,lambda1,lambda2;
845  IssmDouble epsilon[3]; /* epsilon=[exx,eyy,exy];*/
846  IssmDouble tau_xx[NUMVERTICES];
847  IssmDouble tau_yy[NUMVERTICES];
848  IssmDouble tau_zz[NUMVERTICES]={0,0,0};
849  IssmDouble tau_xy[NUMVERTICES];
850  IssmDouble tau_xz[NUMVERTICES]={0,0,0};
851  IssmDouble tau_yz[NUMVERTICES]={0,0,0};
852  IssmDouble tau_e[NUMVERTICES];
853  IssmDouble tau_1[NUMVERTICES];
854  IssmDouble tau_2[NUMVERTICES];
855  GaussTria* gauss=NULL;
856  int domaintype,dim=2;
857 
858  /*Get approximation*/
859  int approximation;
860  this->GetInput2Value(&approximation,ApproximationEnum);
861 
862  /* Get node coordinates and dof list: */
863  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
864 
865  /*Retrieve all inputs we will be needing: */
866  this->FindParam(&domaintype,DomainTypeEnum);
867  Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
868  Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
869 
870  /* Start looping on the number of vertices: */
871  gauss=new GaussTria();
872  for (int iv=0;iv<NUMVERTICES;iv++){
873  gauss->GaussVertex(iv);
874 
875  /*Compute strain rate and viscosity: */
876  this->StrainRateSSA(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
877  switch(approximation){
878  case SSAApproximationEnum:
879  this->material->ViscositySSA(&viscosity,dim,&xyz_list[0][0],gauss,vx_input,vy_input);
880  break;
881  case HOApproximationEnum:
882  this->material->ViscosityHO(&viscosity,dim,&xyz_list[0][0],gauss,vx_input,vy_input);
883  break;
884  case FSApproximationEnum:
885  this->material->ViscosityFS(&viscosity,dim,&xyz_list[0][0],gauss,vx_input,vy_input,NULL);
886  break;
887  default:
888  _error_("not supported yet");
889  }
890 
891  /*Compute Stress*/
892  tau_xx[iv]=2*viscosity*epsilon[0]; // tau = nu eps
893  tau_yy[iv]=2*viscosity*epsilon[1];
894  tau_xy[iv]=2*viscosity*epsilon[2];
895  tau_e[iv]=1/sqrt(2)*sqrt(pow(tau_xx[iv],2)+pow(tau_yy[iv],2)+2*pow(tau_xy[iv],2));
896 
897  /*Get Eigen values*/
898  Matrix2x2Eigen(&tau_2[iv],&tau_1[iv],NULL,NULL,tau_xx[iv],tau_xy[iv],tau_yy[iv]);
899  }
900 
901  /*Add Stress tensor components into inputs*/
902  this->AddInput2(DeviatoricStressxxEnum,&tau_xx[0],P1DGEnum);
903  this->AddInput2(DeviatoricStressxyEnum,&tau_xy[0],P1DGEnum);
904  this->AddInput2(DeviatoricStressxzEnum,&tau_xz[0],P1DGEnum);
905  this->AddInput2(DeviatoricStressyyEnum,&tau_yy[0],P1DGEnum);
906  this->AddInput2(DeviatoricStressyzEnum,&tau_yz[0],P1DGEnum);
907  this->AddInput2(DeviatoricStresszzEnum,&tau_zz[0],P1DGEnum);
908  this->AddInput2(DeviatoricStresseffectiveEnum,&tau_e[0],P1DGEnum);
909  this->AddInput2(DeviatoricStress1Enum,&tau_1[0],P1DGEnum);
910  this->AddInput2(DeviatoricStress2Enum,&tau_2[0],P1DGEnum);
911 
912  /*Clean up and return*/
913  delete gauss;
914 }
915 /*}}}*/
916 void Tria::ComputeEsaStrainAndVorticity(){ /*{{{*/
917 
918  IssmDouble xyz_list[NUMVERTICES][3];
919  IssmDouble epsilon[4]; /* epsilon=[exx,eyy,exy+ (shear),exy- (rotation)];*/
920  IssmDouble strain_xx[NUMVERTICES];
921  IssmDouble strain_yy[NUMVERTICES];
922  IssmDouble strain_xy[NUMVERTICES];
923  IssmDouble vorticity_xy[NUMVERTICES];
924  GaussTria* gauss=NULL;
925 
926  /* Get node coordinates and dof list: */
927  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
928 
929  /*Retrieve all inputs we will be needing: */
930  Input2* vx_input=this->GetInput2(EsaXmotionEnum); _assert_(vx_input);
931  Input2* vy_input=this->GetInput2(EsaYmotionEnum); _assert_(vy_input);
932 
933  /* Start looping on the number of vertices: */
934  gauss=new GaussTria();
935  for (int iv=0;iv<NUMVERTICES;iv++){
936  gauss->GaussVertex(iv);
937 
938  /*Compute strain rate and vorticity rate: */
939  this->StrainRateESA(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
940 
941  /*Compute Stress*/
942  strain_xx[iv]=epsilon[0];
943  strain_yy[iv]=epsilon[1];
944  strain_xy[iv]=epsilon[2];
945  vorticity_xy[iv]=epsilon[3];
946  }
947 
948  /*Add Stress tensor components into inputs*/
949  this->AddInput2(EsaStrainratexxEnum,&strain_xx[0],P1DGEnum);
950  this->AddInput2(EsaStrainrateyyEnum,&strain_yy[0],P1DGEnum);
951  this->AddInput2(EsaStrainratexyEnum,&strain_xy[0],P1DGEnum);
952  this->AddInput2(EsaRotationrateEnum,&vorticity_xy[0],P1DGEnum);
953 
954  /*Clean up and return*/
955  delete gauss;
956 }
957 /*}}}*/
958 void Tria::ComputeSigmaNN(){/*{{{*/
959 
960  if(!IsOnBase()){
961  IssmDouble sigma_nn[3]={0.};
962  this->AddInput2(SigmaNNEnum,&sigma_nn[0],P1Enum);
963  return;
964  }
965  else{
966  IssmDouble* xyz_list=NULL;
967  IssmDouble *xyz_list_base=NULL;
968  IssmDouble pressure,viscosity;
969  IssmDouble sigma_nn[3];
970  IssmDouble sigma_xx,sigma_xy,sigma_yy;
971  IssmDouble epsilon[3]; /* epsilon=[exx,eyy,exy];*/
972  IssmDouble base_normal[2];
973  int domaintype,dim=2;
974 
975  /* Get node coordinates and dof list: */
976  GetVerticesCoordinates(&xyz_list);
977  GetVerticesCoordinatesBase(&xyz_list_base);
978 
979  /*Retrieve all inputs we will be needing: */
980  this->FindParam(&domaintype,DomainTypeEnum);
981  if(domaintype==Domain2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <<EnumToStringx(domaintype)<<", extrude mesh or call ComputeDeviatoricStressTensor");
982  Input2* pressure_input=this->GetInput2(PressureEnum); _assert_(pressure_input);
983  Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
984  Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
985 
986  /* Start looping on the number of vertices: */
987  Gauss* gauss = this->NewGauss();
988  for(int i=0;i<NUMVERTICES;i++){
989  gauss->GaussNode(P1Enum,i);
990 
991  /*Compute strain rate viscosity and pressure: */
992  this->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
993  this->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,NULL);
994  pressure_input->GetInputValue(&pressure,gauss);
995 
996  /*Compute Stress*/
997  sigma_xx=2*viscosity*epsilon[0]-pressure; // sigma = nu eps - pressure
998  sigma_yy=2*viscosity*epsilon[1]-pressure;
999  sigma_xy=2*viscosity*epsilon[2];
1000 
1001  /*Get normal vector to the bed */
1002  NormalBase(&base_normal[0],xyz_list_base);
1003 
1004  /*Compute sigma_nn*/
1005  sigma_nn[i]=sigma_xx*base_normal[0]*base_normal[0] + 2*sigma_xy*base_normal[0]*base_normal[1] + sigma_yy*base_normal[1]*base_normal[1];
1006  }
1007 
1008  /*Add Stress tensor components into inputs*/
1009  this->AddInput2(SigmaNNEnum,&sigma_nn[0],P1Enum);
1010 
1011  /*Clean up and return*/
1012  xDelete<IssmDouble>(xyz_list);
1013  xDelete<IssmDouble>(xyz_list_base);
1014  delete gauss;
1015  }
1016 }
1017 /*}}}*/
1018 void Tria::ComputeStressTensor(){/*{{{*/
1019 
1020  IssmDouble xyz_list[NUMVERTICES][3];
1021  IssmDouble pressure,viscosity;
1022  IssmDouble epsilon[3]; /* epsilon=[exx,eyy,exy];*/
1023  IssmDouble sigma_xx[NUMVERTICES];
1024  IssmDouble sigma_yy[NUMVERTICES];
1025  IssmDouble sigma_zz[NUMVERTICES]={0,0,0};
1026  IssmDouble sigma_xy[NUMVERTICES];
1027  IssmDouble sigma_xz[NUMVERTICES]={0,0,0};
1028  IssmDouble sigma_yz[NUMVERTICES]={0,0,0};
1029  GaussTria* gauss=NULL;
1030  int domaintype,dim=2;
1031 
1032  /* Get node coordinates and dof list: */
1033  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
1034 
1035  /*Retrieve all inputs we will be needing: */
1036  this->FindParam(&domaintype,DomainTypeEnum);
1037  if(domaintype==Domain2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <<EnumToStringx(domaintype)<<", extrude mesh or call ComputeDeviatoricStressTensor");
1038  Input2* pressure_input=this->GetInput2(PressureEnum); _assert_(pressure_input);
1039  Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
1040  Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
1041 
1042  /* Start looping on the number of vertices: */
1043  gauss=new GaussTria();
1044  for (int iv=0;iv<NUMVERTICES;iv++){
1045  gauss->GaussVertex(iv);
1046 
1047  /*Compute strain rate viscosity and pressure: */
1048  this->StrainRateSSA(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
1049  this->material->ViscositySSA(&viscosity,dim,&xyz_list[0][0],gauss,vx_input,vy_input);
1050  pressure_input->GetInputValue(&pressure,gauss);
1051 
1052  /*Compute Stress*/
1053  sigma_xx[iv]=2*viscosity*epsilon[0]-pressure; // sigma = nu eps - pressure
1054  sigma_yy[iv]=2*viscosity*epsilon[1]-pressure;
1055  sigma_xy[iv]=2*viscosity*epsilon[2];
1056  }
1057 
1058  /*Add Stress tensor components into inputs*/
1059  this->AddInput2(StressTensorxxEnum,&sigma_xx[0],P1DGEnum);
1060  this->AddInput2(StressTensorxyEnum,&sigma_xy[0],P1DGEnum);
1061  this->AddInput2(StressTensorxzEnum,&sigma_xz[0],P1DGEnum);
1062  this->AddInput2(StressTensoryyEnum,&sigma_yy[0],P1DGEnum);
1063  this->AddInput2(StressTensoryzEnum,&sigma_yz[0],P1DGEnum);
1064  this->AddInput2(StressTensorzzEnum,&sigma_zz[0],P1DGEnum);
1065 
1066  /*Clean up and return*/
1067  delete gauss;
1068 }
1069 /*}}}*/
1070 void Tria::Configure(Elements* elementsin, Loads* loadsin,Nodes* nodesin,Vertices *verticesin,Materials* materialsin, Parameters* parametersin,Inputs2* inputs2in){/*{{{*/
1071 
1072  /*go into parameters and get the analysis_counter: */
1073  int analysis_counter;
1074  parametersin->FindParam(&analysis_counter,AnalysisCounterEnum);
1075 
1076  /*Get Element type*/
1077  if (this->element_type_list) this->element_type=this->element_type_list[analysis_counter];
1078 
1079  /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
1080  * datasets, using internal ids and offsets hidden in hooks: */
1081  if(this->hnodes){
1082  if (this->hnodes[analysis_counter]) this->hnodes[analysis_counter]->configure(nodesin);
1083  else this->hnodes[analysis_counter] = NULL;
1084  }
1085  else this->hnodes = NULL;
1086  this->hvertices->configure(verticesin);
1087  if(this->hmaterial) this->hmaterial->configure(materialsin);
1088 
1089  /*Now, go pick up the objects inside the hooks: */
1090  if(this->hnodes && this->hnodes[analysis_counter]) this->nodes=(Node**)this->hnodes[analysis_counter]->deliverp();
1091  else this->nodes=NULL;
1092  this->vertices = (Vertex**)this->hvertices->deliverp();
1093  if(this->hmaterial)this->material = (Material*)this->hmaterial->delivers();
1094 
1095  /*point parameters to real dataset: */
1096  this->parameters=parametersin;
1097  this->inputs2=inputs2in;
1098 }/*}}}*/
1099 void Tria::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N, int M){/*{{{*/
1100 
1101  int idlist[NUMVERTICES];
1102  int vertexlids[NUMVERTICES];
1103  int gradidlist[NUMVERTICES];
1104  IssmDouble grad_list[NUMVERTICES];
1105 
1106  GradientIndexing(&gradidlist[0],control_index);
1107  for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
1108 
1109  if(N==1){
1110  this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0]);
1111  }
1112  else{
1113  for(int n=0;n<N;n++){
1114  for(int i=0;i<NUMVERTICES;i++){
1115  idlist[i] = offset + this->vertices[i]->Sid()+n*M;
1116  grad_list[i]=gradient[idlist[i]];
1117  }
1118  this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0],n);
1119  }
1120  }
1121 
1122 }/*}}}*/
1123 void Tria::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){/*{{{*/
1124 
1125  int idlist[NUMVERTICES];
1126  int vertexlids[NUMVERTICES];
1127  IssmDouble grad_list[NUMVERTICES];
1128 
1129  GradientIndexing(&idlist[0],control_index);
1130  for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[idlist[i]];
1131  for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
1132 
1133  this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0]);
1134 
1135 }/*}}}*/
1136 void Tria::ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum){/*{{{*/
1137 
1138  int sidlist[NUMVERTICES];
1139  int lidlist[NUMVERTICES];
1140  int connectivity[NUMVERTICES];
1141  IssmPDouble values[NUMVERTICES];
1142  IssmPDouble gradients[NUMVERTICES];
1143  IssmDouble value,gradient;
1144 
1145  this->GetVerticesConnectivityList(&connectivity[0]);
1146  this->GetVerticesSidList(&sidlist[0]);
1147  this->GetVerticesLidList(&lidlist[0]);
1148 
1149  ElementInput2* control_value = this->inputs2->GetControlInput2Data(control_enum,"value"); _assert_(control_value);
1150  ElementInput2* control_gradient = this->inputs2->GetControlInput2Data(control_enum,"gradient"); _assert_(control_gradient);
1151  control_value->Serve(NUMVERTICES,&lidlist[0]);
1152  control_gradient->Serve(NUMVERTICES,&lidlist[0]);
1153 
1154  GaussTria* gauss=new GaussTria();
1155  for (int iv=0;iv<NUMVERTICES;iv++){
1156  gauss->GaussVertex(iv);
1157 
1158  control_value->GetInputValue(&value,gauss);
1159  control_gradient->GetInputValue(&gradient,gauss);
1160 
1161  values[iv] = reCast<IssmPDouble>(value)/reCast<IssmPDouble>(connectivity[iv]);
1162  gradients[iv] = reCast<IssmPDouble>(gradient)/reCast<IssmPDouble>(connectivity[iv]);
1163  }
1164  delete gauss;
1165 
1166  vector_control->SetValues(NUMVERTICES,&sidlist[0],&values[0],ADD_VAL);
1167  vector_gradient->SetValues(NUMVERTICES,&sidlist[0],&gradients[0],ADD_VAL);
1168 
1169 }/*}}}*/
1170 void Tria::CreateDistanceInputFromSegmentlist(IssmDouble* distances,int distanceenum){/*{{{*/
1171 
1172  /*Get current field and vertex coordinates*/
1173  IssmDouble ls[NUMVERTICES],distance;
1174  Element::GetInputListOnVertices(&ls[0],distanceenum);
1175 
1176  /*Get distance from list of segments and reset ls*/
1177  for(int j=0;j<NUMVERTICES;j++){
1178  distance=distances[this->vertices[j]->Lid()];
1179  if(xIsNan<IssmDouble>(distance)) _error_("NaN found in vector");
1180  if(xIsInf<IssmDouble>(distance)) _error_("Inf found in vector");
1181 
1182  /*FIXME: do we really need this?*/
1183  if(distanceenum==MaskIceLevelsetEnum) if(distance>10000) distance=10000;
1184  if(ls[j]>0){
1185  ls[j] = distance;
1186  }
1187  else{
1188  ls[j] = - distance;
1189  }
1190  }
1191 
1192  /*Update Levelset*/
1193  this->AddInput2(distanceenum,&ls[0],P1Enum);
1194 }
1195 /*}}}*/
1196 int Tria::EdgeOnBaseIndex(void){/*{{{*/
1197 
1198  IssmDouble values[NUMVERTICES];
1199  int indices[3][2] = {{1,2},{2,0},{0,1}};
1200 
1201  /*Retrieve all inputs and parameters*/
1202  Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
1203 
1204  for(int i=0;i<3;i++){
1205  if(values[indices[i][0]] == 1. && values[indices[i][1]] == 1.){
1206  return i;
1207  }
1208  }
1209 
1210  _printf_("list of vertices on bed: "<<values[0]<<" "<<values[1]<<" "<<values[2]);
1211  _error_("Could not find 2 vertices on bed");
1212 }
1213 /*}}}*/
1214 void Tria::EdgeOnBaseIndices(int* pindex1,int* pindex2){/*{{{*/
1215 
1216  IssmDouble values[NUMVERTICES];
1217  int indices[3][2] = {{1,2},{2,0},{0,1}};
1218 
1219  /*Retrieve all inputs and parameters*/
1220  Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
1221 
1222  for(int i=0;i<3;i++){
1223  if(values[indices[i][0]] == 1. && values[indices[i][1]] == 1.){
1224  *pindex1 = indices[i][0];
1225  *pindex2 = indices[i][1];
1226  return;
1227  }
1228  }
1229 
1230  _printf_("list of vertices on bed: "<<values[0]<<" "<<values[1]<<" "<<values[2]);
1231  _error_("Could not find 2 vertices on bed");
1232 }
1233 /*}}}*/
1234 int Tria::EdgeOnSurfaceIndex(void){/*{{{*/
1235 
1236  IssmDouble values[NUMVERTICES];
1237  int indices[3][2] = {{1,2},{2,0},{0,1}};
1238 
1239  /*Retrieve all inputs and parameters*/
1240  Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
1241 
1242  for(int i=0;i<3;i++){
1243  if(values[indices[i][0]] == 1. && values[indices[i][1]] == 1.){
1244  return i;
1245  }
1246  }
1247 
1248  _printf_("list of vertices on surface: "<<values[0]<<" "<<values[1]<<" "<<values[2]);
1249  _error_("Could not find 2 vertices on surface");
1250 }
1251 /*}}}*/
1252 void Tria::EdgeOnSurfaceIndices(int* pindex1,int* pindex2){/*{{{*/
1253 
1254  IssmDouble values[NUMVERTICES];
1255  int indices[3][2] = {{1,2},{2,0},{0,1}};
1256 
1257  /*Retrieve all inputs and parameters*/
1258  Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
1259 
1260  for(int i=0;i<3;i++){
1261  if(values[indices[i][0]] == 1. && values[indices[i][1]] == 1.){
1262  *pindex1 = indices[i][0];
1263  *pindex2 = indices[i][1];
1264  return;
1265  }
1266  }
1267 
1268  _printf_("list of vertices on surface: "<<values[0]<<" "<<values[1]<<" "<<values[2]);
1269  _error_("Could not find 2 vertices on surface");
1270 }
1271 /*}}}*/
1272 void Tria::ElementResponse(IssmDouble* presponse,int response_enum){/*{{{*/
1273 
1274  switch(response_enum){
1275  case MaterialsRheologyBbarEnum:
1276  *presponse=this->material->GetBbar(NULL);
1277  break;
1278 
1279  case VelEnum:{
1280 
1281  /*Get input:*/
1282  IssmDouble vel;
1283  Input2* vel_input=this->GetInput2(VelEnum); _assert_(vel_input);
1284  vel_input->GetInputAverage(&vel);
1285 
1286  /*Assign output pointers:*/
1287  *presponse=vel;}
1288  break;
1289  default:
1290  _error_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
1291  }
1292 
1293 }
1294 /*}}}*/
1295 void Tria::ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){/*{{{*/
1296 
1297  IssmDouble xyz_list[NUMVERTICES][3];
1298  IssmDouble xmin,ymin;
1299  IssmDouble xmax,ymax;
1300 
1301  /*Get xyz list: */
1302  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
1303  xmin=xyz_list[0][0]; xmax=xyz_list[0][0];
1304  ymin=xyz_list[0][1]; ymax=xyz_list[0][1];
1305 
1306  for(int i=1;i<NUMVERTICES;i++){
1307  if(xyz_list[i][0]<xmin) xmin=xyz_list[i][0];
1308  if(xyz_list[i][0]>xmax) xmax=xyz_list[i][0];
1309  if(xyz_list[i][1]<ymin) ymin=xyz_list[i][1];
1310  if(xyz_list[i][1]>ymax) ymax=xyz_list[i][1];
1311  }
1312 
1313  *hx=xmax-xmin;
1314  *hy=ymax-ymin;
1315  *hz=0.;
1316 }
1317 /*}}}*/
1318 int Tria::FiniteElement(void){/*{{{*/
1319  return this->element_type;
1320 }
1321 /*}}}*/
1322 IssmDouble Tria::FloatingArea(bool scaled){/*{{{*/
1323 
1324  /*Intermediaries*/
1325  int domaintype;
1326  IssmDouble phi,scalefactor,floatingarea;
1327  IssmDouble *xyz_list = NULL;
1328 
1329  if(!IsIceInElement())return 0.;
1330 
1331  /*Get problem dimension*/
1332  this->FindParam(&domaintype,DomainTypeEnum);
1333  if(domaintype!=Domain2DhorizontalEnum && domaintype!=Domain3DEnum) _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1334 
1335  this->GetVerticesCoordinates(&xyz_list);
1336  phi=this->GetGroundedPortion(xyz_list);
1337  floatingarea=(1-phi)*this->GetArea();
1338  if(scaled==true){
1339  Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
1340  scalefactor_input->GetInputAverage(&scalefactor);
1341  floatingarea=floatingarea*scalefactor;
1342  }
1343 
1344  /*Clean up and return*/
1345  xDelete<IssmDouble>(xyz_list);
1346  return floatingarea;
1347 }
1348 /*}}}*/
1349 void Tria::FSContactMigration(Vector<IssmDouble>* vertex_sigmann,Vector<IssmDouble>* vertex_waterpressure){/*{{{*/
1350 
1351  if(!IsOnBase()) return;
1352 
1353  int approximation;
1354  this->GetInput2Value(&approximation,ApproximationEnum);
1355 
1356  if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum || approximation==SSAHOApproximationEnum){
1357  _error_(" contact contiditon only works for FS elements");
1358  }
1359  /*Intermediaries*/
1360  IssmDouble* xyz_list = NULL;
1361  IssmDouble bed_normal[2],base[NUMVERTICES],bed[NUMVERTICES],surface[NUMVERTICES],phi[NUMVERTICES];
1362  IssmDouble water_pressure[NUMVERTICES],pressureice[NUMVERTICES],pressure[NUMVERTICES];
1363  IssmDouble sigmaxx[NUMVERTICES],sigmayy[NUMVERTICES],sigmaxy[NUMVERTICES],sigma_nn[NUMVERTICES];
1364  IssmDouble viscosity,epsilon[NUMVERTICES];
1365  Element::GetInputListOnVertices(&base[0],BaseEnum);
1366  Element::GetInputListOnVertices(&bed[0],BedEnum);
1367  Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
1368  Element::GetInputListOnVertices(&pressure[0],PressureEnum);
1369  Element::GetInputListOnVertices(&phi[0],MaskOceanLevelsetEnum);
1370  IssmDouble rho_ice = FindParam(MaterialsRhoIceEnum);
1371  IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
1372  IssmDouble gravity = FindParam(ConstantsGEnum);
1373 
1374  /* Get node coordinates and dof list: */
1375  GetVerticesCoordinates(&xyz_list);
1376  /*Retrieve all inputs we will be needing: */
1377  Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
1378  Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
1379 
1380  /*1. Recover stresses at the base*/
1381  GaussTria* gauss=new GaussTria();
1382  for (int iv=0;iv<NUMVERTICES;iv++){
1383  gauss->GaussVertex(iv);
1384 
1385  /*Compute strain rate viscosity and pressure: */
1386  this->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
1387  this->material->ViscosityFS(&viscosity,2,xyz_list,gauss,vx_input,vy_input,NULL);
1388  /*FIXME: this is for Hongju only*/
1389  // pressureice[iv]=gravity*rho_ice*(surface[iv]-base[iv]);
1390  // if (pressure[iv]/pressureice[iv]>1) pressure[iv]=pressureice[iv];
1391 
1392  /*Compute Stress*/
1393  sigmaxx[iv]=2*viscosity*epsilon[0]-pressure[iv];
1394  sigmayy[iv]=2*viscosity*epsilon[1]-pressure[iv];
1395  sigmaxy[iv]=2*viscosity*epsilon[2];
1396  }
1397 
1398  /*2. compute contact condition*/
1399  for(int i=0;i<NUMVERTICES;i++){
1400  /*If was grounded*/
1401  if (phi[i]>=0.){
1402  NormalBase(&bed_normal[0],xyz_list);
1403  sigma_nn[i]=-1*(sigmaxx[i]*bed_normal[0]*bed_normal[0] + sigmayy[i]*bed_normal[1]*bed_normal[1]+2*sigmaxy[i]*bed_normal[0]*bed_normal[1]);
1404  water_pressure[i]=-gravity*rho_water*base[i];
1405  vertex_sigmann->SetValue(vertices[i]->Pid(),sigma_nn[i],ADD_VAL);
1406  vertex_waterpressure->SetValue(vertices[i]->Pid(),water_pressure[i],ADD_VAL);
1407  }
1408  /*If was floating*/
1409  else{
1410  /*Tricky part:
1411  * 1. if base is now touching, we put 1 for sigma_nn and leave water pressure at 0 so that the rest of the module will reground this vertex
1412  * 2. if base is still above bed, water pressure is set as 1, sigma_nn is left as 0, so the GL module will keep it afloat*/
1413  if(base[i]<bed[i]) vertex_sigmann->SetValue(vertices[i]->Pid(),+1.,ADD_VAL);
1414  vertex_waterpressure->SetValue(vertices[i]->Pid(),+1.,ADD_VAL);
1415  }
1416  }
1417 
1418  /*clean up*/
1419  delete gauss;
1420  xDelete<IssmDouble>(xyz_list);
1421 }
1422 /*}}}*/
1423 IssmDouble Tria::GetArea(void){/*{{{*/
1424 
1425  IssmDouble xyz_list[NUMVERTICES][3];
1426  IssmDouble x1,y1,x2,y2,x3,y3;
1427 
1428  /*Get xyz list: */
1429  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
1430  x1=xyz_list[0][0]; y1=xyz_list[0][1];
1431  x2=xyz_list[1][0]; y2=xyz_list[1][1];
1432  x3=xyz_list[2][0]; y3=xyz_list[2][1];
1433 
1434  _assert_(x2*y3 - y2*x3 + x1*y2 - y1*x2 + x3*y1 - y3*x1>0);
1435  return (x2*y3 - y2*x3 + x1*y2 - y1*x2 + x3*y1 - y3*x1)/2;
1436 }
1437 /*}}}*/
1438 IssmDouble Tria::GetHorizontalSurfaceArea(void){/*{{{*/
1439 
1440  return this->GetArea();
1441 }
1442 /*}}}*/
1443 IssmDouble Tria::GetArea3D(void){/*{{{*/
1444 
1445  IssmDouble xyz_list[NUMVERTICES][3];
1446  IssmDouble x1,y1,z1,x2,y2,z2,x3,y3,z3;
1447  IssmDouble detm1,detm2,detm3;
1448 
1449  /*Get xyz list: */
1450  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
1451  x1=xyz_list[0][0]; y1=xyz_list[0][1]; z1=xyz_list[0][2];
1452  x2=xyz_list[1][0]; y2=xyz_list[1][1]; z2=xyz_list[1][2];
1453  x3=xyz_list[2][0]; y3=xyz_list[2][1]; z3=xyz_list[2][2];
1454 
1455  detm1=x1*y2 - x2*y1 - x1*y3 + x3*y1 + x2*y3 - x3*y2;
1456  detm2=y1*z2 - y2*z1 - y1*z3 + y3*z1 + y2*z3 - y3*z2;
1457  detm3=x2*z1 - x1*z2 + x1*z3 - x3*z1 - x2*z3 + x3*z2;
1458 
1459  return sqrt(pow(detm1,2) + pow(detm2,2) + pow(detm3,2))/2;
1460 }
1461 /*}}}*/
1462 IssmDouble Tria::GetAreaIce(void){/*{{{*/
1463 
1464  /*return area of element covered by ice*/
1465  /*Intermediaries*/
1466  int numiceverts;
1467  IssmDouble area_fraction;
1468  IssmDouble s[2]; // s:fraction of intersected triangle edges that lie inside ice
1469  int* indices=NULL;
1470 
1471  this->GetLevelsetIntersection(&indices, &numiceverts, s, MaskIceLevelsetEnum, 0.);
1472 
1473  switch (numiceverts){
1474  case 0: // no vertex has ice: element is ice free
1475  area_fraction=0.;
1476  break;
1477  case 1: // one vertex has ice: get area of triangle
1478  area_fraction=s[0]*s[1];
1479  break;
1480  case 2: // two vertices have ice: get area of quadrangle
1481  area_fraction=s[0]+s[1]-s[0]*s[1];
1482  break;
1483  case NUMVERTICES: // all vertices have ice: return triangle area
1484  area_fraction=1.;
1485  break;
1486  default:
1487  _error_("Wrong number of ice vertices in Tria::GetAreaIce!");
1488  break;
1489  }
1490  _assert_((area_fraction>=0.) && (area_fraction<=1.));
1491 
1492  xDelete<int>(indices);
1493  return area_fraction*this->GetArea();
1494 }/*}}}*/
1495 IssmDouble Tria::GetAreaSpherical(void){/*{{{*/
1496 
1497  bool spherical=true;
1498  IssmDouble llr_list[NUMVERTICES][3];
1499  IssmDouble x1,y1,z1,x2,y2,z2,x3,y3,z3;
1500  IssmDouble arc12,arc23,arc31,semi_peri,excess;
1501 
1502  /*retrieve coordinates: lat,long,radius */
1503  ::GetVerticesCoordinates(&llr_list[0][0],vertices,NUMVERTICES,spherical);
1504  x1=llr_list[0][0]/180*PI; y1=llr_list[0][1]/180*PI; z1=llr_list[0][2];
1505  x2=llr_list[1][0]/180*PI; y2=llr_list[1][1]/180*PI; z2=llr_list[1][2];
1506  x3=llr_list[2][0]/180*PI; y3=llr_list[2][1]/180*PI; z3=llr_list[2][2];
1507 
1508  /*compute great circle distance between vertices */
1509  arc12=2.*asin(sqrt(pow(sin((x2-x1)/2),2.0)+cos(x1)*cos(x2)*pow(sin((y2-y1)/2),2)));
1510  arc23=2.*asin(sqrt(pow(sin((x3-x2)/2),2.0)+cos(x2)*cos(x3)*pow(sin((y3-y2)/2),2)));
1511  arc31=2.*asin(sqrt(pow(sin((x1-x3)/2),2.0)+cos(x3)*cos(x1)*pow(sin((y1-y3)/2),2)));
1512 
1513  /*semi parameter */
1514  semi_peri=(arc12+arc23+arc31)/2;
1515 
1516  /*spherical excess */
1517  excess=4.*atan(sqrt(tan(semi_peri/2)*tan((semi_peri-arc12)/2)*tan((semi_peri-arc23)/2)*tan((semi_peri-arc31)/2)));
1518 
1519  /*area = excess*radius^2 */
1520  return excess*pow((z1+z2+z3)/3,2);
1521 }
1522 /*}}}*/
1523 void Tria::GetAreaCoordinates(IssmDouble* area_coordinates,IssmDouble* xyz_zero,IssmDouble* xyz_list,int numpoints){/*{{{*/
1524  /*Computeportion of the element that is grounded*/
1525 
1526  int i,j,k;
1527  IssmDouble area_init,area_portion;
1528  IssmDouble xyz_bis[NUMVERTICES][3];
1529 
1530  area_init=GetArea();
1531 
1532  /*Initialize xyz_list with original xyz_list of triangle coordinates*/
1533  for(j=0;j<3;j++){
1534  for(k=0;k<3;k++){
1535  xyz_bis[j][k]=xyz_list[j*3+k];
1536  }
1537  }
1538  for(i=0;i<numpoints;i++){
1539  for(j=0;j<3;j++){
1540  for(k=0;k<3;k++){
1541  /*Change appropriate line*/
1542  xyz_bis[j][k]=xyz_zero[i*3+k];
1543  }
1544 
1545  /*Compute area fraction*/
1546  area_portion=fabs(xyz_bis[1][0]*xyz_bis[2][1] - xyz_bis[1][1]*xyz_bis[2][0] + xyz_bis[0][0]*xyz_bis[1][1] - xyz_bis[0][1]*xyz_bis[1][0] + xyz_bis[2][0]*xyz_bis[0][1] - xyz_bis[2][1]*xyz_bis[0][0])/2.;
1547  *(area_coordinates+3*i+j)=area_portion/area_init;
1548 
1549  /*Reinitialize xyz_list*/
1550  for(k=0;k<3;k++){
1551  /*Reinitialize xyz_list with original coordinates*/
1552  xyz_bis[j][k]=xyz_list[j*3+k];
1553  }
1554  }
1555  }
1556 }
1557 /*}}}*/
1558 int Tria::GetElementType(){/*{{{*/
1559 
1560  /*return TriaRef field*/
1561  return this->element_type;
1562 
1563 }
1564 /*}}}*/
1565 void Tria::GetGroundedPart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlyfloating){/*{{{*/
1566  /*Computeportion of the element that is grounded*/
1567 
1568  bool floating=true;
1569  int point;
1570  const IssmPDouble epsilon= 1.e-15;
1571  IssmDouble gl[NUMVERTICES];
1572  IssmDouble f1,f2;
1573 
1574  /*Recover parameters and values*/
1575  Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
1576 
1577  /*Be sure that values are not zero*/
1578  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
1579  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
1580  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
1581 
1582  /*Check that not all nodes are grounded or floating*/
1583  if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All grounded
1584  point=0;
1585  f1=1.;
1586  f2=1.;
1587  }
1588  else if(gl[0]<0 && gl[1]<0 && gl[2]<0){ //All floating
1589  point=0;
1590  f1=0.;
1591  f2=0.;
1592  }
1593  else{
1594  if(gl[0]*gl[1]*gl[2]<0) floating=false;
1595 
1596  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
1597  point=2;
1598  f1=gl[2]/(gl[2]-gl[0]);
1599  f2=gl[2]/(gl[2]-gl[1]);
1600  }
1601  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
1602  point=0;
1603  f1=gl[0]/(gl[0]-gl[1]);
1604  f2=gl[0]/(gl[0]-gl[2]);
1605  }
1606  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
1607  point=1;
1608  f1=gl[1]/(gl[1]-gl[2]);
1609  f2=gl[1]/(gl[1]-gl[0]);
1610  }
1611  else _error_("case not possible");
1612  }
1613  *point1=point;
1614  *fraction1=f1;
1615  *fraction2=f2;
1616  *mainlyfloating=floating;
1617 }
1618 /*}}}*/
1619 IssmDouble Tria::GetGroundedPortion(IssmDouble* xyz_list){/*{{{*/
1620  /*Computeportion of the element that is grounded*/
1621 
1622  bool mainlyfloating = true;
1623  int domaintype,index1,index2;
1624  const IssmPDouble epsilon = 1.e-15;
1625  IssmDouble phi,s1,s2,area_init,area_grounded;
1626  IssmDouble gl[NUMVERTICES];
1627  IssmDouble xyz_bis[3][3];
1628 
1629  /*Recover parameters and values*/
1630  parameters->FindParam(&domaintype,DomainTypeEnum);
1631  Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
1632 
1633  /*Be sure that values are not zero*/
1634  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
1635  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
1636  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
1637 
1638  if(domaintype==Domain2DverticalEnum){
1639  this->EdgeOnBaseIndices(&index1,&index2);
1640  if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded
1641  else if(gl[index1]<0 && gl[index2]<0) phi=0; // All floating
1642  else if(gl[index1]<0 && gl[index2]>0){ //index2 grounded
1643  phi=1./(1.-gl[index1]/gl[index2]);
1644  }
1645  else if(gl[index2]<0 && gl[index1]>0){ //index1 grounded
1646  phi=1./(1.-gl[index2]/gl[index1]);
1647  }
1648 
1649  }
1650  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
1651  /*Check that not all nodes are grounded or floating*/
1652  if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All grounded
1653  phi=1;
1654  }
1655  else if(gl[0]<0 && gl[1]<0 && gl[2]<0){ //All floating
1656  phi=0;
1657  }
1658  else{
1659  /*Figure out if two nodes are floating or grounded*/
1660  if(gl[0]*gl[1]*gl[2]>0) mainlyfloating=false;
1661 
1662  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
1663  /*Coordinates of point 2: same as initial point 2*/
1664  xyz_bis[2][0]=xyz_list[3*2+0];
1665  xyz_bis[2][1]=xyz_list[3*2+1];
1666  xyz_bis[2][2]=xyz_list[3*2+2];
1667 
1668  /*Portion of the segments*/
1669  s1=gl[2]/(gl[2]-gl[1]);
1670  s2=gl[2]/(gl[2]-gl[0]);
1671 
1672  /*New point 1*/
1673  xyz_bis[1][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
1674  xyz_bis[1][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
1675  xyz_bis[1][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
1676 
1677  /*New point 0*/
1678  xyz_bis[0][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
1679  xyz_bis[0][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
1680  xyz_bis[0][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
1681  }
1682  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
1683  /*Coordinates of point 0: same as initial point 2*/
1684  xyz_bis[0][0]=xyz_list[3*0+0];
1685  xyz_bis[0][1]=xyz_list[3*0+1];
1686  xyz_bis[0][2]=xyz_list[3*0+2];
1687 
1688  /*Portion of the segments*/
1689  s1=gl[0]/(gl[0]-gl[1]);
1690  s2=gl[0]/(gl[0]-gl[2]);
1691 
1692  /*New point 1*/
1693  xyz_bis[1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
1694  xyz_bis[1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
1695  xyz_bis[1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
1696 
1697  /*New point 2*/
1698  xyz_bis[2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
1699  xyz_bis[2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
1700  xyz_bis[2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
1701  }
1702  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
1703  /*Coordinates of point 1: same as initial point 2*/
1704  xyz_bis[1][0]=xyz_list[3*1+0];
1705  xyz_bis[1][1]=xyz_list[3*1+1];
1706  xyz_bis[1][2]=xyz_list[3*1+2];
1707 
1708  /*Portion of the segments*/
1709  s1=gl[1]/(gl[1]-gl[0]);
1710  s2=gl[1]/(gl[1]-gl[2]);
1711 
1712  /*New point 0*/
1713  xyz_bis[0][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
1714  xyz_bis[0][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
1715  xyz_bis[0][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
1716 
1717  /*New point 2*/
1718  xyz_bis[2][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
1719  xyz_bis[2][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
1720  xyz_bis[2][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
1721  }
1722  else _error_("case not possible");
1723 
1724  /*Compute fraction of grounded element*/
1725  if(domaintype==Domain3DsurfaceEnum){ //hack, need to be implemented in a Tria 3D
1726  GetJacobianDeterminant3D(&area_init, xyz_list,NULL);
1727  GetJacobianDeterminant3D(&area_grounded, &xyz_bis[0][0],NULL);
1728  }
1729  else{
1730  GetJacobianDeterminant(&area_init, xyz_list,NULL);
1731  GetJacobianDeterminant(&area_grounded, &xyz_bis[0][0],NULL);
1732  }
1733  if(mainlyfloating==true) area_grounded=area_init-area_grounded;
1734  phi=area_grounded/area_init;
1735  }
1736  }
1737  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
1738 
1739  if(phi>1 || phi<0) _error_("Error. Problem with portion of grounded element: value should be between 0 and 1");
1740 
1741  return phi;
1742 }
1743 /*}}}*/
1744 IssmDouble Tria::GetIcefrontArea(){/*{{{*/
1745 
1746  IssmDouble bed[NUMVERTICES]; //basinId[NUMVERTICES];
1747  IssmDouble Haverage,frontarea;
1748  IssmDouble x1,y1,x2,y2,distance;
1749  IssmDouble lsf[NUMVERTICES], Haux[NUMVERTICES], surfaces[NUMVERTICES], bases[NUMVERTICES];
1750  int* indices=NULL;
1751  IssmDouble* H=NULL;;
1752  int nrfrontbed,numiceverts;
1753 
1754  if(!IsZeroLevelset(MaskIceLevelsetEnum)) return 0;
1755 
1756  /*Retrieve all inputs and parameters*/
1757  Element::GetInputListOnVertices(&bed[0],BedEnum);
1758  Element::GetInputListOnVertices(&surfaces[0],SurfaceEnum);
1759  Element::GetInputListOnVertices(&bases[0],BaseEnum);
1760  Element::GetInputListOnVertices(&lsf[0],MaskIceLevelsetEnum);
1761 
1762  nrfrontbed=0;
1763  for(int i=0;i<NUMVERTICES;i++){
1764  /*Find if bed<0*/
1765  if(bed[i]<0.) nrfrontbed++;
1766  }
1767 
1768  if(nrfrontbed==3){
1769  /*2. Find coordinates of where levelset crosses 0*/
1770  int numiceverts;
1771  IssmDouble s[2],x[2],y[2];
1772  this->GetLevelsetIntersection(&indices, &numiceverts,&s[0],MaskIceLevelsetEnum,0.);
1773  _assert_(numiceverts);
1774 
1775  /*3 Write coordinates*/
1776  IssmDouble xyz_list[NUMVERTICES][3];
1777  ::GetVerticesCoordinates(&xyz_list[0][0],this->vertices,NUMVERTICES);
1778  int counter = 0;
1779  if((numiceverts>0) && (numiceverts<NUMVERTICES)){
1780  for(int i=0;i<numiceverts;i++){
1781  for(int n=numiceverts;n<NUMVERTICES;n++){ // iterate over no-ice vertices
1782  x[counter] = xyz_list[indices[i]][0]+s[counter]*(xyz_list[indices[n]][0]-xyz_list[indices[i]][0]);
1783  y[counter] = xyz_list[indices[i]][1]+s[counter]*(xyz_list[indices[n]][1]-xyz_list[indices[i]][1]);
1784  counter++;
1785  }
1786  }
1787  }
1788  else if(numiceverts==NUMVERTICES){ //NUMVERTICES ice vertices: calving front lies on element edge
1789 
1790  for(int i=0;i<NUMVERTICES;i++){
1791  if(lsf[indices[i]]==0.){
1792  x[counter]=xyz_list[indices[i]][0];
1793  y[counter]=xyz_list[indices[i]][1];
1794  counter++;
1795  }
1796  if(counter==2) break;
1797  }
1798  if(counter==1){
1799  /*We actually have only 1 vertex on levelset, write a single point as a segment*/
1800  x[counter]=x[0];
1801  y[counter]=y[0];
1802  counter++;
1803  }
1804  }
1805  else{
1806  _error_("not sure what's going on here...");
1807  }
1808  x1=x[0]; y1=y[0]; x2=x[1]; y2=y[1];
1809  distance=sqrt(pow((x1-x2),2)+pow((y1-y2),2));
1810 
1811  int numthk=numiceverts+2;
1812  H=xNew<IssmDouble>(numthk);
1813  for(int iv=0;iv<NUMVERTICES;iv++) Haux[iv]=-bed[indices[iv]]; //sort bed in ice/noice
1814 
1815  switch(numiceverts){
1816  case 1: // average over triangle
1817  H[0]=Haux[0];
1818  H[1]=Haux[0]+s[0]*(Haux[1]-Haux[0]);
1819  H[2]=Haux[0]+s[1]*(Haux[2]-Haux[0]);
1820  Haverage=(H[1]+H[2])/2;
1821  break;
1822  case 2: // average over quadrangle
1823  H[0]=Haux[0];
1824  H[1]=Haux[1];
1825  H[2]=Haux[0]+s[0]*(Haux[2]-Haux[0]);
1826  H[3]=Haux[1]+s[1]*(Haux[2]-Haux[1]);
1827  Haverage=(H[2]+H[3])/2;
1828  break;
1829  default:
1830  _error_("Number of ice covered vertices wrong in Tria::GetIceFrontArea(void)");
1831  break;
1832  }
1833  frontarea=distance*Haverage;
1834  }
1835  else return 0;
1836 
1837  xDelete<int>(indices);
1838  xDelete<IssmDouble>(H);
1839 
1840  _assert_(frontarea>0);
1841  return frontarea;
1842 }
1843 /*}}}*/
1844 void Tria::GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum){/*{{{*/
1845 
1846  /* Intermediaries */
1847  IssmDouble levelset[NUMVERTICES];
1848  int indicesfront[NUMVERTICES];
1849 
1850  /*Recover parameters and values*/
1851  Element::GetInputListOnVertices(&levelset[0],levelsetenum);
1852 
1853  /* Get nodes where there is no ice */
1854  int num_frontnodes=0;
1855  for(int i=0;i<NUMVERTICES;i++){
1856  if(levelset[i]>=0.){
1857  indicesfront[num_frontnodes]=i;
1858  num_frontnodes++;
1859  }
1860  }
1861  _assert_(num_frontnodes==2);
1862 
1863  /* arrange order of frontnodes such that they are oriented counterclockwise */
1864  if((NUMVERTICES+indicesfront[0]-indicesfront[1])%NUMVERTICES!=NUMVERTICES-1){
1865  int index=indicesfront[0];
1866  indicesfront[0]=indicesfront[1];
1867  indicesfront[1]=index;
1868  }
1869 
1870  IssmDouble* xyz_front = xNew<IssmDouble>(3*2);
1871  /* Return nodes */
1872  for(int i=0;i<2;i++){
1873  for(int j=0;j<3;j++){
1874  xyz_front[3*i+j]=xyz_list[3*indicesfront[i]+j];
1875  }
1876  }
1877 
1878  *pxyz_front=xyz_front;
1879 }/*}}}*/
1880 Input2* Tria::GetInput2(int inputenum){/*{{{*/
1881 
1882  /*Get Input from dataset*/
1883  if(this->iscollapsed){
1884  PentaInput2* input = this->inputs2->GetPentaInput(inputenum);
1885  if(!input) return input;
1886 
1887  this->InputServe(input);
1888  return input;
1889  }
1890  else{
1891  TriaInput2* input = this->inputs2->GetTriaInput(inputenum);
1892  if(!input) return input;
1893 
1894  this->InputServe(input);
1895  return input;
1896  }
1897 }/*}}}*/
1898 Input2* Tria::GetInput2(int inputenum,IssmDouble time){/*{{{*/
1899 
1900  /*Get Input from dataset*/
1901  if(this->iscollapsed){
1902  PentaInput2* input = this->inputs2->GetPentaInput(inputenum,time);
1903  if(!input) return input;
1904 
1905  this->InputServe(input);
1906  return input;
1907  }
1908  else{
1909  TriaInput2* input = this->inputs2->GetTriaInput(inputenum,time);
1910  if(!input) return input;
1911 
1912  this->InputServe(input);
1913  return input;
1914  }
1915 }/*}}}*/
1916 Input2* Tria::GetInput2(int inputenum,IssmDouble start_time, IssmDouble end_time, int averaging_method){/*{{{*/
1917 
1918  /*Get Input from dataset*/
1919  if(this->iscollapsed){
1920  PentaInput2* input = this->inputs2->GetPentaInput(inputenum,start_time,end_time,averaging_method);
1921  if(!input) return input;
1922 
1923  this->InputServe(input);
1924  return input;
1925  }
1926  else{
1927  TriaInput2* input = this->inputs2->GetTriaInput(inputenum,start_time,end_time,averaging_method);
1928  if(!input) return input;
1929 
1930  this->InputServe(input);
1931  return input;
1932  }
1933 }/*}}}*/
1934 void Tria::GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
1935 
1936  /*Checks in debugging mode*/
1937  _assert_(pvalue);
1938 
1939  /* Start looping on the number of vertices: */
1940  if(input){
1941  GaussTria gauss;
1942  for(int iv=0;iv<NUMVERTICES;iv++){
1943  gauss.GaussVertex(iv);
1944  input->GetInputValue(&pvalue[iv],&gauss);
1945  }
1946  }
1947  else{
1948  for(int iv=0;iv<NUMVERTICES;iv++) pvalue[iv] = default_value;
1949  }
1950 }
1951 /*}}}*/
1952 void Tria::GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
1953 
1954  /*Checks in debugging mode*/
1955  _assert_(pvalue);
1956 
1957  /*What type of finite element are we dealing with?*/
1958  int fe = this->FiniteElement();
1959  int numnodes = this->GetNumberOfNodes();
1960 
1961  /* Start looping on the number of vertices: */
1962  if(input){
1963  GaussTria gauss;
1964  for(int iv=0;iv<numnodes;iv++){
1965  gauss.GaussNode(fe,iv);
1966  input->GetInputValue(&pvalue[iv],&gauss);
1967  }
1968  }
1969  else{
1970  for(int iv=0;iv<numnodes;iv++) pvalue[iv] = default_value;
1971  }
1972 }
1973 /*}}}*/
1974 void Tria::InputServe(Input2* input_in){/*{{{*/
1975 
1976  /*Return NULL pointer if input is NULL*/
1977  if(!input_in) return;
1978 
1979  /*Get Input from dataset*/
1980  if(this->iscollapsed){
1981  _assert_(input_in->ObjectEnum()==PentaInput2Enum);
1982  PentaInput2* input = xDynamicCast<PentaInput2*>(input_in);
1983 
1984  /*Intermediaries*/
1985  int numindices;
1986  int indices[3];
1987 
1988  /*Check interpolation*/
1989  int interpolation = input->GetInterpolation();
1990  switch(interpolation){
1991  case P0Enum:
1992  numindices = 1;
1993  indices[0] = this->lid;
1994  input->Serve(numindices,&indices[0]);
1995  break;
1996  case P1Enum:
1997  numindices = 3;
1998  for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
1999  input->Serve(numindices,&indices[0]);
2000  break;
2001  case P1DGEnum:
2002  case P1bubbleEnum:
2003  input->ServeCollapsed(this->lid,this->iscollapsed);
2004  break;
2005  default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
2006  }
2007 
2008  /*Flag as collapsed for later use*/
2009  input->SetServeCollapsed(true);
2010  return;
2011  }
2012  else{
2013  _assert_(input_in->ObjectEnum()==TriaInput2Enum);
2014  TriaInput2* input = xDynamicCast<TriaInput2*>(input_in);
2015 
2016  /*Intermediaries*/
2017  int numindices;
2018  int indices[7];
2019 
2020  /*Check interpolation*/
2021  int interpolation = input->GetInterpolation();
2022  switch(interpolation){
2023  case P0Enum:
2024  numindices = 1;
2025  indices[0] = this->lid;
2026  input->Serve(numindices,&indices[0]);
2027  break;
2028  case P1Enum:
2029  numindices = 3;
2030  for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
2031  input->Serve(numindices,&indices[0]);
2032  break;
2033  case P1DGEnum:
2034  numindices = 3;
2035  input->Serve(this->lid,numindices);
2036  break;
2037  default:
2038  input->Serve(this->lid,this->GetNumberOfNodes(interpolation));
2039  break;
2040  }
2041  return;
2042  }
2043 }/*}}}*/
2044 DatasetInput2* Tria::GetDatasetInput2(int inputenum){/*{{{*/
2045 
2046  DatasetInput2* datasetinput = this->inputs2->GetDatasetInput2(inputenum);
2047  if(!datasetinput) return NULL;
2048 
2049  for(int i=0;i<datasetinput->GetNumIds();i++){
2050 
2051  /*Get Input from dataset*/
2052  if(this->iscollapsed){
2053 
2054  PentaInput2* input = datasetinput->GetPentaInputByOffset(i); _assert_(input);
2055 
2056  /*Intermediaries*/
2057  int numindices;
2058  int indices[3];
2059 
2060  /*Check interpolation*/
2061  int interpolation = input->GetInterpolation();
2062  switch(interpolation){
2063  case P0Enum:
2064  numindices = 1;
2065  indices[0] = this->lid;
2066  input->Serve(numindices,&indices[0]);
2067  break;
2068  case P1Enum:
2069  numindices = 3;
2070  for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
2071  input->Serve(numindices,&indices[0]);
2072  break;
2073  case P1DGEnum:
2074  case P1bubbleEnum:
2075  input->ServeCollapsed(this->lid,this->iscollapsed);
2076  break;
2077  default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
2078  }
2079 
2080  /*Flag as collapsed for later use*/
2081  input->SetServeCollapsed(true);
2082  }
2083  else{
2084 
2085  TriaInput2* input = datasetinput->GetTriaInputByOffset(i); _assert_(input);
2086 
2087  /*Intermediaries*/
2088  int numindices;
2089  int indices[7];
2090 
2091  /*Check interpolation*/
2092  int interpolation = input->GetInterpolation();
2093  switch(interpolation){
2094  case P0Enum:
2095  numindices = 1;
2096  indices[0] = this->lid;
2097  input->Serve(numindices,&indices[0]);
2098  break;
2099  case P1Enum:
2100  numindices = 3;
2101  for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
2102  input->Serve(numindices,&indices[0]);
2103  break;
2104  case P1DGEnum:
2105  numindices = 3;
2106  input->Serve(this->lid,numindices);
2107  break;
2108  default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
2109  }
2110 
2111  }
2112  }
2113 
2114  return datasetinput;
2115 }/*}}}*/
2116 void Tria::CreateInputTimeAverage(int transientinput_enum,int averagedinput_enum,IssmDouble start_time,IssmDouble end_time, int averaging_method){/*{{{*/
2117 
2118  _assert_(end_time>start_time);
2119 
2120  /*Get transient input time steps*/
2121  TransientInput2* transient_input = this->inputs2->GetTransientInput(transientinput_enum);
2122  TriaInput2* averaged_input = transient_input->GetTriaInput(start_time,end_time,averaging_method);
2123  Input2* averaged_copy = averaged_input->copy();
2124 
2125  averaged_copy->ChangeEnum(averagedinput_enum);
2126  this->inputs2->AddInput(averaged_copy);
2127 }
2128 /*}}}*/
2129 void Tria::GetInputAveragesUpToCurrentTime(int input_enum,IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){/*{{{*/
2130 
2131  /*Get transient input time steps*/
2132  int numtimesteps;
2133  IssmDouble *timesteps = NULL;
2134  TransientInput2* transient_input = this->inputs2->GetTransientInput(input_enum);
2135 
2136  transient_input->GetAllTimes(&timesteps,&numtimesteps);
2137 
2138  /*Figure out how many time steps we are going to return: */
2139  int numsteps = 0;
2140  bool iscurrenttime_included = false;
2141  for(int i=0;i<numtimesteps;i++){
2142  if(timesteps[i]==currenttime) iscurrenttime_included=true;
2143  if(timesteps[i]>currenttime) break;
2144  else numsteps++;
2145  }
2146  if(iscurrenttime_included==false)numsteps++;
2147 
2148  /*allocate: */
2149  IssmDouble* times=xNew<IssmDouble>(numsteps);
2150  IssmDouble* values=xNew<IssmDouble>(numsteps);
2151 
2152  for(int i=0;i<numsteps;i++){
2153  if((iscurrenttime_included==false) && (i==(numsteps-1))){
2154  Input2* input = this->GetInput2(input_enum,currenttime);
2155  input->GetInputAverage(&values[i]);
2156  times[i]=currenttime;
2157  }
2158  else{
2159  TriaInput2* input = transient_input->GetTriaInput(i);
2160  this->InputServe(input);
2161  input->GetInputAverage(&values[i]);
2162  times[i]=timesteps[i];
2163  }
2164  }
2165 
2166  /*Assign output pointers*/
2167  *pvalues=values;
2168  *ptimes=times;
2169  *pnumtimes=numtimesteps;
2170 }
2171 /*}}}*/
2172 void Tria::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){/*{{{*/
2173 
2174  Input2* input=this->GetInput2(enumtype);
2175  if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
2176 
2177  int index = this->GetNodeIndex(node);
2178 
2179  GaussTria* gauss=new GaussTria();
2180  gauss->GaussNode(this->element_type,index);
2181 
2182  input->GetInputValue(pvalue,gauss);
2183  delete gauss;
2184 }
2185 /*}}}*/
2186 void Tria::GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){/*{{{*/
2187 
2188  Input2* input=this->GetInput2(enumtype);
2189  if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
2190 
2191  int index = this->GetVertexIndex(vertex);
2192 
2193  GaussTria* gauss=new GaussTria();
2194  gauss->GaussVertex(index);
2195 
2196  input->GetInputValue(pvalue,gauss);
2197  delete gauss;
2198 }
2199 /*}}}*/
2200 void Tria::GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level){/*{{{*/
2201 
2202  /* Intermediaries */
2203  int i, dir,nrfrontnodes;
2204  IssmDouble levelset[NUMVERTICES];
2205  int indicesfront[NUMVERTICES];
2206 
2207  /*Recover parameters and values*/
2208  Element::GetInputListOnVertices(&levelset[0],levelsetenum);
2209 
2210  /* Get nodes where there is no ice */
2211  nrfrontnodes=0;
2212  for(i=0;i<NUMVERTICES;i++){
2213  if(levelset[i]==level){
2214  indicesfront[nrfrontnodes]=i;
2215  nrfrontnodes++;
2216  }
2217  }
2218 
2219  _assert_(nrfrontnodes==2);
2220 
2221  /* arrange order of frontnodes such that they are oriented counterclockwise */
2222  if((NUMVERTICES+indicesfront[0]-indicesfront[1])%NUMVERTICES!=NUMVERTICES-1){
2223  int index=indicesfront[0];
2224  indicesfront[0]=indicesfront[1];
2225  indicesfront[1]=index;
2226  }
2227 
2228  IssmDouble* xyz_front = xNew<IssmDouble>(3*nrfrontnodes);
2229  /* Return nodes */
2230  for(i=0;i<nrfrontnodes;i++){
2231  for(dir=0;dir<3;dir++){
2232  xyz_front[3*i+dir]=xyz_list[3*indicesfront[i]+dir];
2233  }
2234  }
2235 
2236  *pxyz_front=xyz_front;
2237 
2238 }/*}}}*/
2239 void Tria::GetLevelsetIntersection(int** pindices, int* pnumiceverts, IssmDouble* fraction, int levelset_enum, IssmDouble level){/*{{{*/
2240 
2241  /* GetLevelsetIntersection computes:
2242  * 1. indices of element, sorted in [iceverts, noiceverts] in counterclockwise fashion,
2243  * 2. fraction of intersected triangle edges intersected by levelset, lying below level*/
2244 
2245  /*Intermediaries*/
2246  int i, numiceverts, numnoiceverts;
2247  int ind0, ind1, lastindex;
2248  int indices_ice[NUMVERTICES],indices_noice[NUMVERTICES];
2249  IssmDouble lsf[NUMVERTICES];
2250  int* indices = xNew<int>(NUMVERTICES);
2251 
2252  /*Retrieve all inputs and parameters*/
2253  Element::GetInputListOnVertices(&lsf[0],levelset_enum);
2254 
2255  /* Determine distribution of ice over element.
2256  * Exploit: ice/no-ice parts are connected, so find starting vertex of segment*/
2257  lastindex=0;
2258  for(i=0;i<NUMVERTICES;i++){ // go backwards along vertices, and check for sign change
2259  ind0=(NUMVERTICES-i)%NUMVERTICES;
2260  ind1=(ind0-1+NUMVERTICES)%NUMVERTICES;
2261  if((lsf[ind0]-level)*(lsf[ind1]-level)<=0.){ // levelset has been crossed, find last index belonging to segment
2262  if(lsf[ind1]==level) //if levelset intersects 2nd vertex, choose this vertex as last
2263  lastindex=ind1;
2264  else
2265  lastindex=ind0;
2266  break;
2267  }
2268  }
2269 
2270  numiceverts=0;
2271  numnoiceverts=0;
2272  for(i=0;i<NUMVERTICES;i++){
2273  ind0=(lastindex+i)%NUMVERTICES;
2274  if(lsf[i]<=level){
2275  indices_ice[numiceverts]=i;
2276  numiceverts++;
2277  }
2278  else{
2279  indices_noice[numnoiceverts]=i;
2280  numnoiceverts++;
2281  }
2282  }
2283  //merge indices
2284  for(i=0;i<numiceverts;i++){indices[i]=indices_ice[i];}
2285  for(i=0;i<numnoiceverts;i++){indices[numiceverts+i]=indices_noice[i];}
2286 
2287  switch (numiceverts){
2288  case 0: // no vertex has ice: element is ice free, no intersection
2289  for(i=0;i<2;i++)
2290  fraction[i]=0.;
2291  break;
2292  case 1: // one vertex has ice:
2293  for(i=0;i<2;i++){
2294  fraction[i]=(level-lsf[indices[0]])/(lsf[indices[numiceverts+i]]-lsf[indices[0]]);
2295  }
2296  break;
2297  case 2: // two vertices have ice: fraction is computed from first ice vertex to last in CCW fashion
2298  for(i=0;i<2;i++){
2299  fraction[i]=(level-lsf[indices[i]])/(lsf[indices[numiceverts]]-lsf[indices[i]]);
2300  }
2301  break;
2302  case NUMVERTICES: // all vertices have ice: return triangle area
2303  for(i=0;i<2;i++)
2304  fraction[i]=1.;
2305  break;
2306  default:
2307  _error_("Wrong number of ice vertices in Tria::GetLevelsetIntersection!");
2308  break;
2309  }
2310 
2311  *pindices=indices;
2312  *pnumiceverts=numiceverts;
2313 }
2314 /*}}}*/
2315 void Tria::GetLevelsetPositivePart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlynegative,IssmDouble* gl){/*{{{*/
2316 
2317  /*Computeportion of the element that has a positive levelset*/
2318 
2319  bool negative=true;
2320  int point=0;
2321  const IssmPDouble epsilon= 1.e-15;
2322  IssmDouble f1,f2;
2323 
2324  /*Be sure that values are not zero*/
2325  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
2326  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
2327  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
2328 
2329  /*Check that not all nodes are positive or negative*/
2330  if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All positive
2331  point=0;
2332  f1=1.;
2333  f2=1.;
2334  }
2335  else if(gl[0]<0 && gl[1]<0 && gl[2]<0){ //All negative
2336  point=0;
2337  f1=0.;
2338  f2=0.;
2339  }
2340  else{
2341  if(gl[0]*gl[1]*gl[2]<0) negative=false;
2342 
2343  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
2344  point=2;
2345  f1=gl[2]/(gl[2]-gl[0]);
2346  f2=gl[2]/(gl[2]-gl[1]);
2347  }
2348  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
2349  point=0;
2350  f1=gl[0]/(gl[0]-gl[1]);
2351  f2=gl[0]/(gl[0]-gl[2]);
2352  }
2353  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
2354  point=1;
2355  f1=gl[1]/(gl[1]-gl[2]);
2356  f2=gl[1]/(gl[1]-gl[0]);
2357  }
2358  else{
2359  _error_("This case should NOT be happening");
2360  }
2361  }
2362  *point1=point;
2363  *fraction1=f1;
2364  *fraction2=f2;
2365  *mainlynegative=negative;
2366 }
2367 /*}}}*/
2368 int Tria::GetVertexIndex(Vertex* vertex){/*{{{*/
2369  _assert_(vertices);
2370  for(int i=0;i<NUMVERTICES;i++){
2371  if(vertex==vertices[i])
2372  return i;
2373  }
2374  _error_("Vertex provided not found among element vertices");
2375 }
2376 /*}}}*/
2377 int Tria::GetNumberOfNodes(void){/*{{{*/
2378  if (this->nodes) return this->NumberofNodes(this->element_type);
2379  else return 0;
2380 }
2381 /*}}}*/
2382 int Tria::GetNumberOfNodes(int enum_type){/*{{{*/
2383  return this->NumberofNodes(enum_type);
2384 }
2385 /*}}}*/
2386 int Tria::GetNumberOfVertices(void){/*{{{*/
2387  return NUMVERTICES;
2388 }
2389 /*}}}*/
2390 void Tria::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data){/*{{{*/
2391 
2392  /*Get out if this is not an element input*/
2393  if(!IsInputEnum(control_enum)) _error_("Enum "<<EnumToStringx(control_enum)<<" is not in IsInput");
2394 
2395  /*Prepare index list*/
2396  int idlist[NUMVERTICES];
2397  GradientIndexing(&idlist[0],control_index);
2398 
2399  /*Get input (either in element or material)*/
2400  ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,data); _assert_(input);
2401 
2402  /*Intermediaries*/
2403  int numindices;
2404  int indices[NUMVERTICES];
2405 
2406  /*Check interpolation*/
2407  int interpolation = input->GetInterpolation();
2408  switch(interpolation){
2409  case P1Enum:
2410  numindices = NUMVERTICES;
2411  for(int i=0;i<NUMVERTICES;i++) indices[i] = vertices[i]->lid;
2412  input->Serve(numindices,&indices[0]);
2413  break;
2414  default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
2415  }
2416 
2417  /*Flag as collapsed for later use*/
2418  if(this->iscollapsed){
2419  xDynamicCast<PentaInput2*>(input)->SetServeCollapsed(true);
2420  }
2421 
2422  /* Start looping on the number of vertices: */
2423  IssmDouble values[NUMVERTICES];
2424  Gauss*gauss=this->NewGauss();
2425  for(int iv=0;iv<NUMVERTICES;iv++){
2426  gauss->GaussVertex(iv);
2427  input->GetInputValue(&values[iv],gauss);
2428  }
2429  delete gauss;
2430 
2431  vector->SetValues(NUMVERTICES,idlist,&values[0],INS_VAL);
2432 }
2433 /*}}}*/
2434 void Tria::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data,int offset){/*{{{*/
2435 
2436  /*Get input*/
2437  ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,data); _assert_(input);
2438 
2439  /*Lid list once for all*/
2440  int lidlist[NUMVERTICES];
2441  for(int i=0;i<NUMVERTICES;i++) lidlist[i] = vertices[i]->lid;
2442 
2443  /*Check what input we are dealing with*/
2444  switch(input->ObjectEnum()){
2445  case TriaInput2Enum:
2446  {
2447  IssmDouble values[NUMVERTICES];
2448  int idlist[NUMVERTICES];
2449 
2450  TriaInput2* triainput = xDynamicCast<TriaInput2*>(input);
2451  if(triainput->GetInputInterpolationType()!=P1Enum) _error_("not supported yet");
2452  input->Serve(NUMVERTICES,&lidlist[0]);
2453 
2454  /*Create list of indices and values for global vector*/
2455  GradientIndexing(&idlist[0],control_index);
2456  for(int i=0;i<NUMVERTICES;i++) values[i] = triainput->element_values[i];
2457  vector->SetValues(NUMVERTICES,idlist,values,INS_VAL);
2458  break;
2459  }
2460 
2461  case TransientInputEnum:
2462  {
2463  TransientInput2* transientinput = xDynamicCast<TransientInput2*>(input);
2464  int N = transientinput->numtimesteps;
2465  int* M=NULL;
2466  parameters->FindParam(&M,NULL,ControlInputSizeMEnum);
2467  int* idlist = xNew<int>(NUMVERTICES*N);
2468  IssmDouble* values = xNew<IssmDouble>(NUMVERTICES*N);
2469  for(int t=0;t<transientinput->numtimesteps;t++) {
2470  IssmDouble time = transientinput->GetTimeByOffset(t);
2471  _error_("not implemented");
2472  //TriaInput* timeinput = xDynamicCast<TriaInput*>(transientinput->GetTimeInput(time));
2473  //if(timeinput->interpolation_type!=P1Enum) _error_("not supported yet");
2474  //input->Serve(NUMVERTICES,&lidlist[0]);
2476  //for(int i=0;i<NUMVERTICES;i++){
2477  // idlist[N*i+t] = offset + this->vertices[i]->Sid()+t*M[control_index];
2478  // values[N*i+t] = timeinput->values[i];
2479  //}
2480  }
2481  vector->SetValues(NUMVERTICES*transientinput->numtimesteps,idlist,values,INS_VAL);
2482  xDelete<int>(M);
2483  xDelete<int>(idlist);
2484  xDelete<IssmDouble>(values);
2485  break;
2486  }
2487  default: _error_("input "<<EnumToStringx(input->ObjectEnum())<<" not supported yet");
2488  }
2489 }
2490 /*}}}*/
2491 void Tria::GetVerticesCoordinatesBase(IssmDouble** pxyz_list){/*{{{*/
2492 
2493  int indices[2];
2494  IssmDouble xyz_list[NUMVERTICES][3];
2495 
2496  /*Element XYZ list*/
2497  ::GetVerticesCoordinates(&xyz_list[0][0],this->vertices,NUMVERTICES);
2498 
2499  /*Allocate Output*/
2500  IssmDouble* xyz_list_edge = xNew<IssmDouble>(2*3);
2501  this->EdgeOnBaseIndices(&indices[0],&indices[1]);
2502  for(int i=0;i<2;i++) for(int j=0;j<2;j++) xyz_list_edge[i*3+j]=xyz_list[indices[i]][j];
2503 
2504  /*Assign output pointer*/
2505  *pxyz_list = xyz_list_edge;
2506 
2507 }/*}}}*/
2508 void Tria::GetVerticesCoordinatesTop(IssmDouble** pxyz_list){/*{{{*/
2509 
2510  int indices[2];
2511  IssmDouble xyz_list[NUMVERTICES][3];
2512 
2513  /*Element XYZ list*/
2514  ::GetVerticesCoordinates(&xyz_list[0][0],this->vertices,NUMVERTICES);
2515 
2516  /*Allocate Output*/
2517  IssmDouble* xyz_list_edge = xNew<IssmDouble>(2*3);
2518  this->EdgeOnSurfaceIndices(&indices[0],&indices[1]);
2519  for(int i=0;i<2;i++) for(int j=0;j<2;j++) xyz_list_edge[i*3+j]=xyz_list[indices[i]][j];
2520 
2521  /*Assign output pointer*/
2522  *pxyz_list = xyz_list_edge;
2523 
2524 }/*}}}*/
2525 IssmDouble Tria::GroundedArea(bool scaled){/*{{{*/
2526 
2527  /*Intermediaries*/
2528  int domaintype;
2529  IssmDouble phi,scalefactor,groundedarea;
2530  IssmDouble *xyz_list = NULL;
2531 
2532  if(!IsIceInElement())return 0.;
2533 
2534  /*Get problem dimension*/
2535  this->FindParam(&domaintype,DomainTypeEnum);
2536  if(domaintype!=Domain2DhorizontalEnum && domaintype!=Domain3DEnum) _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
2537 
2538  this->GetVerticesCoordinates(&xyz_list);
2539  phi=this->GetGroundedPortion(xyz_list);
2540  groundedarea=phi*this->GetArea();
2541  if(scaled==true){
2542  Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
2543  scalefactor_input->GetInputAverage(&scalefactor);
2544  groundedarea=groundedarea*scalefactor;
2545  }
2546 
2547  /*Clean up and return*/
2548  xDelete<IssmDouble>(xyz_list);
2549  return groundedarea;
2550 }
2551 /*}}}*/
2552 bool Tria::HasEdgeOnBase(){/*{{{*/
2553 
2554  IssmDouble values[NUMVERTICES];
2555  IssmDouble sum;
2556 
2557  /*Retrieve all inputs and parameters*/
2558  Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
2559  sum = values[0]+values[1]+values[2];
2560 
2561  _assert_(sum==0. || sum==1. || sum==2.);
2562 
2563  if(sum==3.) _error_("Two edges on bed not supported yet...");
2564 
2565  if(sum>1.){
2566  return true;
2567  }
2568  else{
2569  return false;
2570  }
2571 }
2572 /*}}}*/
2573 bool Tria::HasEdgeOnSurface(){/*{{{*/
2574 
2575  IssmDouble values[NUMVERTICES];
2576  IssmDouble sum;
2577 
2578  /*Retrieve all inputs and parameters*/
2579  Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
2580  sum = values[0]+values[1]+values[2];
2581 
2582  _assert_(sum==0. || sum==1. || sum==2.);
2583 
2584  if(sum==3.) _error_("Two edges on surface not supported yet...");
2585 
2586  if(sum>1.){
2587  return true;
2588  }
2589  else{
2590  return false;
2591  }
2592 }
2593 /*}}}*/
2594 IssmDouble Tria::IcefrontMassFlux(bool scaled){/*{{{*/
2595 
2596  /*Make sure there is an ice front here*/
2597  if(!IsIceInElement() || !IsIcefront()) return 0;
2598 
2599  /*Scaled not implemented yet...*/
2600  _assert_(!scaled);
2601 
2602  /*Get domain type*/
2603  int domaintype;
2604  parameters->FindParam(&domaintype,DomainTypeEnum);
2605 
2606  /*Get ice front coordinates*/
2607  IssmDouble *xyz_list = NULL;
2608  IssmDouble* xyz_front = NULL;
2609  this->GetVerticesCoordinates(&xyz_list);
2610  this->GetIcefrontCoordinates(&xyz_front,xyz_list,MaskIceLevelsetEnum);
2611 
2612  /*Get normal vector*/
2613  IssmDouble normal[3];
2614  this->NormalSection(&normal[0],xyz_front);
2615  //normal[0] = -normal[0];
2616  //normal[1] = -normal[1];
2617 
2618  /*Get inputs*/
2619  IssmDouble flux = 0.;
2620  IssmDouble vx,vy,thickness,Jdet;
2621  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
2622  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
2623  Input2* vx_input=NULL;
2624  Input2* vy_input=NULL;
2625  if(domaintype==Domain2DhorizontalEnum){
2626  vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
2627  vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
2628  }
2629  else{
2630  vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
2631  vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
2632  }
2633 
2634  /*Start looping on Gaussian points*/
2635  Gauss* gauss=this->NewGauss(xyz_list,xyz_front,3);
2636  for(int ig=gauss->begin();ig<gauss->end();ig++){
2637 
2638  gauss->GaussPoint(ig);
2639  thickness_input->GetInputValue(&thickness,gauss);
2640  vx_input->GetInputValue(&vx,gauss);
2641  vy_input->GetInputValue(&vy,gauss);
2642  this->JacobianDeterminantSurface(&Jdet,xyz_front,gauss);
2643 
2644  flux += rho_ice*Jdet*gauss->weight*thickness*(vx*normal[0] + vy*normal[1]);
2645  }
2646  delete gauss;
2647  return flux;
2648 }
2649 /*}}}*/
2650 IssmDouble Tria::IcefrontMassFluxLevelset(bool scaled){/*{{{*/
2651 
2652  /*Make sure there is an ice front here*/
2653  if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)) return 0;
2654 
2655  /*Scaled not implemented yet...*/
2656  _assert_(!scaled);
2657 
2658  int domaintype,index1,index2;
2659  const IssmPDouble epsilon = 1.e-15;
2660  IssmDouble s1,s2;
2661  IssmDouble gl[NUMVERTICES];
2662  IssmDouble xyz_front[2][3];
2663 
2664 
2665  IssmDouble *xyz_list = NULL;
2666  this->GetVerticesCoordinates(&xyz_list);
2667 
2668  /*Recover parameters and values*/
2669  parameters->FindParam(&domaintype,DomainTypeEnum);
2670  Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
2671 
2672  /*Be sure that values are not zero*/
2673  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
2674  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
2675  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
2676 
2677  if(domaintype==Domain2DverticalEnum){
2678  _error_("not implemented");
2679  }
2680  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
2681  int pt1 = 0;
2682  int pt2 = 1;
2683  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
2684 
2685  /*Portion of the segments*/
2686  s1=gl[2]/(gl[2]-gl[1]);
2687  s2=gl[2]/(gl[2]-gl[0]);
2688  if(gl[2]<0.){
2689  pt1 = 1; pt2 = 0;
2690  }
2691  xyz_front[pt2][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
2692  xyz_front[pt2][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
2693  xyz_front[pt2][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
2694  xyz_front[pt1][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
2695  xyz_front[pt1][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
2696  xyz_front[pt1][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
2697  }
2698  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
2699 
2700  /*Portion of the segments*/
2701  s1=gl[0]/(gl[0]-gl[1]);
2702  s2=gl[0]/(gl[0]-gl[2]);
2703  if(gl[0]<0.){
2704  pt1 = 1; pt2 = 0;
2705  }
2706 
2707  xyz_front[pt1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
2708  xyz_front[pt1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
2709  xyz_front[pt1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
2710  xyz_front[pt2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
2711  xyz_front[pt2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
2712  xyz_front[pt2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
2713  }
2714  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
2715 
2716  /*Portion of the segments*/
2717  s1=gl[1]/(gl[1]-gl[0]);
2718  s2=gl[1]/(gl[1]-gl[2]);
2719  if(gl[1]<0.){
2720  pt1 = 1; pt2 = 0;
2721  }
2722 
2723  xyz_front[pt2][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
2724  xyz_front[pt2][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
2725  xyz_front[pt2][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
2726  xyz_front[pt1][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
2727  xyz_front[pt1][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
2728  xyz_front[pt1][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
2729  }
2730  else{
2731  _error_("case not possible");
2732  }
2733 
2734  }
2735  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
2736 
2737  /*Some checks in debugging mode*/
2738  _assert_(s1>=0 && s1<=1.);
2739  _assert_(s2>=0 && s2<=1.);
2740 
2741  /*Get normal vector*/
2742  IssmDouble normal[3];
2743  this->NormalSection(&normal[0],&xyz_front[0][0]);
2744  normal[0] = -normal[0];
2745  normal[1] = -normal[1];
2746 
2747  /*Get inputs*/
2748  IssmDouble flux = 0.;
2749  IssmDouble vx,vy,thickness,Jdet;
2750  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
2751  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
2752  Input2* vx_input=NULL;
2753  Input2* vy_input=NULL;
2754  if(domaintype==Domain2DhorizontalEnum){
2755  vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
2756  vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
2757  }
2758  else{
2759  vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
2760  vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
2761  }
2762 
2763  /*Start looping on Gaussian points*/
2764  Gauss* gauss=this->NewGauss(xyz_list,&xyz_front[0][0],3);
2765  for(int ig=gauss->begin();ig<gauss->end();ig++){
2766 
2767  gauss->GaussPoint(ig);
2768  thickness_input->GetInputValue(&thickness,gauss);
2769  vx_input->GetInputValue(&vx,gauss);
2770  vy_input->GetInputValue(&vy,gauss);
2771  this->JacobianDeterminantSurface(&Jdet,&xyz_front[0][0],gauss);
2772 
2773  flux += rho_ice*Jdet*gauss->weight*thickness*(vx*normal[0] + vy*normal[1]);
2774  }
2775  delete gauss;
2776  return flux;
2777 }
2778 /*}}}*/
2779 IssmDouble Tria::GroundinglineMassFlux(bool scaled){/*{{{*/
2780 
2781  /*Make sure there is a grounding line here*/
2782  if(!IsIceInElement()) return 0;
2783  if(!IsZeroLevelset(MaskOceanLevelsetEnum)) return 0;
2784 
2785  /*Scaled not implemented yet...*/
2786  _assert_(!scaled);
2787 
2788  int domaintype,index1,index2;
2789  const IssmPDouble epsilon = 1.e-15;
2790  IssmDouble s1,s2;
2791  IssmDouble gl[NUMVERTICES];
2792  IssmDouble xyz_front[2][3];
2793 
2794  IssmDouble *xyz_list = NULL;
2795  this->GetVerticesCoordinates(&xyz_list);
2796 
2797  /*Recover parameters and values*/
2798  parameters->FindParam(&domaintype,DomainTypeEnum);
2799  Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
2800 
2801  /*Be sure that values are not zero*/
2802  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
2803  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
2804  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
2805 
2806  if(domaintype==Domain2DverticalEnum){
2807  _error_("not implemented");
2808  }
2809  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
2810  int pt1 = 0;
2811  int pt2 = 1;
2812  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
2813 
2814  /*Portion of the segments*/
2815  s1=gl[2]/(gl[2]-gl[1]);
2816  s2=gl[2]/(gl[2]-gl[0]);
2817  if(gl[2]<0.){
2818  pt1 = 1; pt2 = 0;
2819  }
2820  xyz_front[pt2][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
2821  xyz_front[pt2][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
2822  xyz_front[pt2][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
2823  xyz_front[pt1][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
2824  xyz_front[pt1][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
2825  xyz_front[pt1][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
2826  }
2827  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
2828 
2829  /*Portion of the segments*/
2830  s1=gl[0]/(gl[0]-gl[1]);
2831  s2=gl[0]/(gl[0]-gl[2]);
2832  if(gl[0]<0.){
2833  pt1 = 1; pt2 = 0;
2834  }
2835 
2836  xyz_front[pt1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
2837  xyz_front[pt1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
2838  xyz_front[pt1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
2839  xyz_front[pt2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
2840  xyz_front[pt2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
2841  xyz_front[pt2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
2842  }
2843  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
2844 
2845  /*Portion of the segments*/
2846  s1=gl[1]/(gl[1]-gl[0]);
2847  s2=gl[1]/(gl[1]-gl[2]);
2848  if(gl[1]<0.){
2849  pt1 = 1; pt2 = 0;
2850  }
2851 
2852  xyz_front[pt2][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
2853  xyz_front[pt2][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
2854  xyz_front[pt2][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
2855  xyz_front[pt1][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
2856  xyz_front[pt1][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
2857  xyz_front[pt1][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
2858  }
2859  else{
2860  _error_("case not possible");
2861  }
2862 
2863  }
2864  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
2865 
2866  /*Some checks in debugging mode*/
2867  _assert_(s1>=0 && s1<=1.);
2868  _assert_(s2>=0 && s2<=1.);
2869 
2870  /*Get normal vector*/
2871  IssmDouble normal[3];
2872  this->NormalSection(&normal[0],&xyz_front[0][0]);
2873 
2874  /*Get inputs*/
2875  IssmDouble flux = 0.;
2876  IssmDouble vx,vy,thickness,Jdet;
2877  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
2878  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
2879  Input2* vx_input=NULL;
2880  Input2* vy_input=NULL;
2881  if(domaintype==Domain2DhorizontalEnum){
2882  vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
2883  vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
2884  }
2885  else{
2886  vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
2887  vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
2888  }
2889 
2890  /*Start looping on Gaussian points*/
2891  Gauss* gauss=this->NewGauss(xyz_list,&xyz_front[0][0],3);
2892  for(int ig=gauss->begin();ig<gauss->end();ig++){
2893 
2894  gauss->GaussPoint(ig);
2895  thickness_input->GetInputValue(&thickness,gauss);
2896  vx_input->GetInputValue(&vx,gauss);
2897  vy_input->GetInputValue(&vy,gauss);
2898  this->JacobianDeterminantSurface(&Jdet,&xyz_front[0][0],gauss);
2899 
2900  flux += rho_ice*Jdet*gauss->weight*thickness*(vx*normal[0] + vy*normal[1]);
2901  }
2902 
2903  return flux;
2904 }
2905 /*}}}*/
2906 IssmDouble Tria::IceVolume(bool scaled){/*{{{*/
2907 
2908  /*The volume of a truncated prism is area_base * 1/numedges sum(length of edges)*/
2909 
2910  /*Intermediaries*/
2911  int i, numiceverts;
2912  IssmDouble area_base,surface,base,Haverage,scalefactor;
2913  IssmDouble Haux[NUMVERTICES], surfaces[NUMVERTICES], bases[NUMVERTICES];
2914  IssmDouble SFaux[NUMVERTICES], scalefactors[NUMVERTICES];
2915  IssmDouble s[2]; // s:fraction of intersected triangle edges, that lies inside ice
2916  int* indices=NULL;
2917  IssmDouble* H=NULL;
2918  IssmDouble* SF=NULL;
2919 
2920  if(!IsIceInElement())return 0.;
2921 
2922  int domaintype;
2923  parameters->FindParam(&domaintype,DomainTypeEnum);
2924 
2925  if(false && IsIcefront()){
2926  //Assumption: linear ice thickness profile on element.
2927  //Hence ice thickness at intersection of levelset function with triangle edge is linear interpolation of ice thickness at vertices.
2928  this->GetLevelsetIntersection(&indices, &numiceverts, s, MaskIceLevelsetEnum, 0.);
2929  int numthk=numiceverts+2;
2930  H=xNew<IssmDouble>(numthk);
2931  //Correct area distortion caused by projection if requestion
2932  area_base=this->GetAreaIce();
2933  if(scaled==true){
2934  Element::GetInputListOnVertices(&scalefactors[0],MeshScaleFactorEnum);
2935  for(i=0;i<NUMVERTICES;i++) SFaux[i]= scalefactors[indices[i]]; //sort thicknesses in ice/noice
2936  switch(numiceverts){
2937  case 1: // average over triangle
2938  SF[0]=SFaux[0];
2939  SF[1]=SFaux[0]+s[0]*(SFaux[1]-SFaux[0]);
2940  SF[2]=SFaux[0]+s[1]*(SFaux[2]-SFaux[0]);
2941  break;
2942  case 2: // average over quadrangle
2943  SF[0]=SFaux[0];
2944  SF[1]=SFaux[1];
2945  SF[2]=SFaux[0]+s[0]*(SFaux[2]-SFaux[0]);
2946  SF[3]=SFaux[1]+s[1]*(SFaux[2]-SFaux[1]);
2947  break;
2948  default:
2949  _error_("Number of ice covered vertices wrong in Tria::IceVolume()");
2950  break;
2951  }
2952  scalefactor=0.;
2953  for(i=0;i<numthk;i++) scalefactor+=SF[i];
2954  scalefactor/=IssmDouble(numthk);
2955  area_base=area_base*scalefactor;
2956  }
2957  Element::GetInputListOnVertices(&surfaces[0],SurfaceEnum);
2958  Element::GetInputListOnVertices(&bases[0],BaseEnum);
2959  for(i=0;i<NUMVERTICES;i++) Haux[i]= surfaces[indices[i]]-bases[indices[i]]; //sort thicknesses in ice/noice
2960  switch(numiceverts){
2961  case 1: // average over triangle
2962  H[0]=Haux[0];
2963  H[1]=Haux[0]+s[0]*(Haux[1]-Haux[0]);
2964  H[2]=Haux[0]+s[1]*(Haux[2]-Haux[0]);
2965  break;
2966  case 2: // average over quadrangle
2967  H[0]=Haux[0];
2968  H[1]=Haux[1];
2969  H[2]=Haux[0]+s[0]*(Haux[2]-Haux[0]);
2970  H[3]=Haux[1]+s[1]*(Haux[2]-Haux[1]);
2971  break;
2972  default:
2973  _error_("Number of ice covered vertices wrong in Tria::IceVolume()");
2974  break;
2975  }
2976  Haverage=0.;
2977  for(i=0;i<numthk;i++) Haverage+=H[i];
2978  Haverage/=IssmDouble(numthk);
2979  }
2980  else{
2981  /*First get back the area of the base*/
2982  area_base=this->GetArea();
2983  if(scaled==true){
2984  Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
2985  scalefactor_input->GetInputAverage(&scalefactor);
2986  area_base=area_base*scalefactor;
2987  }
2988 
2989  /*Now get the average height*/
2990  Input2* surface_input = this->GetInput2(SurfaceEnum); _assert_(surface_input);
2991  Input2* base_input = this->GetInput2(BaseEnum); _assert_(base_input);
2992  surface_input->GetInputAverage(&surface);
2993  base_input->GetInputAverage(&base);
2994  Haverage=surface-base;
2995  }
2996 
2997  /*Cleanup & return: */
2998  xDelete<int>(indices);
2999  xDelete<IssmDouble>(H);
3000  xDelete<IssmDouble>(SF);
3001 
3002  if(domaintype==Domain2DverticalEnum){
3003  return area_base;
3004  }
3005  else{
3006  return area_base*Haverage;
3007  }
3008 }
3009 /*}}}*/
3010 IssmDouble Tria::IceVolumeAboveFloatation(bool scaled){/*{{{*/
3011 
3012  /*The volume above floatation: H + rho_water/rho_ice * bathymetry */
3013  IssmDouble rho_ice,rho_water;
3014  IssmDouble base,surface,bed,bathymetry,scalefactor;
3015  IssmDouble xyz_list[NUMVERTICES][3];
3016 
3017  if(!IsIceInElement() || IsFloating())return 0;
3018 
3019  rho_ice=FindParam(MaterialsRhoIceEnum);
3020  rho_water=FindParam(MaterialsRhoSeawaterEnum);
3021  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
3022 
3023  /*First calculate the area of the base (cross section triangle)
3024  * http://en.wikipedia.org/wiki/Triangle
3025  * base = 1/2 abs((xA-xC)(yB-yA)-(xA-xB)(yC-yA))*/
3026  base = 1./2. * fabs((xyz_list[0][0]-xyz_list[2][0])*(xyz_list[1][1]-xyz_list[0][1]) - (xyz_list[0][0]-xyz_list[1][0])*(xyz_list[2][1]-xyz_list[0][1]));
3027  if(scaled==true){
3028  Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
3029  scalefactor_input->GetInputAverage(&scalefactor);
3030  base=base*scalefactor;
3031  }
3032 
3033  /*Now get the average height and bathymetry*/
3034  Input2* surface_input = this->GetInput2(SurfaceEnum); _assert_(surface_input);
3035  Input2* base_input = this->GetInput2(BaseEnum); _assert_(base_input);
3036  Input2* bed_input = this->GetInput2(BedEnum); _assert_(bed_input);
3037  if(!bed_input) _error_("Could not find bed");
3038  surface_input->GetInputAverage(&surface);
3039  base_input->GetInputAverage(&bed);
3040  bed_input->GetInputAverage(&bathymetry);
3041 
3042  /*Return: */
3043  return base*(surface-bed+min(rho_water/rho_ice*bathymetry,0.));
3044 }
3045 /*}}}*/
3046 void Tria::InputDepthAverageAtBase(int enum_type,int average_enum_type){/*{{{*/
3047 
3048  /*New input*/
3049  Input2* oldinput=NULL;
3050  Input2* newinput=NULL;
3051 
3052  /*copy input of enum_type*/
3053  oldinput=this->GetInput2(enum_type);
3054  if(!oldinput)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
3055  newinput=oldinput->copy();
3056 
3057  /*Assign new name (average)*/
3058  newinput->ChangeEnum(average_enum_type);
3059 
3060  /*Add new input to current element*/
3061  _error_("not implemented");
3062 }
3063 /*}}}*/
3064 void Tria::InputUpdateFromIoModel(int index, IoModel* iomodel){ //i is the element index/*{{{*/
3065 
3066  /*Intermediaries*/
3067  int i,j;
3068  int tria_vertex_ids[3];
3069  IssmDouble nodeinputs[3];
3070  IssmDouble cmmininputs[3];
3071  IssmDouble cmmaxinputs[3];
3072  bool control_analysis,ad_analysis = false;
3073  int num_control_type,num_responses;
3074  char** controls = NULL;
3075  IssmDouble yts;
3076 
3077  /*Get parameters: */
3078  iomodel->FindConstant(&yts,"md.constants.yts");
3079  iomodel->FindConstant(&control_analysis,"md.inversion.iscontrol");
3080  iomodel->FindConstant(&ad_analysis, "md.autodiff.isautodiff");
3081  if(control_analysis && !ad_analysis) iomodel->FindConstant(&num_control_type,"md.inversion.num_control_parameters");
3082  if(control_analysis && !ad_analysis) iomodel->FindConstant(&num_responses,"md.inversion.num_cost_functions");
3083  if(control_analysis && ad_analysis) iomodel->FindConstant(&num_control_type,"md.autodiff.num_independent_objects");
3084  if(control_analysis && ad_analysis) iomodel->FindConstant(&num_responses,"md.autodiff.num_dependent_objects");
3085 
3086  /*Recover vertices ids needed to initialize inputs*/
3087  for(i=0;i<3;i++){
3088  tria_vertex_ids[i]=reCast<int>(iomodel->elements[3*index+i]); //ids for vertices are in the elements array from Matlab
3089  }
3090 }
3091 /*}}}*/
3092 void Tria::InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type){/*{{{*/
3093 
3094  /*Intermediary*/
3095  int* doflist = NULL;
3096 
3097  /*Fetch number of nodes for this finite element*/
3098  int numnodes = this->NumberofNodes(this->element_type);
3099 
3100  /*Fetch dof list and allocate solution vector*/
3101  GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
3102  IssmDouble* values = xNew<IssmDouble>(numnodes);
3103 
3104  /*Use the dof list to index into the solution vector: */
3105  for(int i=0;i<numnodes;i++){
3106  values[i]=solution[doflist[i]];
3107  if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
3108  if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in solution vector, SID = " << this->Sid());
3109  }
3110 
3111  /*Add input to the element: */
3112  this->AddInput2(enum_type,values,this->element_type);
3113 
3114  /*Free ressources:*/
3115  xDelete<IssmDouble>(values);
3116  xDelete<int>(doflist);
3117 }
3118 /*}}}*/
3119 void Tria::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
3120 
3121  /*Check that name is an element input*/
3122  if(!IsInputEnum(name)) _error_("Enum "<<EnumToStringx(name)<<" is not in IsInput");
3123 
3124  int numnodes;
3125  IssmDouble value;
3126  int lidlist[NUMVERTICES];
3127  int *doflist = NULL;
3128  IssmDouble *values = NULL;
3129 
3130  GetVerticesLidList(&lidlist[0]);
3131 
3132  switch(type){
3133  case VertexLIdEnum:
3134  values = xNew<IssmDouble>(NUMVERTICES);
3135  for(int i=0;i<NUMVERTICES;i++){
3136  values[i]=vector[this->vertices[i]->Lid()];
3137  if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in vector");
3138  if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
3139  }
3140  /*update input*/
3141  inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
3142  break;
3143 
3144  case VertexPIdEnum:
3145  values = xNew<IssmDouble>(NUMVERTICES);
3146  for(int i=0;i<NUMVERTICES;i++){
3147  values[i]=vector[this->vertices[i]->Pid()];
3148  if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in vector");
3149  if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
3150  }
3151  /*update input*/
3152  inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
3153  break;
3154 
3155  case VertexSIdEnum:
3156  values = xNew<IssmDouble>(NUMVERTICES);
3157  for(int i=0;i<NUMVERTICES;i++){
3158  values[i]=vector[this->vertices[i]->Sid()];
3159  if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in vector");
3160  if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
3161  }
3162  /*update input*/
3163  inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
3164  break;
3165 
3166  case NodesEnum:
3167  /*Get number of nodes and dof list: */
3168  numnodes = this->NumberofNodes(this->element_type);
3169  values = xNew<IssmDouble>(numnodes);
3170  GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
3171 
3172  for(int i=0;i<numnodes;i++){
3173  values[i]=vector[doflist[i]];
3174  if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in vector");
3175  if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
3176  }
3177  //this->inputs->AddInput(new TriaInput(name,values,this->element_type));
3178  _error_("not implemented");
3179  break;
3180 
3181  case NodeSIdEnum:
3182  /*Get number of nodes and dof list: */
3183  numnodes = this->NumberofNodes(this->element_type);
3184  values = xNew<IssmDouble>(numnodes);
3185 
3186  for(int i=0;i<numnodes;i++){
3187  values[i]=vector[nodes[i]->Sid()];
3188  if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in vector");
3189  if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
3190  }
3191  if(this->element_type==P1Enum){
3192  inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
3193  }
3194  else{
3195  inputs2->SetTriaInput(name,this->element_type,this->lid,numnodes,values);
3196  }
3197  break;
3198 
3199  case ElementEnum:
3200  value=vector[this->Sid()];
3201  if(xIsNan<IssmDouble>(value)) _error_("NaN found in vector");
3202  if(xIsInf<IssmDouble>(value)) _error_("Inf found in vector");
3203  /*update input*/
3204  //this->inputs->AddInput(new DoubleInput(name,value));
3205  //inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
3206  _error_("not implemented");
3207  break;
3208 
3209  default:
3210  _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
3211  }
3212 
3213  /*Clean-up*/
3214  xDelete<int>(doflist);
3215  xDelete<IssmDouble>(values);
3216 
3217 }
3218 /*}}}*/
3219 bool Tria::IsFaceOnBoundary(void){/*{{{*/
3220 
3221  IssmDouble values[NUMVERTICES];
3222  IssmDouble sum;
3223 
3224  /*Retrieve all inputs and parameters*/
3225  Element::GetInputListOnVertices(&values[0],MeshVertexonboundaryEnum);
3226  sum = values[0]+values[1]+values[2];
3227 
3228  _assert_(sum==0. || sum==1. || sum==2.);
3229 
3230  if(sum==3.) _error_("Two edges on boundary not supported yet...");
3231 
3232  if(sum>1.){
3233  return true;
3234  }
3235  else{
3236  return false;
3237  }
3238 }/*}}}*/
3239 bool Tria::IsIcefront(void){/*{{{*/
3240 
3241  bool isicefront;
3242  int i,nrice;
3243  IssmDouble ls[NUMVERTICES];
3244 
3245  /*Retrieve all inputs and parameters*/
3246  Element::GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
3247 
3248  /* If only one vertex has ice, there is an ice front here */
3249  isicefront=false;
3250  if(IsIceInElement()){
3251  nrice=0;
3252  for(i=0;i<NUMVERTICES;i++)
3253  if(ls[i]<0.) nrice++;
3254  if(nrice==1) isicefront= true;
3255  }
3256  return isicefront;
3257 }/*}}}*/
3258 bool Tria::IsNodeOnShelfFromFlags(IssmDouble* flags){/*{{{*/
3259 
3260  int i;
3261  bool shelf=false;
3262 
3263  for(i=0;i<NUMVERTICES;i++){
3264  if (flags[vertices[i]->Pid()]<0.){
3265  shelf=true;
3266  break;
3267  }
3268  }
3269  return shelf;
3270 }
3271 /*}}}*/
3272 bool Tria::IsZeroLevelset(int levelset_enum){/*{{{*/
3273 
3274  bool iszerols;
3275  IssmDouble ls[NUMVERTICES];
3276 
3277  /*Retrieve all inputs and parameters*/
3278  Element::GetInputListOnVertices(&ls[0],levelset_enum);
3279 
3280  /*If the level set is awlays <0, there is no ice front here*/
3281  iszerols= false;
3282  if(IsIceInElement()){
3283  if(ls[0]*ls[1]<0. || ls[0]*ls[2]<0. || (ls[0]*ls[1]*ls[2]==0. && ls[0]*ls[1]+ls[0]*ls[2]+ls[1]*ls[2]<=0.)){
3284  iszerols = true;
3285  }
3286  }
3287 
3288  return iszerols;
3289 }
3290 /*}}}*/
3291 void Tria::JacobianDeterminant(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
3292 
3293  _assert_(gauss->Enum()==GaussTriaEnum);
3294  this->GetJacobianDeterminant(pJdet,xyz_list,(GaussTria*)gauss);
3295 
3296 }
3297 /*}}}*/
3298 void Tria::JacobianDeterminantBase(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss){/*{{{*/
3299 
3300  _assert_(gauss->Enum()==GaussTriaEnum);
3301  this->GetSegmentJacobianDeterminant(pJdet,xyz_list_base,(GaussTria*)gauss);
3302 
3303 }
3304 /*}}}*/
3305 void Tria::JacobianDeterminantSurface(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
3306 
3307  _assert_(gauss->Enum()==GaussTriaEnum);
3308  this->GetSegmentJacobianDeterminant(pJdet,xyz_list,(GaussTria*)gauss);
3309 
3310 }
3311 /*}}}*/
3312 void Tria::JacobianDeterminantTop(IssmDouble* pJdet,IssmDouble* xyz_list_top,Gauss* gauss){/*{{{*/
3313 
3314  _assert_(gauss->Enum()==GaussTriaEnum);
3315  this->GetSegmentJacobianDeterminant(pJdet,xyz_list_top,(GaussTria*)gauss);
3316 
3317 }
3318 /*}}}*/
3319 IssmDouble Tria::Masscon(IssmDouble* levelset){ /*{{{*/
3320 
3321  /*intermediary: */
3322  IssmDouble* values=NULL;
3323  Input2* thickness_input=NULL;
3324  IssmDouble thickness;
3325  IssmDouble weight;
3326  IssmDouble Jdet;
3327  IssmDouble volume;
3328  IssmDouble rho_ice;
3329  IssmDouble* xyz_list=NULL;
3330  int point1;
3331  IssmDouble fraction1,fraction2;
3332  bool mainlynegative=true;
3333 
3334  /*Output:*/
3335  volume=0;
3336 
3337  /* Get node coordinates and dof list: */
3338  GetVerticesCoordinates(&xyz_list);
3339 
3340  /*Retrieve inputs required:*/
3341  thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
3342 
3343  /*Retrieve material parameters: */
3344  rho_ice=FindParam(MaterialsRhoIceEnum);
3345 
3346  /*Retrieve values of the levelset defining the masscon: */
3347  values = xNew<IssmDouble>(NUMVERTICES);
3348  for(int i=0;i<NUMVERTICES;i++){
3349  values[i]=levelset[this->vertices[i]->Sid()];
3350  }
3351 
3352  /*Ok, use the level set values to figure out where we put our gaussian points:*/
3353  this->GetLevelsetPositivePart(&point1,&fraction1,&fraction2,&mainlynegative,values);
3354  Gauss* gauss = this->NewGauss(point1,fraction1,fraction2,mainlynegative,4);
3355 
3356  volume=0;
3357 
3358  for(int ig=gauss->begin();ig<gauss->end();ig++){
3359  gauss->GaussPoint(ig);
3360 
3361  this->JacobianDeterminant(&Jdet,xyz_list,gauss);
3362  thickness_input->GetInputValue(&thickness, gauss);
3363 
3364  volume+=thickness*gauss->weight*Jdet;
3365  }
3366 
3367  /* clean up and Return: */
3368  xDelete<IssmDouble>(xyz_list);
3369  xDelete<IssmDouble>(values);
3370  delete gauss;
3371  return rho_ice*volume;
3372 }
3373 /*}}}*/
3374 IssmDouble Tria::MassFlux(IssmDouble x1, IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){/*{{{*/
3375 
3376  int domaintype;
3377  IssmDouble mass_flux=0.;
3378  IssmDouble xyz_list[NUMVERTICES][3];
3379  IssmDouble vx1,vx2,vy1,vy2,h1,h2;
3380 
3381  /*Get material parameters :*/
3382  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
3383 
3384  /*First off, check that this segment belongs to this element: */
3385  if (segment_id!=this->id)_error_("error message: segment with id " << segment_id << " does not belong to element with id:" << this->id);
3386 
3387  /*Get xyz list: */
3388  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
3389 
3390  /*get area coordinates of 0 and 1 locations: */
3391  GaussTria* gauss_1=new GaussTria();
3392  gauss_1->GaussFromCoords(x1,y1,&xyz_list[0][0]);
3393  GaussTria* gauss_2=new GaussTria();
3394  gauss_2->GaussFromCoords(x2,y2,&xyz_list[0][0]);
3395 
3396  /*Get segment length and normal (needs to be properly oriented)*/
3397  IssmDouble nx=cos(atan2(x1-x2,y2-y1));
3398  IssmDouble ny=sin(atan2(x1-x2,y2-y1));
3399  IssmDouble length=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
3400 
3401  /*Get velocity and thickness*/
3402  this->parameters->FindParam(&domaintype,DomainTypeEnum);
3403  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
3404  Input2* vx_input=NULL;
3405  Input2* vy_input=NULL;
3406  if(domaintype==Domain2DhorizontalEnum){
3407  vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
3408  vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
3409  }
3410  else{
3411  vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
3412  vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
3413  }
3414 
3415  thickness_input->GetInputValue(&h1, gauss_1);
3416  thickness_input->GetInputValue(&h2, gauss_2);
3417  vx_input->GetInputValue(&vx1,gauss_1);
3418  vx_input->GetInputValue(&vx2,gauss_2);
3419  vy_input->GetInputValue(&vy1,gauss_1);
3420  vy_input->GetInputValue(&vy2,gauss_2);
3421 
3422  mass_flux= rho_ice*length*(
3423  (1./3.*(h1-h2)*(vx1-vx2)+0.5*h2*(vx1-vx2)+0.5*(h1-h2)*vx2+h2*vx2)*nx+
3424  (1./3.*(h1-h2)*(vy1-vy2)+0.5*h2*(vy1-vy2)+0.5*(h1-h2)*vy2+h2*vy2)*ny
3425  );
3426 
3427  /*clean up and return:*/
3428  delete gauss_1;
3429  delete gauss_2;
3430  return mass_flux;
3431 }
3432 /*}}}*/
3433 IssmDouble Tria::MassFlux(IssmDouble* segment){/*{{{*/
3434  return this->MassFlux(segment[0],segment[1],segment[2],segment[3],reCast<int>(segment[4]));
3435 }
3436 /*}}}*/
3437 IssmDouble Tria::Misfit(int modelenum,int observationenum,int weightsenum){/*{{{*/
3438 
3439  /*Intermediaries*/
3440  IssmDouble model,observation,weight;
3441  IssmDouble Jdet;
3442  IssmDouble Jelem = 0;
3443  IssmDouble xyz_list[NUMVERTICES][3];
3444  GaussTria *gauss = NULL;
3445 
3446  /*If on water, return 0: */
3447  if(!IsIceInElement())return 0;
3448 
3449  /*Retrieve all inputs we will be needing: */
3450  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
3451  Input2* model_input=this->GetInput2(modelenum); _assert_(model_input);
3452  Input2* observation_input=this->GetInput2(observationenum);_assert_(observation_input);
3453  Input2* weights_input =this->GetInput2(weightsenum); _assert_(weights_input);
3454 
3455  /* Start looping on the number of gaussian points: */
3456  gauss=new GaussTria(2);
3457  for(int ig=gauss->begin();ig<gauss->end();ig++){
3458 
3459  gauss->GaussPoint(ig);
3460 
3461  /* Get Jacobian determinant: */
3462  GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
3463 
3464  /*Get parameters at gauss point*/
3465  model_input->GetInputValue(&model,gauss);
3466  observation_input->GetInputValue(&observation,gauss);
3467  weights_input->GetInputValue(&weight,gauss);
3468 
3469  /*compute misfit between model and observation */
3470  Jelem+=0.5*(model-observation)*(model-observation)*Jdet*weight*gauss->weight;
3471  }
3472 
3473  /* clean up and Return: */
3474  delete gauss;
3475  return Jelem;
3476 }
3477 /*}}}*/
3478 IssmDouble Tria::MisfitArea(int weightsenum){/*{{{*/
3479 
3480  /*Intermediaries*/
3481  IssmDouble weight;
3482  IssmDouble Jdet;
3483  IssmDouble Jelem = 0;
3484  IssmDouble xyz_list[NUMVERTICES][3];
3485  GaussTria *gauss = NULL;
3486 
3487  /*If on water, return 0: */
3488  if(!IsIceInElement())return 0;
3489 
3490  /*Retrieve all inputs we will be needing: */
3491  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
3492  Input2* weights_input =this->GetInput2(weightsenum); _assert_(weights_input);
3493 
3494  /* Start looping on the number of gaussian points: */
3495  gauss=new GaussTria(2);
3496  for(int ig=gauss->begin();ig<gauss->end();ig++){
3497 
3498  gauss->GaussPoint(ig);
3499 
3500  /* Get Jacobian determinant: */
3501  GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
3502 
3503  /*Get parameters at gauss point*/
3504  weights_input->GetInputValue(&weight,gauss);
3505 
3506  /*compute misfit between model and observation */
3507  Jelem+=Jdet*weight*gauss->weight;
3508  }
3509 
3510  /* clean up and Return: */
3511  delete gauss;
3512  return Jelem;
3513 }
3514 /*}}}*/
3515 Gauss* Tria::NewGauss(void){/*{{{*/
3516  return new GaussTria();
3517 }
3518 /*}}}*/
3519 Gauss* Tria::NewGauss(int order){/*{{{*/
3520  return new GaussTria(order);
3521 }
3522 /*}}}*/
3523 Gauss* Tria::NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order){/*{{{*/
3524 
3525  IssmDouble area_coordinates[2][3];
3526  GetAreaCoordinates(&area_coordinates[0][0],xyz_list_front,xyz_list,2);
3527  return new GaussTria(area_coordinates,order);
3528 }
3529 /*}}}*/
3530 Gauss* Tria::NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,bool mainlyfloating,int order){/*{{{*/
3531 
3532  return new GaussTria(point1,fraction1,fraction2,mainlyfloating,order);
3533 }
3534 /*}}}*/
3535 Gauss* Tria::NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,int order){/*{{{*/
3536 
3537  return new GaussTria(point1,fraction1,fraction2,order);
3538 }
3539 /*}}}*/
3540 Gauss* Tria::NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert){/*{{{*/
3541 
3542  IssmDouble area_coordinates[2][3];
3543  GetAreaCoordinates(&area_coordinates[0][0],xyz_list_front,xyz_list,2);
3544  return new GaussTria(area_coordinates,order_vert);
3545 }
3546 /*}}}*/
3547 Gauss* Tria::NewGaussBase(int order){/*{{{*/
3548 
3549  int indices[2];
3550  this->EdgeOnBaseIndices(&indices[0],&indices[1]);
3551  return new GaussTria(indices[0],indices[1],order);
3552 }
3553 /*}}}*/
3554 Gauss* Tria::NewGaussTop(int order){/*{{{*/
3555 
3556  int indices[2];
3557  this->EdgeOnSurfaceIndices(&indices[0],&indices[1]);
3558  return new GaussTria(indices[0],indices[1],order);
3559 }
3560 /*}}}*/
3561 void Tria::NodalFunctions(IssmDouble* basis, Gauss* gauss){/*{{{*/
3562 
3563  _assert_(gauss->Enum()==GaussTriaEnum);
3564  this->GetNodalFunctions(basis,(GaussTria*)gauss,this->element_type);
3565 
3566 }
3567 /*}}}*/
3568 void Tria::NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
3569 
3570  _assert_(gauss->Enum()==GaussTriaEnum);
3571  this->GetNodalFunctionsDerivatives(dbasis,xyz_list,(GaussTria*)gauss,this->element_type);
3572 
3573 }
3574 /*}}}*/
3575 void Tria::NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
3576 
3577  _assert_(gauss->Enum()==GaussTriaEnum);
3578  this->GetNodalFunctionsDerivatives(dbasis,xyz_list,(GaussTria*)gauss,this->VelocityInterpolation());
3579 
3580 }
3581 /*}}}*/
3582 void Tria::NodalFunctionsPressure(IssmDouble* basis, Gauss* gauss){/*{{{*/
3583 
3584  _assert_(gauss->Enum()==GaussTriaEnum);
3585  this->GetNodalFunctions(basis,(GaussTria*)gauss,this->PressureInterpolation());
3586 
3587 }
3588 /*}}}*/
3589 void Tria::NodalFunctionsP1(IssmDouble* basis, Gauss* gauss){/*{{{*/
3590 
3591  _assert_(gauss->Enum()==GaussTriaEnum);
3592  this->GetNodalFunctions(basis,(GaussTria*)gauss,P1Enum);
3593 
3594 }
3595 /*}}}*/
3596 void Tria::NodalFunctionsP1Derivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
3597 
3598  _assert_(gauss->Enum()==GaussTriaEnum);
3599  this->GetNodalFunctionsDerivatives(dbasis,xyz_list,(GaussTria*)gauss,P1Enum);
3600 
3601 }
3602 /*}}}*/
3603 void Tria::NodalFunctionsP2(IssmDouble* basis, Gauss* gauss){/*{{{*/
3604 
3605  _assert_(gauss->Enum()==GaussTriaEnum);
3606  this->GetNodalFunctions(basis,(GaussTria*)gauss,P2Enum);
3607 
3608 }
3609 /*}}}*/
3610 void Tria::NodalFunctionsTensor(IssmDouble* basis, Gauss* gauss){/*{{{*/
3611 
3612  _assert_(gauss->Enum()==GaussTriaEnum);
3613  this->GetNodalFunctions(basis,(GaussTria*)gauss,this->TensorInterpolation());
3614 
3615 }
3616 /*}}}*/
3617 void Tria::NodalFunctionsVelocity(IssmDouble* basis, Gauss* gauss){/*{{{*/
3618 
3619  _assert_(gauss->Enum()==GaussTriaEnum);
3620  this->GetNodalFunctions(basis,(GaussTria*)gauss,this->VelocityInterpolation());
3621 
3622 }
3623 /*}}}*/
3624 int Tria::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){/*{{{*/
3625 
3626  int found = 0;
3627  IssmDouble value;
3628  GaussTria *gauss = NULL;
3629 
3630  /*First, serarch the input: */
3631  Input2* data=this->GetInput2(natureofdataenum);
3632 
3633  /*figure out if we have the vertex id: */
3634  found=0;
3635  for(int i=0;i<NUMVERTICES;i++){
3636  if(index==vertices[i]->Sid()){
3637  /*Do we have natureofdataenum in our inputs? :*/
3638  if(data){
3639  /*ok, we are good. retrieve value of input at vertex :*/
3640  gauss=new GaussTria(); gauss->GaussVertex(i);
3641  data->GetInputValue(&value,gauss);
3642  found=1;
3643  break;
3644  }
3645  }
3646  }
3647 
3648  /*clean-up*/
3649  delete gauss;
3650 
3651  if(found)*pvalue=value;
3652  return found;
3653 }
3654 /*}}}*/
3655 void Tria::NormalBase(IssmDouble* bed_normal,IssmDouble* xyz_list){/*{{{*/
3656 
3657  /*Build unit outward pointing vector*/
3658  IssmDouble vector[2];
3659  IssmDouble norm;
3660 
3661  vector[0]=xyz_list[1*3+0] - xyz_list[0*3+0];
3662  vector[1]=xyz_list[1*3+1] - xyz_list[0*3+1];
3663 
3664  norm=sqrt(vector[0]*vector[0] + vector[1]*vector[1]);
3665 
3666  bed_normal[0]= + vector[1]/norm;
3667  bed_normal[1]= - vector[0]/norm;
3668  _assert_(bed_normal[1]<0);
3669 }
3670 /*}}}*/
3671 void Tria::NormalSection(IssmDouble* normal,IssmDouble* xyz_list){/*{{{*/
3672 
3673  /*Build unit outward pointing vector*/
3674  IssmDouble vector[2];
3675  IssmDouble norm;
3676 
3677  vector[0]=xyz_list[1*3+0] - xyz_list[0*3+0];
3678  vector[1]=xyz_list[1*3+1] - xyz_list[0*3+1];
3679 
3680  norm=sqrt(vector[0]*vector[0] + vector[1]*vector[1]);
3681 
3682  normal[0]= + vector[1]/norm;
3683  normal[1]= - vector[0]/norm;
3684 }
3685 /*}}}*/
3686 void Tria::NormalTop(IssmDouble* top_normal,IssmDouble* xyz_list){/*{{{*/
3687 
3688  /*Build unit outward pointing vector*/
3689  int index1,index2;
3690  IssmDouble vector[2];
3691  IssmDouble norm;
3692 
3693  this->EdgeOnSurfaceIndices(&index1,&index2);
3694  vector[0]=xyz_list[1*3+0] - xyz_list[0*3+0];
3695  vector[1]=xyz_list[1*3+1] - xyz_list[0*3+1];
3696 
3697  norm=sqrt(vector[0]*vector[0] + vector[1]*vector[1]);
3698 
3699  top_normal[0]= + vector[1]/norm;
3700  top_normal[1]= - vector[0]/norm;
3701  _assert_(top_normal[1]>0);
3702 }
3703 /*}}}*/
3704 int Tria::ObjectEnum(void){/*{{{*/
3705 
3706  return TriaEnum;
3707 
3708 }
3709 /*}}}*/
3710 int Tria::NumberofNodesPressure(void){/*{{{*/
3711  return TriaRef::NumberofNodes(this->PressureInterpolation());
3712 }
3713 /*}}}*/
3714 int Tria::NumberofNodesVelocity(void){/*{{{*/
3715  return TriaRef::NumberofNodes(this->VelocityInterpolation());
3716 }
3717 /*}}}*/
3718 void Tria::PotentialUngrounding(Vector<IssmDouble>* potential_ungrounding){/*{{{*/
3719 
3720  IssmDouble h[NUMVERTICES],r[NUMVERTICES],gl[NUMVERTICES];
3721  IssmDouble bed_hydro;
3722  IssmDouble rho_water,rho_ice,density;
3723 
3724  /*material parameters: */
3725  rho_water=FindParam(MaterialsRhoSeawaterEnum);
3726  rho_ice=FindParam(MaterialsRhoIceEnum);
3727  density=rho_ice/rho_water;
3728  Element::GetInputListOnVertices(&h[0],ThicknessEnum);
3729  Element::GetInputListOnVertices(&r[0],BedEnum);
3730  Element::GetInputListOnVertices(&gl[0],MaskOceanLevelsetEnum);
3731 
3732  /*go through vertices, and figure out which ones are grounded and want to unground: */
3733  for(int i=0;i<NUMVERTICES;i++){
3734  /*Find if grounded vertices want to start floating*/
3735  if (gl[i]>0.){
3736  bed_hydro=-density*h[i];
3737  if(bed_hydro>r[i]){
3738  /*Vertex that could potentially unground, flag it*/
3739  potential_ungrounding->SetValue(vertices[i]->Pid(),1,INS_VAL);
3740  }
3741  }
3742  }
3743 }
3744 /*}}}*/
3745 int Tria::PressureInterpolation(void){/*{{{*/
3746  return TriaRef::PressureInterpolation(this->element_type);
3747 }
3748 /*}}}*/
3749 void Tria::ReduceMatrices(ElementMatrix* Ke,ElementVector* pe){/*{{{*/
3750 
3751  /*Static condensation if requested*/
3752  if(pe){
3753  if(this->element_type==MINIcondensedEnum){
3754  int indices[2]={6,7};
3755  pe->StaticCondensation(Ke,2,&indices[0]);
3756  }
3757  else if(this->element_type==P1bubblecondensedEnum){
3758  int size = nodes[3]->GetNumberOfDofs(NoneApproximationEnum,GsetEnum);
3759  int offset = 0;
3760  for(int i=0;i<3;i++) offset+=nodes[i]->GetNumberOfDofs(NoneApproximationEnum,GsetEnum);
3761  int* indices=xNew<int>(size);
3762  for(int i=0;i<size;i++) indices[i] = offset+i;
3763  pe->StaticCondensation(Ke,size,indices);
3764  xDelete<int>(indices);
3765  }
3766  }
3767 
3768  if(Ke){
3769  if(this->element_type==MINIcondensedEnum){
3770  int indices[2]={6,7};
3771  Ke->StaticCondensation(2,&indices[0]);
3772  }
3773  else if(this->element_type==P1bubblecondensedEnum){
3774  int size = nodes[3]->GetNumberOfDofs(NoneApproximationEnum,GsetEnum);
3775  int offset = 0;
3776  for(int i=0;i<3;i++) offset+=nodes[i]->GetNumberOfDofs(NoneApproximationEnum,GsetEnum);
3777  int* indices=xNew<int>(size);
3778  for(int i=0;i<size;i++) indices[i] = offset+i;
3779  Ke->StaticCondensation(size,indices);
3780  xDelete<int>(indices);
3781  }
3782  }
3783 
3784 }
3785 /*}}}*/
3786 void Tria::ResetFSBasalBoundaryCondition(void){/*{{{*/
3787 
3788  int numnodes = this->NumberofNodesVelocity();
3789 
3790  int approximation;
3791  IssmDouble* vertexonbase= NULL;
3792  IssmDouble slope,groundedice;
3793  IssmDouble xz_plane[6];
3794 
3795  /*For FS only: we want the CS to be tangential to the bedrock*/
3796  this->GetInput2Value(&approximation,ApproximationEnum);
3797  if(!HasNodeOnBase() || approximation!=FSApproximationEnum) return;
3798 
3799  /*Get inputs*/
3800  Input2* slope_input=this->GetInput2(BedSlopeXEnum); _assert_(slope_input);
3801  Input2* groundedicelevelset_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(groundedicelevelset_input);
3802  vertexonbase = xNew<IssmDouble>(numnodes);
3803  this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
3804 
3805  /*Loop over basal nodes and update their CS*/
3806  GaussTria* gauss = new GaussTria();
3807  for(int i=0;i<this->NumberofNodesVelocity();i++){
3808 
3809  if(vertexonbase[i]==1){
3810  gauss->GaussNode(this->VelocityInterpolation(),i);
3811  slope_input->GetInputValue(&slope,gauss);
3812  groundedicelevelset_input->GetInputValue(&groundedice,gauss);
3813  IssmDouble theta = atan(slope);
3814 
3815  /*New X axis New Z axis*/
3816  xz_plane[0]=cos(theta); xz_plane[3]=0.;
3817  xz_plane[1]=sin(theta); xz_plane[4]=0.;
3818  xz_plane[2]=0.; xz_plane[5]=1.;
3819 
3820  if(groundedice>=0){
3821  this->nodes[i]->DofInSSet(1); //vy
3822  }
3823  else{
3824  this->nodes[i]->DofInFSet(1); //vy
3825  }
3826 
3827  XZvectorsToCoordinateSystem(&this->nodes[i]->coord_system[0][0],&xz_plane[0]);
3828  }
3829  }
3830 
3831  /*cleanup*/
3832  xDelete<IssmDouble>(vertexonbase);
3833  delete gauss;
3834 }
3835 /*}}}*/
3836 void Tria::ResetHooks(){/*{{{*/
3837 
3838  if(this->nodes) xDelete<Node*>(this->nodes);
3839  this->nodes=NULL;
3840  this->vertices=NULL;
3841  this->material=NULL;
3842  this->parameters=NULL;
3843 
3844  //deal with ElementHook mother class
3845  for(int i=0;i<this->numanalyses;i++) if(this->hnodes[i]) this->hnodes[i]->reset();
3846  this->hvertices->reset();
3847  if(this->hmaterial)this->hmaterial->reset();
3848  if(this->hneighbors) this->hneighbors->reset();
3849 
3850 }
3851 /*}}}*/
3852 void Tria::RignotMeltParameterization(){/*{{{*/
3853 
3854  IssmDouble A, B, alpha, beta;
3855  IssmDouble bed,qsg,qsg_basin,TF,yts;
3856  int numbasins;
3857  IssmDouble basinid[NUMVERTICES];
3858  IssmDouble* basin_icefront_area=NULL;
3859 
3860  /* Coefficients */
3861  A = 3e-4;
3862  B = 0.15;
3863  alpha = 0.39;
3864  beta = 1.18;
3865 
3866  /*Get inputs*/
3867  Input2* bed_input = this->GetInput2(BedEnum); _assert_(bed_input);
3868  Input2* qsg_input = this->GetInput2(FrontalForcingsSubglacialDischargeEnum); _assert_(qsg_input);
3869  Input2* TF_input = this->GetInput2(FrontalForcingsThermalForcingEnum); _assert_(TF_input);
3870  Element::GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
3871 
3872  this->FindParam(&yts, ConstantsYtsEnum);
3873  this->parameters->FindParam(&numbasins,FrontalForcingsNumberofBasinsEnum);
3874  this->parameters->FindParam(&basin_icefront_area,&numbasins,FrontalForcingsBasinIcefrontAreaEnum);
3875 
3876  IssmDouble meltrates[NUMVERTICES]; //frontal melt-rate
3877 
3878  /* Start looping on the number of vertices: */
3879  GaussTria* gauss=new GaussTria();
3880  for(int iv=0;iv<NUMVERTICES;iv++){
3881  gauss->GaussVertex(iv);
3882 
3883  /* Get variables */
3884  bed_input->GetInputValue(&bed,gauss);
3885  qsg_input->GetInputValue(&qsg,gauss);
3886  TF_input->GetInputValue(&TF,gauss);
3887 
3888  if(basin_icefront_area[reCast<int>(basinid[iv])-1]==0.) meltrates[iv]=0.;
3889  else{
3890  /* change the unit of qsg (m^3/d -> m/d) with ice front area */
3891  qsg_basin=qsg/basin_icefront_area[reCast<int>(basinid[iv])-1];
3892 
3893  /* calculate melt rates */
3894  meltrates[iv]=((A*max(-bed,0.)*pow(max(qsg_basin,0.),alpha)+B)*pow(max(TF,0.),beta))/86400; //[m/s]
3895  }
3896 
3897  if(xIsNan<IssmDouble>(meltrates[iv])) _error_("NaN found in vector");
3898  if(xIsInf<IssmDouble>(meltrates[iv])) _error_("Inf found in vector");
3899  }
3900 
3901  /*Add input*/
3902  this->AddInput2(CalvingMeltingrateEnum,&meltrates[0],P1Enum);
3903 
3904  /*Cleanup and return*/
3905  xDelete<IssmDouble>(basin_icefront_area);
3906  delete gauss;
3907 }
3908 /*}}}*/
3909 void Tria::SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index,int offset,int N, int M){/*{{{*/
3910 
3911  IssmDouble values[NUMVERTICES];
3912  int lidlist[NUMVERTICES];
3913  int idlist[NUMVERTICES],control_init;
3914 
3915  /*Get Domain type*/
3916  int domaintype;
3917  parameters->FindParam(&domaintype,DomainTypeEnum);
3918 
3919  /*Specific case for depth averaged quantities*/
3920  control_init=control_enum;
3921  if(domaintype==Domain2DverticalEnum){
3922  if(control_enum==MaterialsRheologyBbarEnum){
3923  control_enum=MaterialsRheologyBEnum;
3924  if(!IsOnBase()) return;
3925  }
3926  if(control_enum==DamageDbarEnum){
3927  control_enum=DamageDEnum;
3928  if(!IsOnBase()) return;
3929  }
3930  }
3931 
3932  /*Get out if this is not an element input*/
3933  if(!IsInputEnum(control_enum)) return;
3934 
3935  this->GetVerticesLidList(&lidlist[0]);
3936  ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,"value"); _assert_(input);
3937 
3938  /*Get values on vertices*/
3939  for(int n=0;n<N;n++){
3940  for(int i=0;i<NUMVERTICES;i++){
3941  idlist[i]=offset + this->vertices[i]->Sid()+n*M;
3942  values[i]=vector[idlist[i]];
3943  }
3944  if(input->ObjectEnum()==TriaInput2Enum){
3945  input->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
3946  }
3947  else if(input->ObjectEnum()==TransientInput2Enum){
3948  _error_("not implemented");
3949  //Input* new_input = new TriaInput(control_enum,values,P1Enum);
3950  //controlinput->SetInput(new_input,n);
3951  //controlinput->Configure(parameters);
3952  }
3953  else _error_("Type not supported");
3954  }
3955 }
3956 /*}}}*/
3957 void Tria::SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index){/*{{{*/
3958 
3959  IssmDouble values[NUMVERTICES];
3960  int idlist[NUMVERTICES];
3961  int lidlist[NUMVERTICES];
3962 
3963  /*Get Domain type*/
3964  int domaintype;
3965  parameters->FindParam(&domaintype,DomainTypeEnum);
3966 
3967  /*Specific case for depth averaged quantities*/
3968  if(domaintype==Domain2DverticalEnum){
3969  if(control_enum==MaterialsRheologyBbarEnum){
3970  control_enum=MaterialsRheologyBEnum;
3971  if(!IsOnBase()) return;
3972  }
3973  if(control_enum==DamageDbarEnum){
3974  control_enum=DamageDEnum;
3975  if(!IsOnBase()) return;
3976  }
3977  }
3978 
3979  /*Get out if this is not an element input*/
3980  if(!IsInputEnum(control_enum)) return;
3981 
3982  /*prepare index list*/
3983  this->GetVerticesLidList(&lidlist[0]);
3984  GradientIndexing(&idlist[0],control_index);
3985 
3986  /*Get values on vertices*/
3987  for(int i=0;i<NUMVERTICES;i++){
3988  values[i]=vector[idlist[i]];
3989  }
3990 
3991  /*Set Input*/
3992  ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,"value"); _assert_(input);
3993  input->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
3994 }
3995 /*}}}*/
3996 void Tria::SetCurrentConfiguration(Elements* elementsin, Loads* loadsin, Nodes* nodesin, Materials* materialsin, Parameters* parametersin){/*{{{*/
3997 
3998  /*go into parameters and get the analysis_counter: */
3999  int analysis_counter;
4000  parametersin->FindParam(&analysis_counter,AnalysisCounterEnum);
4001 
4002  /*Get Element type*/
4003  if(this->element_type_list) this->element_type=this->element_type_list[analysis_counter];
4004 
4005  /*Pick up nodes*/
4006  if(this->hnodes && this->hnodes[analysis_counter]){
4007  this->nodes=(Node**)this->hnodes[analysis_counter]->deliverp();
4008  }
4009 
4010 }
4011 /*}}}*/
4012 void Tria::SetElementInput(int enum_in,IssmDouble value){/*{{{*/
4013 
4014  this->SetElementInput(this->inputs2,enum_in,value);
4015 
4016 }
4017 /*}}}*/
4018 void Tria::SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble value){/*{{{*/
4019 
4020  _assert_(inputs2);
4021  inputs2->SetTriaInput(enum_in,P0Enum,this->lid,value);
4022 
4023 }
4024 /*}}}*/
4025 void Tria::SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in){/*{{{*/
4026 
4027  _assert_(inputs2);
4028  inputs2->SetTriaInput(enum_in,P1Enum,numindices,indices,values);
4029 
4030 }
4031 /*}}}*/
4032 Element* Tria::SpawnBasalElement(void){/*{{{*/
4033 
4034  int index1,index2;
4035  int domaintype;
4036 
4037  this->parameters->FindParam(&domaintype,DomainTypeEnum);
4038  switch(domaintype){
4039  case Domain2DhorizontalEnum:
4040  return this;
4041  case Domain2DverticalEnum:
4042  _assert_(HasEdgeOnBase());
4043  this->EdgeOnBaseIndices(&index1,&index2);
4044  return SpawnSeg(index1,index2);
4045  default:
4046  _error_("not implemented yet");
4047  }
4048 }
4049 /*}}}*/
4050 Seg* Tria::SpawnSeg(int index1,int index2){/*{{{*/
4051 
4052  int analysis_counter;
4053 
4054  /*go into parameters and get the analysis_counter: */
4055  this->parameters->FindParam(&analysis_counter,AnalysisCounterEnum);
4056 
4057  /*Create Seg*/
4058  Seg* seg=new Seg();
4059  seg->id=this->id;
4060  seg->sid=this->sid;
4061  seg->lid=this->lid;
4062  seg->inputs2=this->inputs2;
4063  seg->parameters=this->parameters;
4064  seg->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
4065  this->SpawnSegHook(xDynamicCast<ElementHook*>(seg),index1,index2);
4066 
4067  seg->iscollapsed = 1;
4068  seg->collapsed_ids[0] = index1;
4069  seg->collapsed_ids[1] = index2;
4070 
4071  /*Spawn material*/
4072  seg->material=(Material*)this->material->copy2(seg);
4073 
4074  /*recover nodes, material*/
4075  seg->nodes = (Node**)seg->hnodes[analysis_counter]->deliverp();
4076  seg->vertices = (Vertex**)seg->hvertices->deliverp();
4077 
4078  /*Return new Seg*/
4079  return seg;
4080 }
4081 /*}}}*/
4082 Element* Tria::SpawnTopElement(void){/*{{{*/
4083 
4084  int index1,index2;
4085  int domaintype;
4086 
4087  this->parameters->FindParam(&domaintype,DomainTypeEnum);
4088  switch(domaintype){
4089  case Domain2DhorizontalEnum:
4090  return this;
4091  case Domain2DverticalEnum:
4092  _assert_(HasEdgeOnSurface());
4093  this->EdgeOnSurfaceIndices(&index1,&index2);
4094  return SpawnSeg(index2,index1); //reverse order
4095  default:
4096  _error_("not implemented yet");
4097  }
4098 }
4099 /*}}}*/
4100 void Tria::StrainRateparallel(){/*{{{*/
4101 
4102  IssmDouble *xyz_list = NULL;
4103  IssmDouble epsilon[3];
4104  GaussTria* gauss=NULL;
4105  IssmDouble vx,vy,vel;
4106  IssmDouble strainxx;
4107  IssmDouble strainxy;
4108  IssmDouble strainyy;
4109  IssmDouble strainparallel[NUMVERTICES];
4110 
4111  /* Get node coordinates and dof list: */
4112  this->GetVerticesCoordinates(&xyz_list);
4113 
4114  /*Retrieve all inputs we will need*/
4115  Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
4116  Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
4117 
4118  /* Start looping on the number of vertices: */
4119  gauss=new GaussTria();
4120  for (int iv=0;iv<NUMVERTICES;iv++){
4121  gauss->GaussVertex(iv);
4122 
4123  /* Get the value we need*/
4124  vx_input->GetInputValue(&vx,gauss);
4125  vy_input->GetInputValue(&vy,gauss);
4126  vel=vx*vx+vy*vy;
4127 
4128  /*Compute strain rate viscosity and pressure: */
4129  this->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
4130  strainxx=epsilon[0];
4131  strainyy=epsilon[1];
4132  strainxy=epsilon[2];
4133 
4134  /*strainparallel= Strain rate along the ice flow direction */
4135  strainparallel[iv]=(vx*vx*(strainxx)+vy*vy*(strainyy)+2*vy*vx*strainxy)/(vel+1.e-14);
4136  }
4137 
4138  /*Add input*/
4139  this->AddInput2(StrainRateparallelEnum,&strainparallel[0],P1DGEnum);
4140 
4141  /*Clean up and return*/
4142  delete gauss;
4143  xDelete<IssmDouble>(xyz_list);
4144 }
4145 /*}}}*/
4146 void Tria::StrainRateperpendicular(){/*{{{*/
4147 
4148  IssmDouble *xyz_list = NULL;
4149  GaussTria* gauss=NULL;
4150  IssmDouble epsilon[3];
4151  IssmDouble vx,vy,vel;
4152  IssmDouble strainxx;
4153  IssmDouble strainxy;
4154  IssmDouble strainyy;
4155  IssmDouble strainperpendicular[NUMVERTICES];
4156 
4157  /* Get node coordinates and dof list: */
4158  this->GetVerticesCoordinates(&xyz_list);
4159 
4160  /*Retrieve all inputs we will need*/
4161  Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
4162  Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
4163 
4164  /* Start looping on the number of vertices: */
4165  gauss=new GaussTria();
4166  for (int iv=0;iv<NUMVERTICES;iv++){
4167  gauss->GaussVertex(iv);
4168 
4169  /* Get the value we need*/
4170  vx_input->GetInputValue(&vx,gauss);
4171  vy_input->GetInputValue(&vy,gauss);
4172  vel=vx*vx+vy*vy;
4173 
4174  /*Compute strain rate viscosity and pressure: */
4175  this->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
4176  strainxx=epsilon[0];
4177  strainyy=epsilon[1];
4178  strainxy=epsilon[2];
4179 
4180  /*strainperpendicular= Strain rate perpendicular to the ice flow direction */
4181  strainperpendicular[iv]=(vx*vx*(strainyy)+vy*vy*(strainxx)-2*vy*vx*strainxy)/(vel+1.e-14);
4182  }
4183 
4184  /*Add input*/
4185  this->AddInput2(StrainRateperpendicularEnum,&strainperpendicular[0],P1DGEnum);
4186 
4187  /*Clean up and return*/
4188  delete gauss;
4189  xDelete<IssmDouble>(xyz_list);
4190 }
4191 /*}}}*/
4192 IssmDouble Tria::SurfaceArea(void){/*{{{*/
4193 
4194  IssmDouble S;
4195  IssmDouble normal[3];
4196  IssmDouble v13[3],v23[3];
4197  IssmDouble xyz_list[NUMVERTICES][3];
4198 
4199  /*If on water, return 0: */
4200  if(!IsIceInElement()) return 0.;
4201 
4202  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
4203 
4204  for(int i=0;i<3;i++){
4205  v13[i]=xyz_list[0][i]-xyz_list[2][i];
4206  v23[i]=xyz_list[1][i]-xyz_list[2][i];
4207  }
4208 
4209  normal[0]=v13[1]*v23[2]-v13[2]*v23[1];
4210  normal[1]=v13[2]*v23[0]-v13[0]*v23[2];
4211  normal[2]=v13[0]*v23[1]-v13[1]*v23[0];
4212 
4213  S = 0.5 * sqrt(normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]);
4214 
4215  /*Return: */
4216  return S;
4217 }
4218 /*}}}*/
4219 int Tria::TensorInterpolation(void){/*{{{*/
4220  return TriaRef::TensorInterpolation(this->element_type);
4221 }
4222 /*}}}*/
4223 IssmDouble Tria::TimeAdapt(void){/*{{{*/
4224 
4225  /*intermediary: */
4226  IssmDouble C;
4227  IssmDouble xyz_list[NUMVERTICES][3];
4228 
4229  /*get CFL coefficient:*/
4230  this->parameters->FindParam(&C,TimesteppingCflCoefficientEnum);
4231 
4232  /*Get for Vx and Vy, the max of abs value: */
4233  Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
4234  Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
4235  IssmDouble maxabsvx = vx_input->GetInputMaxAbs();
4236  IssmDouble maxabsvy = vy_input->GetInputMaxAbs();
4237 
4238  /* Get node coordinates and dof list: */
4239  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
4240 
4241  IssmDouble minx=xyz_list[0][0];
4242  IssmDouble maxx=xyz_list[0][0];
4243  IssmDouble miny=xyz_list[0][1];
4244  IssmDouble maxy=xyz_list[0][1];
4245 
4246  for(int i=1;i<NUMVERTICES;i++){
4247  if(xyz_list[i][0]<minx) minx=xyz_list[i][0];
4248  if(xyz_list[i][0]>maxx) maxx=xyz_list[i][0];
4249  if(xyz_list[i][1]<miny) miny=xyz_list[i][1];
4250  if(xyz_list[i][1]>maxy) maxy=xyz_list[i][1];
4251  }
4252  IssmDouble dx=maxx-minx;
4253  IssmDouble dy=maxy-miny;
4254 
4255  /*CFL criterion: */
4256  IssmDouble dt = C/(maxabsvx/dx+maxabsvy/dy);
4257 
4258  return dt;
4259 }
4260 /*}}}*/
4261 IssmDouble Tria::TotalCalvingFluxLevelset(bool scaled){/*{{{*/
4262 
4263  /*Make sure there is an ice front here*/
4264  if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)) return 0;
4265 
4266  /*Scaled not implemented yet...*/
4267  _assert_(!scaled);
4268 
4269  int domaintype,index1,index2;
4270  const IssmPDouble epsilon = 1.e-15;
4271  IssmDouble s1,s2;
4272  IssmDouble gl[NUMVERTICES];
4273  IssmDouble xyz_front[2][3];
4274 
4275 
4276  IssmDouble *xyz_list = NULL;
4277  this->GetVerticesCoordinates(&xyz_list);
4278 
4279  /*Recover parameters and values*/
4280  parameters->FindParam(&domaintype,DomainTypeEnum);
4281  Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
4282 
4283  /*Be sure that values are not zero*/
4284  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
4285  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
4286  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
4287 
4288  if(domaintype==Domain2DverticalEnum){
4289  _error_("not implemented");
4290  }
4291  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
4292  int pt1 = 0;
4293  int pt2 = 1;
4294  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
4295 
4296  /*Portion of the segments*/
4297  s1=gl[2]/(gl[2]-gl[1]);
4298  s2=gl[2]/(gl[2]-gl[0]);
4299  if(gl[2]<0.){
4300  pt1 = 1; pt2 = 0;
4301  }
4302  xyz_front[pt2][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
4303  xyz_front[pt2][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
4304  xyz_front[pt2][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
4305  xyz_front[pt1][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
4306  xyz_front[pt1][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
4307  xyz_front[pt1][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
4308  }
4309  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
4310 
4311  /*Portion of the segments*/
4312  s1=gl[0]/(gl[0]-gl[1]);
4313  s2=gl[0]/(gl[0]-gl[2]);
4314  if(gl[0]<0.){
4315  pt1 = 1; pt2 = 0;
4316  }
4317 
4318  xyz_front[pt1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
4319  xyz_front[pt1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
4320  xyz_front[pt1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
4321  xyz_front[pt2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
4322  xyz_front[pt2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
4323  xyz_front[pt2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
4324  }
4325  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
4326 
4327  /*Portion of the segments*/
4328  s1=gl[1]/(gl[1]-gl[0]);
4329  s2=gl[1]/(gl[1]-gl[2]);
4330  if(gl[1]<0.){
4331  pt1 = 1; pt2 = 0;
4332  }
4333 
4334  xyz_front[pt2][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
4335  xyz_front[pt2][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
4336  xyz_front[pt2][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
4337  xyz_front[pt1][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
4338  xyz_front[pt1][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
4339  xyz_front[pt1][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
4340  }
4341  else{
4342  _error_("case not possible");
4343  }
4344 
4345  }
4346  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
4347 
4348  /*Some checks in debugging mode*/
4349  _assert_(s1>=0 && s1<=1.);
4350  _assert_(s2>=0 && s2<=1.);
4351 
4352  /*Get normal vector*/
4353  IssmDouble normal[3];
4354  this->NormalSection(&normal[0],&xyz_front[0][0]);
4355  normal[0] = -normal[0];
4356  normal[1] = -normal[1];
4357 
4358  /*Get inputs*/
4359  IssmDouble flux = 0.;
4360  IssmDouble calvingratex,calvingratey,thickness,Jdet;
4361  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
4362  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
4363  Input2* calvingratex_input=NULL;
4364  Input2* calvingratey_input=NULL;
4365  if(domaintype==Domain2DhorizontalEnum){
4366  calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
4367  calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
4368  }
4369  else{
4370  calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
4371  calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
4372  }
4373 
4374  /*Start looping on Gaussian points*/
4375  Gauss* gauss=this->NewGauss(xyz_list,&xyz_front[0][0],3);
4376  for(int ig=gauss->begin();ig<gauss->end();ig++){
4377 
4378  gauss->GaussPoint(ig);
4379  thickness_input->GetInputValue(&thickness,gauss);
4380  calvingratex_input->GetInputValue(&calvingratex,gauss);
4381  calvingratey_input->GetInputValue(&calvingratey,gauss);
4382  this->JacobianDeterminantSurface(&Jdet,&xyz_front[0][0],gauss);
4383 
4384  flux += rho_ice*Jdet*gauss->weight*thickness*(calvingratex*normal[0] + calvingratey*normal[1]);
4385  }
4386 
4387  return flux;
4388 }
4389 /*}}}*/
4390 IssmDouble Tria::TotalCalvingMeltingFluxLevelset(bool scaled){/*{{{*/
4391 
4392  /*Make sure there is an ice front here*/
4393  if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)) return 0;
4394 
4395  /*Scaled not implemented yet...*/
4396  _assert_(!scaled);
4397 
4398  int domaintype,index1,index2;
4399  const IssmPDouble epsilon = 1.e-15;
4400  IssmDouble s1,s2;
4401  IssmDouble gl[NUMVERTICES];
4402  IssmDouble xyz_front[2][3];
4403 
4404 
4405  IssmDouble *xyz_list = NULL;
4406  this->GetVerticesCoordinates(&xyz_list);
4407 
4408  /*Recover parameters and values*/
4409  parameters->FindParam(&domaintype,DomainTypeEnum);
4410  Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
4411 
4412  /*Be sure that values are not zero*/
4413  if(gl[0]==0.) gl[0]=gl[0]+epsilon;
4414  if(gl[1]==0.) gl[1]=gl[1]+epsilon;
4415  if(gl[2]==0.) gl[2]=gl[2]+epsilon;
4416 
4417  if(domaintype==Domain2DverticalEnum){
4418  _error_("not implemented");
4419  }
4420  else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum || domaintype==Domain3DsurfaceEnum){
4421  int pt1 = 0;
4422  int pt2 = 1;
4423  if(gl[0]*gl[1]>0){ //Nodes 0 and 1 are similar, so points must be found on segment 0-2 and 1-2
4424 
4425  /*Portion of the segments*/
4426  s1=gl[2]/(gl[2]-gl[1]);
4427  s2=gl[2]/(gl[2]-gl[0]);
4428  if(gl[2]<0.){
4429  pt1 = 1; pt2 = 0;
4430  }
4431  xyz_front[pt2][0]=xyz_list[3*2+0]+s1*(xyz_list[3*1+0]-xyz_list[3*2+0]);
4432  xyz_front[pt2][1]=xyz_list[3*2+1]+s1*(xyz_list[3*1+1]-xyz_list[3*2+1]);
4433  xyz_front[pt2][2]=xyz_list[3*2+2]+s1*(xyz_list[3*1+2]-xyz_list[3*2+2]);
4434  xyz_front[pt1][0]=xyz_list[3*2+0]+s2*(xyz_list[3*0+0]-xyz_list[3*2+0]);
4435  xyz_front[pt1][1]=xyz_list[3*2+1]+s2*(xyz_list[3*0+1]-xyz_list[3*2+1]);
4436  xyz_front[pt1][2]=xyz_list[3*2+2]+s2*(xyz_list[3*0+2]-xyz_list[3*2+2]);
4437  }
4438  else if(gl[1]*gl[2]>0){ //Nodes 1 and 2 are similar, so points must be found on segment 0-1 and 0-2
4439 
4440  /*Portion of the segments*/
4441  s1=gl[0]/(gl[0]-gl[1]);
4442  s2=gl[0]/(gl[0]-gl[2]);
4443  if(gl[0]<0.){
4444  pt1 = 1; pt2 = 0;
4445  }
4446 
4447  xyz_front[pt1][0]=xyz_list[3*0+0]+s1*(xyz_list[3*1+0]-xyz_list[3*0+0]);
4448  xyz_front[pt1][1]=xyz_list[3*0+1]+s1*(xyz_list[3*1+1]-xyz_list[3*0+1]);
4449  xyz_front[pt1][2]=xyz_list[3*0+2]+s1*(xyz_list[3*1+2]-xyz_list[3*0+2]);
4450  xyz_front[pt2][0]=xyz_list[3*0+0]+s2*(xyz_list[3*2+0]-xyz_list[3*0+0]);
4451  xyz_front[pt2][1]=xyz_list[3*0+1]+s2*(xyz_list[3*2+1]-xyz_list[3*0+1]);
4452  xyz_front[pt2][2]=xyz_list[3*0+2]+s2*(xyz_list[3*2+2]-xyz_list[3*0+2]);
4453  }
4454  else if(gl[0]*gl[2]>0){ //Nodes 0 and 2 are similar, so points must be found on segment 1-0 and 1-2
4455 
4456  /*Portion of the segments*/
4457  s1=gl[1]/(gl[1]-gl[0]);
4458  s2=gl[1]/(gl[1]-gl[2]);
4459  if(gl[1]<0.){
4460  pt1 = 1; pt2 = 0;
4461  }
4462 
4463  xyz_front[pt2][0]=xyz_list[3*1+0]+s1*(xyz_list[3*0+0]-xyz_list[3*1+0]);
4464  xyz_front[pt2][1]=xyz_list[3*1+1]+s1*(xyz_list[3*0+1]-xyz_list[3*1+1]);
4465  xyz_front[pt2][2]=xyz_list[3*1+2]+s1*(xyz_list[3*0+2]-xyz_list[3*1+2]);
4466  xyz_front[pt1][0]=xyz_list[3*1+0]+s2*(xyz_list[3*2+0]-xyz_list[3*1+0]);
4467  xyz_front[pt1][1]=xyz_list[3*1+1]+s2*(xyz_list[3*2+1]-xyz_list[3*1+1]);
4468  xyz_front[pt1][2]=xyz_list[3*1+2]+s2*(xyz_list[3*2+2]-xyz_list[3*1+2]);
4469  }
4470  else{
4471  _error_("case not possible");
4472  }
4473 
4474  }
4475  else _error_("mesh type "<<EnumToStringx(domaintype)<<"not supported yet ");
4476 
4477  /*Some checks in debugging mode*/
4478  _assert_(s1>=0 && s1<=1.);
4479  _assert_(s2>=0 && s2<=1.);
4480 
4481  /*Get normal vector*/
4482  IssmDouble normal[3];
4483  this->NormalSection(&normal[0],&xyz_front[0][0]);
4484  normal[0] = -normal[0];
4485  normal[1] = -normal[1];
4486 
4487  /*Get inputs*/
4488  IssmDouble flux = 0.;
4489  IssmDouble calvingratex,calvingratey,vx,vy,vel,meltingrate,meltingratex,meltingratey,thickness,Jdet;
4490  IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
4491  Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
4492  Input2* calvingratex_input=NULL;
4493  Input2* calvingratey_input=NULL;
4494  Input2* vx_input=NULL;
4495  Input2* vy_input=NULL;
4496  Input2* meltingrate_input=NULL;
4497  if(domaintype==Domain2DhorizontalEnum){
4498  calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
4499  calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
4500  vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
4501  vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
4502  meltingrate_input=this->GetInput2(CalvingMeltingrateEnum); _assert_(meltingrate_input);
4503  }
4504  else{
4505  calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
4506  calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
4507  }
4508 
4509  /*Start looping on Gaussian points*/
4510  Gauss* gauss=this->NewGauss(xyz_list,&xyz_front[0][0],3);
4511  for(int ig=gauss->begin();ig<gauss->end();ig++){
4512 
4513  gauss->GaussPoint(ig);
4514  thickness_input->GetInputValue(&thickness,gauss);
4515  calvingratex_input->GetInputValue(&calvingratex,gauss);
4516  calvingratey_input->GetInputValue(&calvingratey,gauss);
4517  vx_input->GetInputValue(&vx,gauss);
4518  vy_input->GetInputValue(&vy,gauss);
4519  vel=vx*vx+vy*vy;
4520  meltingrate_input->GetInputValue(&meltingrate,gauss);
4521  meltingratex=meltingrate*vx/(sqrt(vel)+1.e-14);
4522  meltingratey=meltingrate*vy/(sqrt(vel)+1.e-14);
4523  this->JacobianDeterminantSurface(&Jdet,&xyz_front[0][0],gauss);
4524 
4525  flux += rho_ice*Jdet*gauss->weight*thickness*((calvingratex+meltingratex)*normal[0] + (calvingratey+meltingratey)*normal[1]);
4526  }
4527 
4528  return flux;
4529 }
4530 /*}}}*/
4531 IssmDouble Tria::TotalFloatingBmb(bool scaled){/*{{{*/
4532 
4533  /*The fbmb[kg yr-1] of one element is area[m2] * melting_rate [kg m^-2 yr^-1]*/
4534  int point1;
4535  bool mainlyfloating;
4536  IssmDouble fbmb=0;
4537  IssmDouble rho_ice,fraction1,fraction2,floatingmelt,Jdet,scalefactor;
4538  IssmDouble Total_Fbmb=0;
4539  IssmDouble xyz_list[NUMVERTICES][3];
4540  Gauss* gauss = NULL;
4541 
4542  if(!IsIceInElement())return 0;
4543 
4544  /*Get material parameters :*/
4545  rho_ice=FindParam(MaterialsRhoIceEnum);
4546  Input2* floatingmelt_input = this->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
4547  Input2* gllevelset_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
4548  Input2* scalefactor_input = NULL;
4549  if(scaled==true){
4550  scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
4551  }
4552  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
4553 
4554  this->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
4555  /* Start looping on the number of gaussian points: */
4556  gauss = this->NewGauss(point1,fraction1,fraction2,1-mainlyfloating,3);
4557  for(int ig=gauss->begin();ig<gauss->end();ig++){
4558 
4559  gauss->GaussPoint(ig);
4560  this->JacobianDeterminant(&Jdet,&xyz_list[0][0],gauss);
4561  floatingmelt_input->GetInputValue(&floatingmelt,gauss);
4562  if(scaled==true){
4563  scalefactor_input->GetInputValue(&scalefactor,gauss);
4564  }
4565  else scalefactor=1;
4566  fbmb+=floatingmelt*Jdet*gauss->weight*scalefactor;
4567  }
4568 
4569  Total_Fbmb=rho_ice*fbmb; // from volume to mass
4570 
4571  /*Return: */
4572  delete gauss;
4573  return Total_Fbmb;
4574 }
4575 /*}}}*/
4576 IssmDouble Tria::TotalGroundedBmb(bool scaled){/*{{{*/
4577 
4578  /*The gbmb[kg yr-1] of one element is area[m2] * gounded melting rate [kg m^-2 yr^-1]*/
4579  int point1;
4580  bool mainlyfloating;
4581  IssmDouble gbmb=0;
4582  IssmDouble rho_ice,fraction1,fraction2,groundedmelt,Jdet,scalefactor;
4583  IssmDouble Total_Gbmb=0;
4584  IssmDouble xyz_list[NUMVERTICES][3];
4585  Gauss* gauss = NULL;
4586 
4587  if(!IsIceInElement())return 0;
4588 
4589  /*Get material parameters :*/
4590  rho_ice=FindParam(MaterialsRhoIceEnum);
4591  Input2* groundedmelt_input = this->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
4592  Input2* gllevelset_input = this->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
4593  Input2* scalefactor_input = NULL;
4594  if(scaled==true){
4595  scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
4596  }
4597  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
4598 
4599  this->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
4600  /* Start looping on the number of gaussian points: */
4601  gauss = this->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
4602  for(int ig=gauss->begin();ig<gauss->end();ig++){
4603 
4604  gauss->GaussPoint(ig);
4605  this->JacobianDeterminant(&Jdet,&xyz_list[0][0],gauss);
4606  groundedmelt_input->GetInputValue(&groundedmelt,gauss);
4607  if(scaled==true){
4608  scalefactor_input->GetInputValue(&scalefactor,gauss);
4609  }
4610  else scalefactor=1;
4611  gbmb+=groundedmelt*Jdet*gauss->weight*scalefactor;
4612  }
4613 
4614  Total_Gbmb=rho_ice*gbmb; // from volume to mass
4615 
4616  /*Return: */
4617  delete gauss;
4618  return Total_Gbmb;
4619 }
4620 /*}}}*/
4621 IssmDouble Tria::TotalSmb(bool scaled){/*{{{*/
4622 
4623  /*The smb[kg yr-1] of one element is area[m2] * smb [kg m^-2 yr^-1]*/
4624  IssmDouble base,smb,rho_ice,scalefactor;
4625  IssmDouble Total_Smb=0;
4626  IssmDouble xyz_list[NUMVERTICES][3];
4627 
4628  /*Get material parameters :*/
4629  rho_ice=FindParam(MaterialsRhoIceEnum);
4630 
4631  if(!IsIceInElement())return 0;
4632 
4633  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
4634 
4635  /*First calculate the area of the base (cross section triangle)
4636  * http://en.wikipedia.org/wiki/Triangle
4637  * base = 1/2 abs((xA-xC)(yB-yA)-(xA-xB)(yC-yA))*/
4638  base = 1./2. * fabs((xyz_list[0][0]-xyz_list[2][0])*(xyz_list[1][1]-xyz_list[0][1]) - (xyz_list[0][0]-xyz_list[1][0])*(xyz_list[2][1]-xyz_list[0][1])); // area of element in m2
4639 
4640  /*Now get the average SMB over the element*/
4641  Input2* smb_input = this->GetInput2(SmbMassBalanceEnum); _assert_(smb_input);
4642  smb_input->GetInputAverage(&smb); // average smb on element in m ice s-1
4643  if(scaled==true){
4644  Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
4645  scalefactor_input->GetInputAverage(&scalefactor);// average scalefactor on element
4646  }
4647  else{
4648  scalefactor=1.;
4649  }
4650  Total_Smb=rho_ice*base*smb*scalefactor; // smb on element in kg s-1
4651 
4652  /*Return: */
4653  return Total_Smb;
4654 }
4655 /*}}}*/
4656 void Tria::Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){/*{{{*/
4657 
4658  /*Intermediaries*/
4659  int numnodes;
4660  int* tria_node_ids = NULL;
4661 
4662  /*Checks if debuging*/
4663  _assert_(iomodel->elements);
4664  _assert_(index==this->sid);
4665 
4666  /*Recover element type*/
4667  this->element_type_list[analysis_counter]=finiteelement_type;
4668 
4669  /*Recover nodes ids needed to initialize the node hook.*/
4670  switch(finiteelement_type){
4671  case P0DGEnum:
4672  numnodes = 1;
4673  tria_node_ids = xNew<int>(numnodes);
4674  tria_node_ids[0]= index + 1;
4675  break;
4676  case P1Enum:
4677  numnodes = 3;
4678  tria_node_ids = xNew<int>(numnodes);
4679  tria_node_ids[0]=iomodel->elements[3*index+0];
4680  tria_node_ids[1]=iomodel->elements[3*index+1];
4681  tria_node_ids[2]=iomodel->elements[3*index+2];
4682  break;
4683  case P1DGEnum:
4684  numnodes = 3;
4685  tria_node_ids = xNew<int>(numnodes);
4686  tria_node_ids[0]=3*index+1;
4687  tria_node_ids[1]=3*index+2;
4688  tria_node_ids[2]=3*index+3;
4689  break;
4690  case P1bubbleEnum: case P1bubblecondensedEnum:
4691  numnodes = 4;
4692  tria_node_ids = xNew<int>(numnodes);
4693  tria_node_ids[0]=iomodel->elements[3*index+0];
4694  tria_node_ids[1]=iomodel->elements[3*index+1];
4695  tria_node_ids[2]=iomodel->elements[3*index+2];
4696  tria_node_ids[3]=iomodel->numberofvertices+index+1;
4697  break;
4698  case P2Enum:
4699  numnodes = 6;
4700  tria_node_ids = xNew<int>(numnodes);
4701  tria_node_ids[0]=iomodel->elements[3*index+0];
4702  tria_node_ids[1]=iomodel->elements[3*index+1];
4703  tria_node_ids[2]=iomodel->elements[3*index+2];
4704  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1;
4705  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1;
4706  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1;
4707  break;
4708  case P2bubbleEnum: case P2bubblecondensedEnum:
4709  numnodes = 7;
4710  tria_node_ids = xNew<int>(numnodes);
4711  tria_node_ids[0]=iomodel->elements[3*index+0];
4712  tria_node_ids[1]=iomodel->elements[3*index+1];
4713  tria_node_ids[2]=iomodel->elements[3*index+2];
4714  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1;
4715  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1;
4716  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1;
4717  tria_node_ids[6]=iomodel->numberofvertices+iomodel->numberofedges+index+1;
4718  break;
4719  case P1P1Enum: case P1P1GLSEnum:
4720  numnodes = 6;
4721  tria_node_ids = xNew<int>(numnodes);
4722  tria_node_ids[0]=iomodel->elements[3*index+0];
4723  tria_node_ids[1]=iomodel->elements[3*index+1];
4724  tria_node_ids[2]=iomodel->elements[3*index+2];
4725 
4726  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elements[3*index+0];
4727  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elements[3*index+1];
4728  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elements[3*index+2];
4729  break;
4730  case MINIEnum: case MINIcondensedEnum:
4731  numnodes = 7;
4732  tria_node_ids = xNew<int>(numnodes);
4733  tria_node_ids[0]=iomodel->elements[3*index+0];
4734  tria_node_ids[1]=iomodel->elements[3*index+1];
4735  tria_node_ids[2]=iomodel->elements[3*index+2];
4736  tria_node_ids[3]=iomodel->numberofvertices+index+1;
4737 
4738  tria_node_ids[4]=iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[3*index+0];
4739  tria_node_ids[5]=iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[3*index+1];
4740  tria_node_ids[6]=iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[3*index+2];
4741  break;
4742  case TaylorHoodEnum:
4743  case XTaylorHoodEnum:
4744  numnodes = 9;
4745  tria_node_ids = xNew<int>(numnodes);
4746  tria_node_ids[0]=iomodel->elements[3*index+0];
4747  tria_node_ids[1]=iomodel->elements[3*index+1];
4748  tria_node_ids[2]=iomodel->elements[3*index+2];
4749  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1;
4750  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1;
4751  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1;
4752 
4753  tria_node_ids[6]=iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[3*index+0];
4754  tria_node_ids[7]=iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[3*index+1];
4755  tria_node_ids[8]=iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[3*index+2];
4756  break;
4757  case LATaylorHoodEnum:
4758  numnodes = 6;
4759  tria_node_ids = xNew<int>(numnodes);
4760  tria_node_ids[0]=iomodel->elements[3*index+0];
4761  tria_node_ids[1]=iomodel->elements[3*index+1];
4762  tria_node_ids[2]=iomodel->elements[3*index+2];
4763  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1;
4764  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1;
4765  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1;
4766  break;
4767  case CrouzeixRaviartEnum:
4768  numnodes = 10;
4769  tria_node_ids = xNew<int>(numnodes);
4770  tria_node_ids[0]=iomodel->elements[3*index+0];
4771  tria_node_ids[1]=iomodel->elements[3*index+1];
4772  tria_node_ids[2]=iomodel->elements[3*index+2];
4773  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1;
4774  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1;
4775  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1;
4776  tria_node_ids[6]=iomodel->numberofvertices+iomodel->numberofedges+index+1;
4777 
4778  tria_node_ids[7]=iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberofelements+3*index+1;
4779  tria_node_ids[8]=iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberofelements+3*index+2;
4780  tria_node_ids[9]=iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberofelements+3*index+3;
4781  break;
4782  case LACrouzeixRaviartEnum:
4783  numnodes = 7;
4784  tria_node_ids = xNew<int>(numnodes);
4785  tria_node_ids[0]=iomodel->elements[3*index+0];
4786  tria_node_ids[1]=iomodel->elements[3*index+1];
4787  tria_node_ids[2]=iomodel->elements[3*index+2];
4788  tria_node_ids[3]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1;
4789  tria_node_ids[4]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1;
4790  tria_node_ids[5]=iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1;
4791  tria_node_ids[6]=iomodel->numberofvertices+iomodel->numberofedges+index+1;
4792  break;
4793  default:
4794  _error_("Finite element "<<EnumToStringx(finiteelement_type)<<" not supported yet");
4795  }
4796 
4797  /*hooks: */
4798  this->SetHookNodes(tria_node_ids,numnodes,analysis_counter); this->nodes=NULL;
4799  xDelete<int>(tria_node_ids);
4800 }
4801 /*}}}*/
4802 void Tria::UpdateConstraintsExtrudeFromBase(void){/*{{{*/
4803 
4804  if(!HasNodeOnBase()) return;
4805 
4806  int extrusioninput;
4807  IssmDouble value,isonbase;
4808 
4809  this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
4810  Input2* input = this->GetInput2(extrusioninput); _assert_(input);
4811  Input2* onbase = this->GetInput2(MeshVertexonbaseEnum); _assert_(onbase);
4812 
4813  GaussTria* gauss=new GaussTria();
4814  for(int iv=0;iv<this->NumberofNodes(this->element_type);iv++){
4815  gauss->GaussNode(this->element_type,iv);
4816  onbase->GetInputValue(&isonbase,gauss);
4817  if(isonbase==1.){
4818  input->GetInputValue(&value,gauss);
4819  this->nodes[iv]->ApplyConstraint(0,value);
4820  }
4821  }
4822  delete gauss;
4823 
4824 }
4825 /*}}}*/
4826 void Tria::UpdateConstraintsExtrudeFromTop(void){/*{{{*/
4827 
4828  if(!HasNodeOnSurface()) return;
4829 
4830  int extrusioninput;
4831  IssmDouble value,isonsurface;
4832 
4833  this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
4834  Input2* input = this->GetInput2(extrusioninput); _assert_(input);
4835  Input2* onsurf = this->GetInput2(MeshVertexonsurfaceEnum); _assert_(onsurf);
4836 
4837  GaussTria* gauss=new GaussTria();
4838  for(int iv=0;iv<this->NumberofNodes(this->element_type);iv++){
4839  gauss->GaussNode(this->element_type,iv);
4840  onsurf->GetInputValue(&isonsurface,gauss);
4841  if(isonsurface==1.){
4842  input->GetInputValue(&value,gauss);
4843  this->nodes[iv]->ApplyConstraint(0,value);
4844  }
4845  }
4846  delete gauss;
4847 }
4848 /*}}}*/
4849 int Tria::UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf){/*{{{*/
4850 
4851  int i;
4852  int nflipped=0;
4853 
4854  /*Go through nodes, and whoever is on the potential_ungrounding, ends up in nodes_on_iceshelf: */
4855  for(i=0;i<3;i++){
4856  if (reCast<bool>(vertices_potentially_ungrounding[vertices[i]->Pid()])){
4857  vec_nodes_on_iceshelf->SetValue(vertices[i]->Pid(),-1.,INS_VAL);
4858 
4859  /*If node was not on ice shelf, we flipped*/
4860  if(nodes_on_iceshelf[vertices[i]->Pid()]>=0.){
4861  nflipped++;
4862  }
4863  }
4864  }
4865  return nflipped;
4866 }
4867 /*}}}*/
4868 void Tria::ValueP1DerivativesOnGauss(IssmDouble* dvalue,IssmDouble* values,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
4869  TriaRef::GetInputDerivativeValue(dvalue,values,xyz_list,gauss,P1Enum);
4870 }
4871 /*}}}*/
4872 void Tria::ValueP1OnGauss(IssmDouble* pvalue,IssmDouble* values,Gauss* gauss){/*{{{*/
4873  TriaRef::GetInputValue(pvalue,values,gauss,P1Enum);
4874 }
4875 /*}}}*/
4876 int Tria::VelocityInterpolation(void){/*{{{*/
4877  return TriaRef::VelocityInterpolation(this->element_type);
4878 }
4879 /*}}}*/
4880 int Tria::VertexConnectivity(int vertexindex){/*{{{*/
4881  _assert_(this->vertices);
4882  return this->vertices[vertexindex]->Connectivity();
4883 }
4884 /*}}}*/
4885 void Tria::WriteFieldIsovalueSegment(DataSet* segments,int fieldenum,IssmDouble fieldvalue){/*{{{*/
4886 
4887  _assert_(fieldvalue==0.); //field value != 0 not implemented yet
4888 
4889  /*Get field on vertices (we do not allow for higher order elements!!)*/
4890  IssmDouble lsf[NUMVERTICES];
4891  Element::GetInputListOnVertices(&lsf[0],fieldenum);
4892 
4893  /*1. check that we do cross fieldvalue in this element*/
4894  IssmDouble minvalue = lsf[0];
4895  IssmDouble maxvalue = lsf[0];
4896  for(int i=1;i<NUMVERTICES;i++){
4897  if(lsf[i]>maxvalue) maxvalue = lsf[i];
4898  if(lsf[i]<minvalue) minvalue = lsf[i];
4899  }
4900  if(minvalue>fieldvalue) return;
4901  if(maxvalue<fieldvalue) return;
4902 
4903  /*2. Find coordinates of where levelset crosses 0*/
4904  int numiceverts;
4905  IssmDouble s[2],x[2],y[2];
4906  int *indices = NULL;
4907  this->GetLevelsetIntersection(&indices, &numiceverts,&s[0],fieldenum,fieldvalue);
4908  _assert_(numiceverts);
4909 
4910  /*3 Write coordinates*/
4911  IssmDouble xyz_list[NUMVERTICES][3];
4912  ::GetVerticesCoordinates(&xyz_list[0][0],this->vertices,NUMVERTICES);
4913  int counter = 0;
4914  if((numiceverts>0) && (numiceverts<NUMVERTICES)){
4915  for(int i=0;i<numiceverts;i++){
4916  for(int n=numiceverts;n<NUMVERTICES;n++){ // iterate over no-ice vertices
4917  x[counter] = xyz_list[indices[i]][0]+s[counter]*(xyz_list[indices[n]][0]-xyz_list[indices[i]][0]);
4918  y[counter] = xyz_list[indices[i]][1]+s[counter]*(xyz_list[indices[n]][1]-xyz_list[indices[i]][1]);
4919  counter++;
4920  }
4921  }
4922  }
4923  else if(numiceverts==NUMVERTICES){ //NUMVERTICES ice vertices: calving front lies on element edge
4924 
4925  for(int i=0;i<NUMVERTICES;i++){
4926  if(lsf[indices[i]]==0.){
4927  x[counter]=xyz_list[indices[i]][0];
4928  y[counter]=xyz_list[indices[i]][1];
4929  counter++;
4930  }
4931  if(counter==2) break;
4932  }
4933  if(counter==1){
4934  /*We actually have only 1 vertex on levelset, write a single point as a segment*/
4935  x[counter]=x[0];
4936  y[counter]=y[0];
4937  counter++;
4938  }
4939  }
4940  else{
4941  _error_("not sure what's going on here...");
4942  }
4943 
4944  /*4. Write segment*/
4945  _assert_(counter==2);
4946  segments->AddObject(new Contour<IssmDouble>(segments->Size()+1,2,&x[0],&y[0],false));
4947 
4948  /*Cleanup and return*/
4949  xDelete<int>(indices);
4950 }
4951 /*}}}*/
4952 
4953 #ifdef _HAVE_GIA_
4954 void Tria::GiaDeflection(Vector<IssmDouble>* wg,Vector<IssmDouble>* dwgdt,IssmDouble* x, IssmDouble* y){/*{{{*/
4955 
4956  IssmDouble xyz_list[NUMVERTICES][3];
4957 
4958  /*gia solution parameters:*/
4959  IssmDouble lithosphere_thickness,mantle_viscosity;
4960 
4961  /*output: */
4962  IssmDouble wi;
4963  IssmDouble dwidt;
4964 
4965  /*arguments to GiaDeflectionCorex: */
4966  GiaDeflectionCoreArgs arguments;
4967 
4968  /*how many dofs are we working with here? */
4969  int gsize;
4970  IssmDouble yts;
4971  this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
4972  this->parameters->FindParam(&yts,ConstantsYtsEnum);
4973 
4974  /*recover gia solution parameters: */
4975  int cross_section_shape;
4976  this->parameters->FindParam(&cross_section_shape,GiaCrossSectionShapeEnum);
4977 
4978  /*what time is it? :*/
4979  IssmDouble currenttime;
4980  this->parameters->FindParam(&currenttime,TimeEnum);
4981 
4982  /*recover material parameters: */
4983  IssmDouble lithosphere_shear_modulus = FindParam(MaterialsLithosphereShearModulusEnum);
4984  IssmDouble lithosphere_density = FindParam(MaterialsLithosphereDensityEnum);
4985  IssmDouble mantle_shear_modulus = FindParam(MaterialsMantleShearModulusEnum);
4986  IssmDouble mantle_density = FindParam(MaterialsMantleDensityEnum);
4987  IssmDouble rho_ice = FindParam(MaterialsRhoIceEnum);
4988 
4989  /*pull thickness averages! */
4990  IssmDouble *hes = NULL;
4991  IssmDouble *times = NULL;
4992  int numtimes;
4993  this->GetInputAveragesUpToCurrentTime(ThicknessEnum,&hes,&times,&numtimes,currenttime);
4994 
4995  /*recover mantle viscosity: */
4996  Input2* mantle_viscosity_input=this->GetInput2(GiaMantleViscosityEnum);
4997  if (!mantle_viscosity_input)_error_("mantle viscosity input needed to compute gia deflection!");
4998  mantle_viscosity_input->GetInputAverage(&mantle_viscosity);
4999 
5000  /*recover lithosphere thickness: */
5001  Input2* lithosphere_thickness_input=this->GetInput2(GiaLithosphereThicknessEnum);
5002  if (!lithosphere_thickness_input)_error_("lithosphere thickness input needed to compute gia deflection!");
5003  lithosphere_thickness_input->GetInputAverage(&lithosphere_thickness);
5004 
5005  /*pull area of this Tria: */
5006  IssmDouble area=this->GetArea();
5007 
5008  /*element radius: */
5009  IssmDouble re=sqrt(area/PI);
5010 
5011  /*figure out gravity center of our element: */
5012  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
5013  IssmDouble x0=(xyz_list[0][0]+xyz_list[1][0]+xyz_list[2][0])/3.0;
5014  IssmDouble y0=(xyz_list[0][1]+xyz_list[1][1]+xyz_list[2][1])/3.0;
5015 
5016  /*start loading GiaDeflectionCore arguments: */
5017  arguments.re=re;
5018  arguments.hes=hes;
5019  arguments.times=times;
5020  arguments.numtimes=numtimes;
5021  arguments.currenttime=currenttime;
5022  arguments.lithosphere_shear_modulus=lithosphere_shear_modulus;
5023  arguments.lithosphere_density=lithosphere_density;
5024  arguments.mantle_shear_modulus=mantle_shear_modulus;
5025  arguments.mantle_viscosity=mantle_viscosity;
5026  arguments.mantle_density=mantle_density;
5027  arguments.lithosphere_thickness=lithosphere_thickness;
5028  arguments.rho_ice=rho_ice;
5029  arguments.idisk=this->id;
5030  arguments.iedge=cross_section_shape;
5031  arguments.yts=yts;
5032 
5033  for(int i=0;i<gsize;i++){
5034  /*compute distance from the center of the tria to the vertex i: */
5035  IssmDouble xi=x[i];
5036  IssmDouble yi=y[i];
5037  IssmDouble ri=sqrt(pow(xi-x0,2)+pow(yi-y0,2));
5038 
5039  /*load ri onto arguments for this vertex i: */
5040  arguments.ri=ri;
5041 
5042  /*for this Tria, compute contribution to rebound at vertex i: */
5043  GiaDeflectionCorex(&wi,&dwidt,&arguments);
5044 
5045  /*plug value into solution vector: */
5046  wg->SetValue(i,wi,ADD_VAL);
5047  dwgdt->SetValue(i,dwidt,ADD_VAL);
5048  }
5049 
5050  /*Free ressources: */
5051  xDelete<IssmDouble>(hes);
5052  xDelete<IssmDouble>(times);
5053 
5054  return;
5055 }
5056 /*}}}*/
5057 #endif
5058 #ifdef _HAVE_ESA_
5059 void Tria::EsaGeodetic2D(Vector<IssmDouble>* pUp,Vector<IssmDouble>* pNorth,Vector<IssmDouble>* pEast,Vector<IssmDouble>* pX,Vector<IssmDouble>* pY,IssmDouble* xx,IssmDouble* yy){ /*{{{*/
5060 
5061  /*diverse:*/
5062  int gsize;
5063  IssmDouble xyz_list[NUMVERTICES][3];
5064  IssmDouble area;
5065  IssmDouble earth_radius = 6371012.0; // Earth's radius [m]
5066  IssmDouble I; //ice/water loading
5067  IssmDouble rho_ice, rho_earth;
5068 
5069  /*precomputed elastic green functions:*/
5070  IssmDouble* U_elastic_precomputed = NULL;
5071  IssmDouble* H_elastic_precomputed = NULL;
5072  int M, hemi;
5073 
5074  /*computation of Green functions:*/
5075  IssmDouble* U_elastic= NULL;
5076  IssmDouble* N_elastic= NULL;
5077  IssmDouble* E_elastic= NULL;
5078  IssmDouble* X_elastic= NULL;
5079  IssmDouble* Y_elastic= NULL;
5080 
5081  /*optimization:*/
5082  bool store_green_functions=false;
5083 
5084  /*Compute ice thickness change: */
5085  Input2* deltathickness_input=this->GetInput2(EsaDeltathicknessEnum);
5086  if (!deltathickness_input)_error_("delta thickness input needed to compute elastic adjustment!");
5087  deltathickness_input->GetInputAverage(&I);
5088 
5089  /*early return if we are not on the (ice) loading point: */
5090  if(I==0) return;
5091 
5092  /*recover material parameters: */
5093  rho_ice=FindParam(MaterialsRhoIceEnum);
5094  rho_earth=FindParam(MaterialsEarthDensityEnum);
5095 
5096  /*how many dofs are we working with here? */
5097  this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
5098 
5099  /*which hemisphere? for north-south, east-west components*/
5100  this->parameters->FindParam(&hemi,EsaHemisphereEnum);
5101 
5102  /*compute area of element:*/
5103  area=GetArea();
5104 
5105  /*figure out gravity center of our element (Cartesian): */
5106  IssmDouble x_element, y_element;
5107  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
5108  x_element=(xyz_list[0][0]+xyz_list[1][0]+xyz_list[2][0])/3.0;
5109  y_element=(xyz_list[0][1]+xyz_list[1][1]+xyz_list[2][1])/3.0;
5110 
5111  /*recover elastic Green's functions for displacement:*/
5112  DoubleVecParam* U_parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(EsaUElasticEnum)); _assert_(U_parameter);
5113  DoubleVecParam* H_parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(EsaHElasticEnum)); _assert_(H_parameter);
5114  U_parameter->GetParameterValueByPointer(&U_elastic_precomputed,&M);
5115  H_parameter->GetParameterValueByPointer(&H_elastic_precomputed,&M);
5116 
5117  /*initialize: */
5118  U_elastic=xNewZeroInit<IssmDouble>(gsize);
5119  N_elastic=xNewZeroInit<IssmDouble>(gsize);
5120  E_elastic=xNewZeroInit<IssmDouble>(gsize);
5121  X_elastic=xNewZeroInit<IssmDouble>(gsize);
5122  Y_elastic=xNewZeroInit<IssmDouble>(gsize);
5123 
5124  int* indices=xNew<int>(gsize);
5125  IssmDouble* U_values=xNewZeroInit<IssmDouble>(gsize);
5126  IssmDouble* N_values=xNewZeroInit<IssmDouble>(gsize);
5127  IssmDouble* E_values=xNewZeroInit<IssmDouble>(gsize);
5128  IssmDouble* X_values=xNewZeroInit<IssmDouble>(gsize);
5129  IssmDouble* Y_values=xNewZeroInit<IssmDouble>(gsize);
5130  IssmDouble dx, dy, dist, alpha, ang, ang2;
5131  IssmDouble N_azim, E_azim, X_azim, Y_azim;
5132 
5133  for(int i=0;i<gsize;i++){
5134 
5135  indices[i]=i;
5136 
5137  IssmDouble N_azim=0;
5138  IssmDouble E_azim=0;
5139 
5140  /*Compute alpha angle between centroid and current vertex: */
5141  dx = x_element - xx[i]; dy = y_element - yy[i];
5142  dist = sqrt(pow(dx,2)+pow(dy,2)); // distance between vertex and elemental centroid [m]
5143  alpha = dist*360.0/(2*PI*earth_radius) * PI/180.0; // [in radians] 360 degree = 2*pi*earth_radius
5144 
5145  /*Compute azimuths, both north and east components: */
5146  ang = PI/2 - atan2(dy,dx); // this is bearing angle!
5147  Y_azim = cos(ang);
5148  X_azim = sin(ang);
5149 
5150  /*Elastic component (from Eq 17 in Adhikari et al, GMD 2015): */
5151  int index=reCast<int,IssmDouble>(alpha/PI*(M-1));
5152  U_elastic[i] += U_elastic_precomputed[index];
5153  Y_elastic[i] += H_elastic_precomputed[index]*Y_azim;
5154  X_elastic[i] += H_elastic_precomputed[index]*X_azim;
5155 
5156  /*Add all components to the pUp solution vectors:*/
5157  U_values[i]+=3*rho_ice/rho_earth*area/(4*PI*pow(earth_radius,2))*I*U_elastic[i];
5158  Y_values[i]+=3*rho_ice/rho_earth*area/(4*PI*pow(earth_radius,2))*I*Y_elastic[i];
5159  X_values[i]+=3*rho_ice/rho_earth*area/(4*PI*pow(earth_radius,2))*I*X_elastic[i];
5160 
5161  /*North-south, East-west components */
5162  if (hemi == -1) {
5163  ang2 = PI/2 - atan2(yy[i],xx[i]);
5164  }
5165  else if (hemi == 1) {
5166  ang2 = PI/2 - atan2(-yy[i],-xx[i]);
5167  }
5168  if (hemi != 0){
5169  N_azim = Y_azim*cos(ang2) + X_azim*sin(ang2);
5170  E_azim = X_azim*cos(ang2) - Y_azim*sin(ang2);
5171  N_elastic[i] += H_elastic_precomputed[index]*N_azim;
5172  E_elastic[i] += H_elastic_precomputed[index]*E_azim;
5173  N_values[i]+=3*rho_ice/rho_earth*area/(4*PI*pow(earth_radius,2))*I*N_elastic[i];
5174  E_values[i]+=3*rho_ice/rho_earth*area/(4*PI*pow(earth_radius,2))*I*E_elastic[i];
5175  }
5176  }
5177 
5178  pUp->SetValues(gsize,indices,U_values,ADD_VAL);
5179  pNorth->SetValues(gsize,indices,N_values,ADD_VAL);
5180  pEast->SetValues(gsize,indices,E_values,ADD_VAL);
5181  pX->SetValues(gsize,indices,X_values,ADD_VAL);
5182  pY->SetValues(gsize,indices,Y_values,ADD_VAL);
5183 
5184  /*free ressources:*/
5185  xDelete<int>(indices);
5186  xDelete<IssmDouble>(U_values); xDelete<IssmDouble>(N_values); xDelete<IssmDouble>(E_values);
5187  xDelete<IssmDouble>(U_elastic); xDelete<IssmDouble>(N_elastic); xDelete<IssmDouble>(E_elastic);
5188  xDelete<IssmDouble>(X_values); xDelete<IssmDouble>(Y_values);
5189  xDelete<IssmDouble>(X_elastic); xDelete<IssmDouble>(Y_elastic);
5190 
5191  return;
5192 }
5193 /*}}}*/
5194 void Tria::EsaGeodetic3D(Vector<IssmDouble>* pUp,Vector<IssmDouble>* pNorth,Vector<IssmDouble>* pEast,IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx,IssmDouble* yy,IssmDouble* zz){ /*{{{*/
5195 
5196  /*diverse:*/
5197  int gsize;
5198  bool spherical=true;
5199  IssmDouble llr_list[NUMVERTICES][3];
5200  IssmDouble xyz_list[NUMVERTICES][3];
5201  IssmDouble area,planetarea;
5202  IssmDouble I; //ice/water loading
5203  IssmDouble late,longe,re;
5204  IssmDouble lati,longi,ri;
5205  IssmDouble rho_ice,rho_earth;
5206  IssmDouble minlong=400;
5207  IssmDouble maxlong=-20;
5208 
5209  /*precomputed elastic green functions:*/
5210  IssmDouble* U_elastic_precomputed = NULL;
5211  IssmDouble* H_elastic_precomputed = NULL;
5212  int M;
5213 
5214  /*computation of Green functions:*/
5215  IssmDouble* U_elastic= NULL;
5216  IssmDouble* N_elastic= NULL;
5217  IssmDouble* E_elastic= NULL;
5218 
5219  /*optimization:*/
5220  bool store_green_functions=false;
5221 
5222  /*Compute ice thickness change: */
5223  Input2* deltathickness_input=this->GetInput2(EsaDeltathicknessEnum);
5224  if (!deltathickness_input)_error_("delta thickness input needed to compute elastic adjustment!");
5225  deltathickness_input->GetInputAverage(&I);
5226 
5227  /*early return if we are not on the (ice) loading point: */
5228  if(I==0) return;
5229 
5230  /*recover material parameters: */
5231  rho_ice=FindParam(MaterialsRhoIceEnum);
5232  rho_earth=FindParam(MaterialsEarthDensityEnum);
5233 
5234  /*recover earth area: */
5235  this->parameters->FindParam(&planetarea,SolidearthPlanetAreaEnum);
5236 
5237  /*how many dofs are we working with here? */
5238  this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
5239 
5240  /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
5241  area=GetAreaSpherical();
5242 
5243  /*element centroid (spherical): */
5244  /* Where is the centroid of this element?:{{{*/
5245  ::GetVerticesCoordinates(&llr_list[0][0],this->vertices,NUMVERTICES,spherical);
5246 
5247  minlong=400; maxlong=-20;
5248  for (int i=0;i<NUMVERTICES;i++){
5249  llr_list[i][0]=(90-llr_list[i][0]);
5250  if(llr_list[i][1]<0)llr_list[i][1]=180+(180+llr_list[i][1]);
5251  if(llr_list[i][1]>maxlong)maxlong=llr_list[i][1];
5252  if(llr_list[i][1]<minlong)minlong=llr_list[i][1];
5253  }
5254  if(minlong==0 && maxlong>180){
5255  if (llr_list[0][1]==0)llr_list[0][1]=360;
5256  if (llr_list[1][1]==0)llr_list[1][1]=360;
5257  if (llr_list[2][1]==0)llr_list[2][1]=360;
5258  }
5259 
5260  // correction at the north pole: given longitude of the North pole a definition
5261  // closer to the other two vertices.
5262  if(llr_list[0][0]==0)llr_list[0][1]=(llr_list[1][1]+llr_list[2][1])/2.0;
5263  if(llr_list[1][0]==0)llr_list[1][1]=(llr_list[0][1]+llr_list[2][1])/2.0;
5264  if(llr_list[2][0]==0)llr_list[2][1]=(llr_list[0][1]+llr_list[1][1])/2.0;
5265 
5266  // correction at the north pole: given longitude of the North pole a definition
5267  // closer to the other two vertices.
5268  if(llr_list[0][0]==180)llr_list[0][1]=(llr_list[1][1]+llr_list[2][1])/2.0;
5269  if(llr_list[1][0]==180)llr_list[1][1]=(llr_list[0][1]+llr_list[2][1])/2.0;
5270  if(llr_list[2][0]==180)llr_list[2][1]=(llr_list[0][1]+llr_list[1][1])/2.0;
5271 
5272  late=(llr_list[0][0]+llr_list[1][0]+llr_list[2][0])/3.0;
5273  longe=(llr_list[0][1]+llr_list[1][1]+llr_list[2][1])/3.0;
5274 
5275  late=90-late;
5276  if(longe>180)longe=longe-360;
5277 
5278  late=late/180*PI;
5279  longe=longe/180*PI;
5280  /*}}}*/
5281 
5282  /*figure out gravity center of our element (Cartesian): */
5283  IssmDouble x_element, y_element, z_element;
5284  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
5285  x_element=(xyz_list[0][0]+xyz_list[1][0]+xyz_list[2][0])/3.0;
5286  y_element=(xyz_list[0][1]+xyz_list[1][1]+xyz_list[2][1])/3.0;
5287  z_element=(xyz_list[0][2]+xyz_list[1][2]+xyz_list[2][2])/3.0;
5288 
5289  /*recover elastic Green's functions for displacement:*/
5290  DoubleVecParam* U_parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(EsaUElasticEnum)); _assert_(U_parameter);
5291  DoubleVecParam* H_parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(EsaHElasticEnum)); _assert_(H_parameter);
5292  U_parameter->GetParameterValueByPointer(&U_elastic_precomputed,&M);
5293  H_parameter->GetParameterValueByPointer(&H_elastic_precomputed,&M);
5294 
5295  /*initialize: */
5296  U_elastic=xNewZeroInit<IssmDouble>(gsize);
5297  N_elastic=xNewZeroInit<IssmDouble>(gsize);
5298  E_elastic=xNewZeroInit<IssmDouble>(gsize);
5299 
5300  int* indices=xNew<int>(gsize);
5301  IssmDouble* U_values=xNewZeroInit<IssmDouble>(gsize);
5302  IssmDouble* N_values=xNewZeroInit<IssmDouble>(gsize);
5303  IssmDouble* E_values=xNewZeroInit<IssmDouble>(gsize);
5304  IssmDouble alpha;
5305  IssmDouble delPhi,delLambda;
5306  IssmDouble dx, dy, dz, x, y, z;
5307  IssmDouble N_azim, E_azim;
5308 
5309  for(int i=0;i<gsize;i++){
5310 
5311  indices[i]=i;
5312 
5313  /*Compute alpha angle between centroid and current vertex: */
5314  lati=latitude[i]/180*PI; longi=longitude[i]/180*PI;
5315 
5316  delPhi=fabs(lati-late); delLambda=fabs(longi-longe);
5317  alpha=2.*asin(sqrt(pow(sin(delPhi/2),2.0)+cos(lati)*cos(late)*pow(sin(delLambda/2),2)));
5318 
5319  /*Compute azimuths, both north and east components: */
5320  x = xx[i]; y = yy[i]; z = zz[i];
5321  if(latitude[i]==90){
5322  x=1e-12; y=1e-12;
5323  }
5324  if(latitude[i]==-90){
5325  x=1e-12; y=1e-12;
5326  }
5327  dx = x_element-x; dy = y_element-y; dz = z_element-z;
5328  N_azim = (-z*x*dx-z*y*dy+(pow(x,2)+pow(y,2))*dz) /pow((pow(x,2)+pow(y,2))*(pow(x,2)+pow(y,2)+pow(z,2))*(pow(dx,2)+pow(dy,2)+pow(dz,2)),0.5);
5329  E_azim = (-y*dx+x*dy) /pow((pow(x,2)+pow(y,2))*(pow(dx,2)+pow(dy,2)+pow(dz,2)),0.5);
5330 
5331  /*Elastic component (from Eq 17 in Adhikari et al, GMD 2015): */
5332  int index=reCast<int,IssmDouble>(alpha/PI*(M-1));
5333  U_elastic[i] += U_elastic_precomputed[index];
5334  N_elastic[i] += H_elastic_precomputed[index]*N_azim;
5335  E_elastic[i] += H_elastic_precomputed[index]*E_azim;
5336 
5337  /*Add all components to the pUp solution vectors:*/
5338  U_values[i]+=3*rho_ice/rho_earth*area/planetarea*I*U_elastic[i];
5339  N_values[i]+=3*rho_ice/rho_earth*area/planetarea*I*N_elastic[i];
5340  E_values[i]+=3*rho_ice/rho_earth*area/planetarea*I*E_elastic[i];
5341  }
5342  pUp->SetValues(gsize,indices,U_values,ADD_VAL);
5343  pNorth->SetValues(gsize,indices,N_values,ADD_VAL);
5344  pEast->SetValues(gsize,indices,E_values,ADD_VAL);
5345 
5346  /*free ressources:*/
5347  xDelete<int>(indices);
5348  xDelete<IssmDouble>(U_values); xDelete<IssmDouble>(N_values); xDelete<IssmDouble>(E_values);
5349  xDelete<IssmDouble>(U_elastic); xDelete<IssmDouble>(N_elastic); xDelete<IssmDouble>(E_elastic);
5350 
5351  return;
5352 }
5353 /*}}}*/
5354 #endif
5355 #ifdef _HAVE_SEALEVELRISE_
5356 IssmDouble Tria::OceanAverage(IssmDouble* Sg, SealevelMasks* masks){ /*{{{*/
5357 
5358  if(masks->isoceanin[this->lid]){
5359 
5360  IssmDouble area;
5361 
5362  /*Get area of element:*/
5363  this->GetInput2Value(&area,AreaEnum);
5364 
5365  /*Average Sg over vertices:*/
5366  IssmDouble Sg_avg=0; for(int i=0;i<NUMVERTICES;i++) Sg_avg+=Sg[this->vertices[i]->Sid()]/NUMVERTICES;
5367 
5368  /*return: */
5369  return area*Sg_avg;
5370  }
5371  else return 0;
5372 
5373 }
5374 /*}}}*/
5375 void Tria::SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){/*{{{*/
5376  /*early return if we are not on an ice cap OR ocean:*/
5377  if(!masks->isiceonly[this->lid] && !masks->isoceanin[this->lid]){
5378  dI_list[0] = 0.0; // this is important!!!
5379  dI_list[1] = 0.0; // this is important!!!
5380  dI_list[2] = 0.0; // this is important!!!
5381  return;
5382  }
5383 
5384  /*Compute area of element:*/
5385  IssmDouble area,planetarea;
5386  this->GetInput2Value(&area,AreaEnum);
5387 
5388  /*recover earth area: */
5389  this->parameters->FindParam(&planetarea,SolidearthPlanetAreaEnum);
5390 
5391  /*Compute lat,long,radius of elemental centroid: */
5392  bool spherical=true;
5393  IssmDouble llr_list[NUMVERTICES][3];
5394  IssmDouble late,longe,re;
5395  /* Where is the centroid of this element?:{{{*/
5396  ::GetVerticesCoordinates(&llr_list[0][0],this->vertices,NUMVERTICES,spherical);
5397 
5398  IssmDouble minlong=400;
5399  IssmDouble maxlong=-20;
5400  for (int i=0;i<NUMVERTICES;i++){
5401  llr_list[i][0]=(90-llr_list[i][0]);
5402  if(llr_list[i][1]<0)llr_list[i][1]=180+(180+llr_list[i][1]);
5403  if(llr_list[i][1]>maxlong)maxlong=llr_list[i][1];
5404  if(llr_list[i][1]<minlong)minlong=llr_list[i][1];
5405  }
5406  if(minlong==0 && maxlong>180){
5407  if (llr_list[0][1]==0)llr_list[0][1]=360;
5408  if (llr_list[1][1]==0)llr_list[1][1]=360;
5409  if (llr_list[2][1]==0)llr_list[2][1]=360;
5410  }
5411 
5412  // correction at the north pole
5413  if(llr_list[0][0]==0)llr_list[0][1]=(llr_list[1][1]+llr_list[2][1])/2.0;
5414  if(llr_list[1][0]==0)llr_list[1][1]=(llr_list[0][1]+llr_list[2][1])/2.0;
5415  if(llr_list[2][0]==0)llr_list[2][1]=(llr_list[0][1]+llr_list[1][1])/2.0;
5416 
5417  //correction at the south pole
5418  if(llr_list[0][0]==180)llr_list[0][1]=(llr_list[1][1]+llr_list[2][1])/2.0;
5419  if(llr_list[1][0]==180)llr_list[1][1]=(llr_list[0][1]+llr_list[2][1])/2.0;
5420  if(llr_list[2][0]==180)llr_list[2][1]=(llr_list[0][1]+llr_list[1][1])/2.0;
5421 
5422  late=(llr_list[0][0]+llr_list[1][0]+llr_list[2][0])/3.0;
5423  longe=(llr_list[0][1]+llr_list[1][1]+llr_list[2][1])/3.0;
5424 
5425  late=90-late;
5426  if(longe>180)longe=(longe-180)-180;
5427 
5428  late=late/180*PI;
5429  longe=longe/180*PI;
5430  /*}}}*/
5431  re=(llr_list[0][2]+llr_list[1][2]+llr_list[2][2])/3.0;
5432 
5433  if(masks->isoceanin[this->lid]){
5434  IssmDouble rho_water, S;
5435 
5436  /*recover material parameters: */
5437  rho_water=FindParam(MaterialsRhoSeawaterEnum);
5438 
5439  /*From Sg_old, recover water sea level rise:*/
5440  S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg_old[this->vertices[i]->Sid()]/NUMVERTICES;
5441 
5442  /* Perturbation terms for moment of inertia (moi_list):
5443  * computed analytically (see Wu & Peltier, eqs 10 & 32)
5444  * also consistent with my GMD formulation!
5445  * ALL in geographic coordinates
5446  * */
5447  dI_list[0] = -4*PI*(rho_water*S*area)*pow(re,4)*(sin(late)*cos(late)*cos(longe))/planetarea;
5448  dI_list[1] = -4*PI*(rho_water*S*area)*pow(re,4)*(sin(late)*cos(late)*sin(longe))/planetarea;
5449  dI_list[2] = +4*PI*(rho_water*S*area)*pow(re,4)*(1-pow(sin(late),2))/planetarea;
5450  }
5451  else if(masks->isiceonly[this->lid]){
5452  IssmDouble rho_ice, I;
5453 
5454  /*recover material parameters: */
5455  rho_ice=FindParam(MaterialsRhoIceEnum);
5456 
5457  /*Compute ice thickness change: */
5458  Input2* deltathickness_input=this->GetInput2(SurfaceloadIceThicknessChangeEnum);
5459  if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
5460  deltathickness_input->GetInputAverage(&I);
5461 
5462  dI_list[0] = -4*PI*(rho_ice*I*area)*pow(re,4)*(sin(late)*cos(late)*cos(longe))/planetarea;
5463  dI_list[1] = -4*PI*(rho_ice*I*area)*pow(re,4)*(sin(late)*cos(late)*sin(longe))/planetarea;
5464  dI_list[2] = +4*PI*(rho_ice*I*area)*pow(re,4)*(1-pow(sin(late),2))/planetarea;
5465  }
5466 
5467  return;
5468 }/*}}}*/
5469 void Tria::SetSealevelMasks(SealevelMasks* masks){ /*{{{*/
5470 
5471  masks->isiceonly[this->lid]=this->IsIceOnlyInElement();
5472  masks->isoceanin[this->lid]=this->IsOceanInElement();
5473 
5474  /*are we fully floating:*/
5475  Input2* gr_input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(gr_input);
5476  if (gr_input->GetInputMax()<=0)masks->isfullyfloating[this->lid]=true;
5477  else masks->isfullyfloating[this->lid]=false;
5478 
5479  /*are we not fully grounded: */
5480  if ((gr_input->GetInputMin())<0) masks->notfullygrounded[this->lid]=true;
5481  else masks->notfullygrounded[this->lid]=false;
5482 
5483 }
5484 /*}}}*/
5485 void Tria::SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){ /*{{{*/
5486  /*diverse:*/
5487  int gsize;
5488  bool spherical=true;
5489  IssmDouble llr_list[NUMVERTICES][3];
5490  IssmDouble xyz_list[NUMVERTICES][3];
5491  IssmDouble area,planetarea,planetradius;
5492  IssmDouble I; //change in ice thickness or water level(Farrel and Clarke, Equ. 4)
5493  IssmDouble rho_earth;
5494  IssmDouble late,longe,re;
5495  IssmDouble lati,longi,ri;
5496  IssmDouble constant;
5497  IssmDouble x_element,y_element,z_element,x,y,z,dx,dy,dz,N_azim,E_azim;
5498 
5499  #ifdef _HAVE_RESTRICT_
5500  IssmDouble* __restrict__ G=NULL;
5501  IssmDouble* __restrict__ GU=NULL;
5502  IssmDouble* __restrict__ GN=NULL;
5503  IssmDouble* __restrict__ GE=NULL;
5504  IssmDouble* __restrict__ G_elastic_precomputed=NULL;
5505  IssmDouble* __restrict__ G_rigid_precomputed=NULL;
5506  IssmDouble* __restrict__ U_elastic_precomputed=NULL;
5507  IssmDouble* __restrict__ H_elastic_precomputed=NULL;
5508  IssmDouble* __restrict__ indices=NULL;
5509  #else
5510  IssmDouble* G=NULL;
5511  IssmDouble* GU=NULL;
5512  IssmDouble* GN=NULL;
5513  IssmDouble* GE=NULL;
5514  IssmDouble* G_elastic_precomputed=NULL;
5515  IssmDouble* G_rigid_precomputed=NULL;
5516  IssmDouble* U_elastic_precomputed=NULL;
5517  IssmDouble* H_elastic_precomputed=NULL;
5518  IssmDouble* indices=NULL;
5519  #endif
5520 
5521  /*elastic green function:*/
5522  int index;
5523  int M;
5524 
5525  /*Computational flags:*/
5526  bool computerigid = true;
5527  bool computeelastic = true;
5528  int horiz;
5529 
5530  /*recover parameters: */
5531  rho_earth=FindParam(MaterialsEarthDensityEnum);
5532  this->parameters->FindParam(&computerigid,SolidearthSettingsRigidEnum);
5533  this->parameters->FindParam(&computeelastic,SolidearthSettingsElasticEnum);
5534  this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
5535  this->parameters->FindParam(&planetarea,SolidearthPlanetAreaEnum);
5536  this->parameters->FindParam(&planetradius,SolidearthPlanetRadiusEnum);
5537  this->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
5538 
5539  /*recover precomputed green function kernels:*/
5540  DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGRigidEnum)); _assert_(parameter);
5541  parameter->GetParameterValueByPointer((IssmDouble**)&G_rigid_precomputed,&M);
5542 
5543  parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGElasticEnum)); _assert_(parameter);
5544  parameter->GetParameterValueByPointer((IssmDouble**)&G_elastic_precomputed,&M);
5545 
5546  parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseHElasticEnum)); _assert_(parameter);
5547  parameter->GetParameterValueByPointer((IssmDouble**)&H_elastic_precomputed,&M);
5548 
5549  parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseUElasticEnum)); _assert_(parameter);
5550  parameter->GetParameterValueByPointer((IssmDouble**)&U_elastic_precomputed,&M);
5551 
5552  /*allocate indices:*/
5553  indices=xNew<IssmDouble>(gsize);
5554  G=xNewZeroInit<IssmDouble>(gsize);
5555  GU=xNewZeroInit<IssmDouble>(gsize);
5556  if(horiz){
5557  GN=xNewZeroInit<IssmDouble>(gsize);
5558  GE=xNewZeroInit<IssmDouble>(gsize);
5559  }
5560 
5561  /*compute area:*/
5562  area=GetAreaSpherical();
5563 
5564 
5565  /* Where is the centroid of this element:*/
5566 
5567  /*retrieve coordinates: */
5568  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
5569 
5570  /*figure out gravity center of our element (Cartesian): */
5571  x_element=(xyz_list[0][0]+xyz_list[1][0]+xyz_list[2][0])/3.0;
5572  y_element=(xyz_list[0][1]+xyz_list[1][1]+xyz_list[2][1])/3.0;
5573  z_element=(xyz_list[0][2]+xyz_list[1][2]+xyz_list[2][2])/3.0;
5574 
5575  /*compute gravity center in lat,long: */
5576  late= asin(z_element/planetradius);
5577  longe = atan2(y_element,x_element);
5578 
5579  constant=3/rho_earth*area/planetarea;
5580 
5581  for(int i=0;i<gsize;i++){
5582  IssmDouble alpha;
5583  IssmDouble delPhi,delLambda;
5584 
5585  /*Compute alpha angle between centroid and current vertex and index into precomputed tables: */
5586  lati=latitude[i]/180*PI; longi=longitude[i]/180*PI;
5587  delPhi=fabs(lati-late); delLambda=fabs(longi-longe); if (delLambda>PI)delLambda=2*PI-delLambda;
5588  alpha=2.*asin(sqrt(pow(sin(delPhi/2),2)+cos(lati)*cos(late)*pow(sin(delLambda/2),2)));
5589  indices[i]=alpha/PI*reCast<IssmDouble,int>(M-1);
5590  index=reCast<int,IssmDouble>(indices[i]);
5591 
5592  /*Rigid earth gravitational perturbation: */
5593  if(computerigid){
5594  G[i]+=G_rigid_precomputed[index];
5595  }
5596  if(computeelastic){
5597  G[i]+=G_elastic_precomputed[index];
5598  }
5599  G[i]=G[i]*constant;
5600 
5601  /*Elastic components:*/
5602  GU[i] = constant * U_elastic_precomputed[index];
5603  if(horiz){
5604  /*Compute azimuths, both north and east components: */
5605  x = xx[i]; y = yy[i]; z = zz[i];
5606  if(latitude[i]==90){
5607  x=1e-12; y=1e-12;
5608  }
5609  if(latitude[i]==-90){
5610  x=1e-12; y=1e-12;
5611  }
5612  dx = x_element-x; dy = y_element-y; dz = z_element-z;
5613  N_azim = (-z*x*dx-z*y*dy+(pow(x,2)+pow(y,2))*dz) /pow((pow(x,2)+pow(y,2))*(pow(x,2)+pow(y,2)+pow(z,2))*(pow(dx,2)+pow(dy,2)+pow(dz,2)),0.5);
5614  E_azim = (-y*dx+x*dy) /pow((pow(x,2)+pow(y,2))*(pow(dx,2)+pow(dy,2)+pow(dz,2)),0.5);
5615 
5616  GN[i] = constant*H_elastic_precomputed[index]*N_azim;
5617  GE[i] = constant*H_elastic_precomputed[index]*E_azim;
5618  }
5619  }
5620 
5621  /*Add in inputs:*/
5622  this->inputs2->SetArrayInput(SealevelriseIndicesEnum,this->lid,indices,gsize);
5623  this->inputs2->SetArrayInput(SealevelriseGEnum,this->lid,G,gsize);
5624  this->inputs2->SetArrayInput(SealevelriseGUEnum,this->lid,GU,gsize);
5625  if(horiz){
5626  this->inputs2->SetArrayInput(SealevelriseGNEnum,this->lid,GN,gsize);
5627  this->inputs2->SetArrayInput(SealevelriseGEEnum,this->lid,GE,gsize);
5628  }
5629  this->inputs2->SetDoubleInput(AreaEnum,this->lid,area);
5630 
5631  /*Free allocations:*/
5632  #ifdef _HAVE_RESTRICT_
5633  delete indices;
5634  delete G;
5635  delete GU;
5636  if(horiz){
5637  delete GN;
5638  delete GE;
5639  }
5640  #else
5641  xDelete(indices);
5642  xDelete(G);
5643  xDelete(GU);
5644  if(horiz){
5645  xDelete(GN);
5646  xDelete(GE);
5647  }
5648  #endif
5649 
5650  return;
5651 }
5652 /*}}}*/
5653 void Tria::SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
5654 
5655  int bp_compute_fingerprints= 0;
5656 
5657  /*Compute bottom pressure contribution from ocean if requested:*/
5658  this->parameters->FindParam(&bp_compute_fingerprints,DslComputeFingerprintsEnum);
5659  if(bp_compute_fingerprints)this->SealevelriseBottomPressure(Sgi,masks);
5660 
5661  /*Compute eustatic ice contribution to sea level rise: */
5662  this->SealevelriseEustaticIce(Sgi,peustatic,masks, oceanarea);
5663 
5664  /*Compute hydrological contribution to sea level rise: */
5665  this->SealevelriseEustaticHydro(Sgi,peustatic,masks, oceanarea);
5666 
5667 
5668 }
5669 /*}}}*/
5670 void Tria::SealevelriseEustaticIce(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
5671 
5672  /*diverse:*/
5673  int gsize;
5674  IssmDouble area;
5675  IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes eustatic
5676  IssmDouble I; //change in ice thickness or water level(Farrel and Clarke, Equ. 4)
5677  bool notfullygrounded=false;
5678  bool scaleoceanarea= false;
5679 
5680  /*elastic green function:*/
5681  IssmDouble* G=NULL;
5682 
5683  /*ice properties: */
5684  IssmDouble rho_ice,rho_water;
5685 
5686  /*constants:*/
5687  IssmDouble constant=0;
5688 
5689  /*Initialize eustatic component: do not skip this step :):*/
5690  IssmDouble eustatic = 0.;
5691 
5692  /*early return if we are not on an ice cap:*/
5693  if(!masks->isiceonly[this->lid]){
5694  #ifdef _ISSM_DEBUG_
5695  constant=0; this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
5696  #endif
5697  *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
5698  return;
5699  }
5700 
5701  /*early return if we are fully floating:*/
5702  if (masks->isfullyfloating[this->lid]){
5703  constant=0;
5704  #ifdef _ISSM_DEBUG_
5705  this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
5706  #endif
5707  *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
5708  return;
5709  }
5710 
5711  /*If we are here, we are on ice that is fully grounded or half-way to floating:*/
5712  if (masks->notfullygrounded[this->lid]) notfullygrounded=true; //used later on.
5713 
5714  /*Inform mask: */
5715  constant=1;
5716  #ifdef _ISSM_DEBUG_
5717  this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
5718  #endif
5719 
5720  /*recover material parameters: */
5721  rho_ice=FindParam(MaterialsRhoIceEnum);
5722  rho_water=FindParam(MaterialsRhoSeawaterEnum);
5723 
5724  /*recover ocean area scaling: */
5725  this->parameters->FindParam(&scaleoceanarea,SolidearthSettingsOceanAreaScalingEnum);
5726 
5727  /*retrieve precomputed G:*/
5728  this->inputs2->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
5729 
5730  /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
5731  this->GetInput2Value(&area,AreaEnum);
5732 
5733  /*Compute fraction of the element that is grounded: */
5734  if(notfullygrounded){
5735  IssmDouble xyz_list[NUMVERTICES][3];
5736  ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
5737 
5738  phi=this->GetGroundedPortion(&xyz_list[0][0]); //watch out, this only works because of the Thales theorem! We are in 3D, but this routine is inherently for 2D trias
5739  }
5740  else phi=1.0;
5741 
5742  /*Retrieve ice thickness at vertices: */
5743  Input2* deltathickness_input=this->GetInput2(SurfaceloadIceThicknessChangeEnum);
5744  if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
5745 
5746  /*/Average ice thickness over grounded area of the element only: {{{*/
5747  if(!notfullygrounded)deltathickness_input->GetInputAverage(&I);
5748  else{
5749  IssmDouble total_weight=0;
5750  bool mainlyfloating = true;
5751  int point1;
5752  IssmDouble fraction1,fraction2;
5753 
5754  /*Recover portion of element that is grounded*/
5755  this->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
5756  Gauss* gauss = this->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
5757 
5758  /* Start looping on the number of gaussian points and average over these gaussian points: */
5759  total_weight=0;
5760  I=0;
5761  for(int ig=gauss->begin();ig<gauss->end();ig++){
5762  IssmDouble Ig=0;
5763  gauss->GaussPoint(ig);
5764  deltathickness_input->GetInputValue(&Ig,gauss);
5765  I+=Ig*gauss->weight;
5766  total_weight+=gauss->weight;
5767  }
5768  I=I/total_weight;
5769  delete gauss;
5770  }
5771  /*}}}*/
5772 
5773  /*Compute eustatic component:*/
5774  _assert_(oceanarea>0.);
5775  if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
5776  eustatic += rho_ice*area*phi*I/(oceanarea*rho_water);
5777 
5778  /*convert from m to kg/m^2:*/
5779  I=I*rho_ice*phi;
5780 
5781  /*convolve:*/
5782  for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*I;
5783 
5784  /*Assign output pointer:*/
5785  _assert_(!xIsNan<IssmDouble>(eustatic));
5786  *peustatic=eustatic;
5787  return;
5788 }
5789 /*}}}*/
5790 void Tria::SealevelriseEustaticHydro(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble oceanarea){ /*{{{*/
5791 
5792  /*diverse:*/
5793  int gsize;
5794  IssmDouble area;
5795  IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes eustatic
5796  IssmDouble W; //change in water height thickness (Farrel and Clarke, Equ. 4)
5797  bool notfullygrounded=false;
5798  bool scaleoceanarea= false;
5799 
5800  /*elastic green function:*/
5801  IssmDouble* G=NULL;
5802 
5803  /*ice properties: */
5804  IssmDouble rho_water;
5805  IssmDouble rho_freshwater;
5806 
5807  /*constants:*/
5808  IssmDouble constant=0;
5809 
5810  /*Initialize eustatic component: do not skip this step :):*/
5811  IssmDouble eustatic = 0.;
5812 
5813  /*early return if we are on an ice cap:*/
5814  if(masks->isiceonly[this->lid]){ *peustatic=0; return; }
5815 
5816  /*early return if we are fully floating:*/
5817  if (masks->isfullyfloating[this->lid]){ constant=0; *peustatic=0; return; }
5818 
5819  /*If we are here, we are on earth, not on ice: */
5820 
5821  /*recover material parameters: */
5822  rho_water=FindParam(MaterialsRhoSeawaterEnum);
5823  rho_freshwater=FindParam(MaterialsRhoFreshwaterEnum);
5824 
5825  /*recover ocean area scaling: */
5826  this->parameters->FindParam(&scaleoceanarea,SolidearthSettingsOceanAreaScalingEnum);
5827 
5828  /*retrieve precomputed G:*/
5829  this->inputs2->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
5830 
5831  /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
5832  this->GetInput2Value(&area,AreaEnum);
5833 
5834  /*Retrieve water height at vertices: */
5835  Input2* deltathickness_input=this->GetInput2(SurfaceloadWaterHeightChangeEnum);
5836  if (!deltathickness_input)_error_("SurfaceloadWaterHeightChangeEnum input needed to compute sea level rise!");
5837  deltathickness_input->GetInputAverage(&W);
5838 
5839  /*Compute eustatic component:*/
5840  _assert_(oceanarea>0.);
5841  if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
5842  eustatic += rho_freshwater*area*phi*W/(oceanarea*rho_water);
5843 
5844  /*convert from m to kg/m^2:*/
5845  W=W*rho_freshwater*phi;
5846 
5847  /*convolve:*/
5848  for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*W;
5849 
5850  /*Assign output pointer:*/
5851  _assert_(!xIsNan<IssmDouble>(eustatic));
5852  *peustatic=eustatic;
5853  return;
5854 }
5855 /*}}}*/
5856 void Tria::SealevelriseBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){ /*{{{*/
5857 
5858  /*diverse:*/
5859  int gsize;
5860  IssmDouble area;
5861  IssmDouble BP; //change in bottom pressure (Farrel and Clarke, Equ. 4)
5862  IssmDouble constant;
5863 
5864  /*elastic green function:*/
5865  IssmDouble* G=NULL;
5866 
5867  /*water properties: */
5868  IssmDouble rho_water;
5869 
5870  /*we are here to compute fingerprints originating fromn bottom pressure changes:*/
5871  if(!masks->isoceanin[this->lid])return;
5872 
5873  /*Inform mask: */
5874  #ifdef _ISSM_DEBUG_
5875  constant=1; this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
5876  #endif
5877 
5878  /*recover material parameters: */
5879  rho_water=FindParam(MaterialsRhoSeawaterEnum);
5880 
5881  /*retrieve precomputed G:*/
5882  this->inputs2->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
5883 
5884  /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
5885  this->GetInput2Value(&area,AreaEnum);
5886 
5887  /*Retrieve bottom pressure change and average over the element: */
5888  Input2* bottompressure_change_input=this->GetInput2(DslSeaWaterPressureChangeAtSeaFloor);
5889  if (!bottompressure_change_input)_error_("bottom pressure input needed to compute sea level rise fingerprint!");
5890  bottompressure_change_input->GetInputAverage(&BP);
5891 
5892  /*convert from m to kg/m^2:*/
5893  BP=BP*rho_water;
5894 
5895  /*convolve:*/
5896  for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*BP;
5897 
5898  return;
5899 }
5900 /*}}}*/
5901 void Tria::SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old, SealevelMasks* masks){ /*{{{*/
5902 
5903  /*diverse:*/
5904  int gsize,dummy;
5905  IssmDouble S; //change in water water level(Farrel and Clarke, Equ. 4)
5906  IssmDouble constant=0;
5907  IssmDouble rho_water;
5908  IssmDouble* G=NULL;
5909  int bp_compute_fingerprints= 0;
5910 
5911  /*retrieve parameters:*/
5912  this->parameters->FindParam(&bp_compute_fingerprints,DslComputeFingerprintsEnum);
5913  rho_water=FindParam(MaterialsRhoSeawaterEnum);
5914 
5915  /*early return if we are not on the ocean:*/
5916  if (!masks->isoceanin[this->lid]){
5917  constant=0;
5918  #ifdef _ISSM_DEBUG_
5919  this->AddInput2(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
5920  #endif
5921  return;
5922  }
5923  constant=1;
5924  #ifdef _ISSM_DEBUG_
5925  this->AddInput2(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
5926  #endif
5927 
5928  /*how many dofs are we working with here? */
5929  this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
5930 
5931  /*retrieve precomputed G:*/
5932  this->inputs2->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&dummy); _assert_(dummy==gsize);
5933 
5934  /*From Sg_old, recover water sea level rise:*/
5935  S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg_old[this->vertices[i]->Sid()]/NUMVERTICES;
5936 
5937  /*convert to kg/m^2: */
5938  S=S*rho_water;
5939 
5940  for(int i=0;i<gsize;i++) Sgo[i]+=G[i]*S;
5941 
5942  return;
5943 }
5944 /*}}}*/
5945 void Tria::SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North ,IssmDouble* East,IssmDouble* Sg, SealevelMasks* masks){ /*{{{*/
5946 
5947  /*diverse:*/
5948  int gsize;
5949  IssmDouble I, S; //change in relative ice thickness and sea level
5950  IssmDouble rho_ice,rho_water;
5951  int horiz;
5952  int bp_compute_fingerprints= 0;
5953 
5954  /*precomputed elastic green functions:*/
5955  IssmDouble* GU=NULL;
5956  IssmDouble* GN=NULL;
5957  IssmDouble* GE=NULL;
5958 
5959  /*computational flags:*/
5960  bool computeelastic= true;
5961 
5962  /*early return if we are not on the ocean or on an ice cap:*/
5963  if(!masks->isiceonly[this->lid] && !masks->isoceanin[this->lid]) return;
5964 
5965  /*recover parameters:*/
5966  this->parameters->FindParam(&computeelastic,SolidearthSettingsElasticEnum);
5967  this->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
5968  this->parameters->FindParam(&bp_compute_fingerprints,DslComputeFingerprintsEnum);
5969 
5970  /*early return if elastic not requested:*/
5971  if(!computeelastic) return;
5972 
5973  /*recover material parameters: */
5974  rho_ice=FindParam(MaterialsRhoIceEnum);
5975  rho_water=FindParam(MaterialsRhoSeawaterEnum);
5976 
5977  /*recover elastic Green's functions for displacement:*/
5978  this->inputs2->GetArrayPtr(SealevelriseGUEnum,this->lid,&GU,&gsize);
5979  if(horiz){
5980  this->inputs2->GetArrayPtr(SealevelriseGEEnum,this->lid,&GE,&gsize);
5981  this->inputs2->GetArrayPtr(SealevelriseGNEnum,this->lid,&GN,&gsize);
5982  }
5983 
5984 
5985  if(masks->isoceanin[this->lid]){
5986  /*From Sg, recover water sea level rise:*/
5987  S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg[this->vertices[i]->Sid()]/NUMVERTICES;
5988 
5989  /*convert to kg/m^2:*/
5990  S=rho_water*S;
5991 
5992  for(int i=0;i<gsize;i++){
5993  Up[i]+=S*GU[i];
5994  if(horiz){
5995  North[i]+=S*GN[i];
5996  East[i]+=S*GE[i];
5997  }
5998  }
5999  }
6000  else if (masks->isiceonly[this->lid]){
6001 
6002  /*Compute ice thickness change: */
6003  Input2* deltathickness_input=this->GetInput2(SurfaceloadIceThicknessChangeEnum);
6004  if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
6005  deltathickness_input->GetInputAverage(&I);
6006 
6007  /*convert to kg/m^2*/
6008  I=I*rho_ice;
6009 
6010  for(int i=0;i<gsize;i++){
6011  Up[i]+=I*GU[i];
6012  if(horiz){
6013  North[i]+=I*GN[i];
6014  East[i]+=I*GE[i];
6015  }
6016  }
6017  }
6018 
6019  return;
6020 }
6021 /*}}}*/
6022 #endif
6023 
6024 #ifdef _HAVE_DAKOTA_
6025 void Tria::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
6026 
6027  /*Check that name is an element input*/
6028  if(!IsInputEnum(name)) _error_("Enum "<<EnumToStringx(name)<<" is not in IsInput");
6029  TransientInput2* transientinput = inputs2->GetTransientInput(name);
6030 
6031  switch(type){
6032 
6033  case VertexEnum:
6034 
6035  /*Get LID lists once for all*/
6036  IssmDouble values[NUMVERTICES];
6037  int lidlist[NUMVERTICES];
6038  this->GetVerticesLidList(&lidlist[0]);
6039 
6040  /*Create transient input: */
6041  for(int t=0;t<ncols;t++){ //ncols is the number of times
6042  for(int i=0;i<3;i++){
6043  int row=this->vertices[i]->Sid();
6044  values[i]=matrix[ncols*row+t];
6045  }
6046 
6047  /*time:*/
6048  IssmDouble time=matrix[(nrows-1)*ncols+t];
6049 
6050  transientinput->AddTriaTimeInput(t,NUMVERTICES,&lidlist[0],&values[0],P1Enum);
6051  }
6052  break;
6053 
6054  case ElementEnum:
6055  /*Get value for the element: */
6056  for(int t=0;t<ncols;t++){ //ncols is the number of times
6057  IssmDouble value=matrix[ncols*(this->Sid())+t];
6058  IssmDouble time=matrix[(nrows-1)*ncols+t];
6059  transientinput->AddTriaTimeInput(t,1,&(this->lid),&value,P0Enum);
6060  }
6061  break;
6062 
6063  default:
6064  _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
6065  }
6066 }
6067 /*}}}*/
6068 void Tria::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
6069 
6070  int i,j;
6071 
6072  /*Check that name is an element input*/
6073  if(!IsInputEnum(name)) _error_("Enum "<<EnumToStringx(name)<<" is not in IsInput");
6074 
6075  switch(type){
6076 
6077  case VertexEnum:
6078 
6079  /*New TriaInput*/
6080  IssmDouble values[3];
6081 
6082  /*Get values on the 3 vertices*/
6083  for (i=0;i<3;i++){
6084  values[i]=vector[this->vertices[i]->Sid()]; //careful, vector of values here is not parallel distributed, but serial distributed (from a serial Dakota core!)
6085  }
6086 
6087  /*Branch on the specified type of update: */
6088  switch(name){
6089  case ThicknessEnum:
6090  IssmDouble thickness[3];
6091  IssmDouble thickness_init[3];
6092  IssmDouble hydrostatic_ratio[3];
6093  IssmDouble surface[3];
6094  IssmDouble bed[3];
6095 
6096  /*retrieve inputs: */
6097  Element::GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
6098  Element::GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
6099  Element::GetInputListOnVertices(&bed[0],BaseEnum);
6100  Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
6101 
6102  /*build new bed and surface: */
6103  if (this->IsFloating()){
6104  /*hydrostatic equilibrium: */
6105  IssmDouble rho_ice,rho_water,di;
6106  rho_ice = this->FindParam(MaterialsRhoIceEnum);
6107  rho_water = this->FindParam(MaterialsRhoSeawaterEnum);
6108  di = rho_ice/rho_water;
6109 
6110  /*build new thickness: */
6111  for (j=0; j<3; j++) {
6112  /* for observed/interpolated/hydrostatic thickness, remove scaling from any hydrostatic thickness */
6113  if (hydrostatic_ratio[j] >= 0.)
6114  thickness[j]=values[j]-(values[j]/thickness_init[j]-1.)*hydrostatic_ratio[j]*surface[j]/(1.-di);
6115  /* for minimum thickness, don't scale */
6116  else
6117  thickness[j]=thickness_init[j];
6118 
6119  /* check the computed thickness and update bed*/
6120  if (thickness[j] < 0.) thickness[j]=1./(1.-di);
6121  bed[j]=surface[j]-thickness[j];
6122  }
6123  }
6124  else{
6125  /*build new thickness: */
6126  for (j=0; j<3; j++) {
6127  /* for observed thickness, use scaled value */
6128  if (hydrostatic_ratio[j] >= 0.)
6129  thickness[j]=values[j];
6130  /* for minimum thickness, don't scale */
6131  else
6132  thickness[j]=thickness_init[j];
6133  }
6134 
6135  /*update bed on grounded ice: */
6136  for(j=0;j<3;j++)bed[j]=surface[j]-thickness[j];
6137  }
6138 
6139  /*Add new inputs: */
6140  this->AddInput2(ThicknessEnum,thickness,P1Enum);
6141  this->AddInput2(BaseEnum,bed,P1Enum);
6142  this->AddInput2(SurfaceEnum,surface,P1Enum);
6143 
6144  break;
6145  case MaterialsRheologyBEnum:
6146  this->AddInput2(MaterialsRheologyBbarEnum,values,P1Enum);
6147  break;
6148  default:
6149  this->AddInput2(name,values,P1Enum);
6150  }
6151  break;
6152 
6153  case ElementEnum:
6154  IssmDouble value;
6155  /*Get value for the element: */
6156  value=vector[this->Sid()]; //careful, vector of values here is not parallel distributed, but serial distributed (from a serial Dakota core!)
6157  this->AddInput2(name,&value,P0Enum);
6158  break;
6159  default:
6160  _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
6161  }
6162 
6163 }
6164 /*}}}*/
6165 #endif
DataSet::Size
int Size()
Definition: DataSet.cpp:399
Tria::iscollapsed
int iscollapsed
Definition: Tria.h:32
Tria::GetInputListOnNodes
void GetInputListOnNodes(IssmDouble *pvalue, Input2 *input, IssmDouble default_value)
Definition: Tria.cpp:1952
Element::StrainRateESA
void StrainRateESA(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4035
DslSeaWaterPressureChangeAtSeaFloor
@ DslSeaWaterPressureChangeAtSeaFloor
Definition: EnumDefinitions.h:542
ElementInput2::SetInput
virtual void SetInput(int interp_in, int row, IssmDouble value_in)=0
Element::GetVerticesConnectivityList
void GetVerticesConnectivityList(int *connectivitylist)
Definition: Element.cpp:1440
Element::lid
int lid
Definition: Element.h:46
TransientInput2::GetAllTimes
void GetAllTimes(IssmDouble **ptimesteps, int *pnumtimesteps)
Definition: TransientInput2.cpp:258
CrouzeixRaviartEnum
@ CrouzeixRaviartEnum
Definition: EnumDefinitions.h:1023
BaseEnum
@ BaseEnum
Definition: EnumDefinitions.h:495
Vertices
Declaration of Vertices class.
Definition: Vertices.h:15
StressTensorxxEnum
@ StressTensorxxEnum
Definition: EnumDefinitions.h:811
GiaDeflectionCoreArgs::idisk
int idisk
Definition: GiaDeflectionCoreArgs.h:36
TriaRef::GetJacobianDeterminant
void GetJacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:107
ElementVector::StaticCondensation
void StaticCondensation(ElementMatrix *Ke, int numindices, int *indices)
Definition: ElementVector.cpp:266
CalvingStressThresholdGroundediceEnum
@ CalvingStressThresholdGroundediceEnum
Definition: EnumDefinitions.h:506
SmbMassBalanceEnum
@ SmbMassBalanceEnum
Definition: EnumDefinitions.h:748
SealevelEustaticOceanMaskEnum
@ SealevelEustaticOceanMaskEnum
Definition: EnumDefinitions.h:677
TransientInput2Enum
@ TransientInput2Enum
Definition: EnumDefinitions.h:1315
ElementInput2::Serve
virtual void Serve(int numindices, int *indices)=0
DeviatoricStressxzEnum
@ DeviatoricStressxzEnum
Definition: EnumDefinitions.h:526
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
Tria::StrainRateparallel
void StrainRateparallel()
Definition: Tria.cpp:4100
Tria::Update
void Update(Inputs2 *inputs2, int index, IoModel *iomodel, int analysis_counter, int analysis_type, int finitelement)
Definition: Tria.cpp:4656
SealevelMasks::isiceonly
bool * isiceonly
Definition: SealevelMasks.h:14
IssmDouble
double IssmDouble
Definition: types.h:37
HOApproximationEnum
@ HOApproximationEnum
Definition: EnumDefinitions.h:1095
Tria::GetNumberOfVertices
int GetNumberOfVertices(void)
Definition: Tria.cpp:2386
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
Nodes
Declaration of Nodes class.
Definition: Nodes.h:19
Tria::GetHorizontalSurfaceArea
IssmDouble GetHorizontalSurfaceArea(void)
Definition: Tria.cpp:1438
Tria::NodalFunctionsDerivativesVelocity
void NodalFunctionsDerivativesVelocity(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)
Definition: Tria.cpp:3575
DatasetInput2
Definition: DatasetInput2.h:14
GiaDeflectionCoreArgs::numtimes
int numtimes
Definition: GiaDeflectionCoreArgs.h:13
FrontalForcingsBasinIcefrontAreaEnum
@ FrontalForcingsBasinIcefrontAreaEnum
Definition: EnumDefinitions.h:152
Element::GetDofList
void GetDofList(int **pdoflist, int approximation_enum, int setenum)
Definition: Element.cpp:961
Tria::EdgeOnSurfaceIndices
void EdgeOnSurfaceIndices(int *pindex1, int *pindex)
Definition: Tria.cpp:1252
PentaInput2::GetInterpolation
int GetInterpolation()
Definition: PentaInput2.cpp:266
ElementHook::SpawnSegHook
void SpawnSegHook(ElementHook *triahook, int ndex1, int index2)
Definition: ElementHook.cpp:192
GiaDeflectionCoreArgs::rho_ice
IssmDouble rho_ice
Definition: GiaDeflectionCoreArgs.h:30
Tria::ComputeDeviatoricStressTensor
void ComputeDeviatoricStressTensor()
Definition: Tria.cpp:841
Tria::ValueP1OnGauss
void ValueP1OnGauss(IssmDouble *pvalue, IssmDouble *values, Gauss *gauss)
Definition: Tria.cpp:4872
Tria::ElementSizes
void ElementSizes(IssmDouble *hx, IssmDouble *hy, IssmDouble *hz)
Definition: Tria.cpp:1295
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
ElementHook::SetHookNodes
void SetHookNodes(int *node_ids, int numnodes, int analysis_counter)
Definition: ElementHook.cpp:188
Tria::AddBasalInput2
void AddBasalInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Tria.cpp:165
Tria::SetControlInputsFromVector
void SetControlInputsFromVector(IssmDouble *vector, int control_enum, int control_index, int offset, int N, int M)
Definition: Tria.cpp:3909
CalvingMeltingFluxLevelsetEnum
@ CalvingMeltingFluxLevelsetEnum
Definition: EnumDefinitions.h:513
DeviatoricStressyzEnum
@ DeviatoricStressyzEnum
Definition: EnumDefinitions.h:528
TriaRef::GetSegmentJacobianDeterminant
void GetSegmentJacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:229
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
SealevelriseHElasticEnum
@ SealevelriseHElasticEnum
Definition: EnumDefinitions.h:322
Element::HasNodeOnSurface
bool HasNodeOnSurface()
Definition: Element.cpp:1565
Vertex::Pid
int Pid(void)
Definition: Vertex.cpp:164
Tria::GroundinglineMassFlux
IssmDouble GroundinglineMassFlux(bool scaled)
Definition: Tria.cpp:2779
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
MaterialsEarthDensityEnum
@ MaterialsEarthDensityEnum
Definition: EnumDefinitions.h:251
Tria::~Tria
~Tria()
Definition: Tria.cpp:82
Tria::JacobianDeterminantBase
void JacobianDeterminantBase(IssmDouble *pJdet, IssmDouble *xyz_list_base, Gauss *gauss)
Definition: Tria.cpp:3298
EsaHElasticEnum
@ EsaHElasticEnum
Definition: EnumDefinitions.h:131
MaskOceanLevelsetEnum
@ MaskOceanLevelsetEnum
Definition: EnumDefinitions.h:640
SealevelMasks::isfullyfloating
bool * isfullyfloating
Definition: SealevelMasks.h:15
Hook::deliverp
Object ** deliverp(void)
Definition: Hook.cpp:187
Parameters
Declaration of Parameters class.
Definition: Parameters.h:18
SSAHOApproximationEnum
@ SSAHOApproximationEnum
Definition: EnumDefinitions.h:1257
DeviatoricStress2Enum
@ DeviatoricStress2Enum
Definition: EnumDefinitions.h:531
EsaDeltathicknessEnum
@ EsaDeltathicknessEnum
Definition: EnumDefinitions.h:559
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
MeshVertexonboundaryEnum
@ MeshVertexonboundaryEnum
Definition: EnumDefinitions.h:654
TriaRef::GetJacobianDeterminant3D
void GetJacobianDeterminant3D(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: TriaRef.cpp:121
TimeEnum
@ TimeEnum
Definition: EnumDefinitions.h:427
ADD_VAL
@ ADD_VAL
Definition: toolkitsenums.h:14
MaterialsRhoFreshwaterEnum
@ MaterialsRhoFreshwaterEnum
Definition: EnumDefinitions.h:263
MARSHALLING_ENUM
#define MARSHALLING_ENUM(EN)
Definition: Marshalling.h:14
CalvinglevermannCoeffEnum
@ CalvinglevermannCoeffEnum
Definition: EnumDefinitions.h:507
Seg::collapsed_ids
int collapsed_ids[2]
Definition: Seg.h:31
DeviatoricStressxxEnum
@ DeviatoricStressxxEnum
Definition: EnumDefinitions.h:524
MINIEnum
@ MINIEnum
Definition: EnumDefinitions.h:1156
Inputs2::SetTriaControlInput
void SetTriaControlInput(int enum_in, int layout, int interpolation, int id, int numindices, int *indices, IssmDouble *values, IssmDouble *values_min, IssmDouble *values_max)
Definition: Inputs2.cpp:692
IoModel::my_vertices_lids
int * my_vertices_lids
Definition: IoModel.h:73
Tria::GetLevelCoordinates
void GetLevelCoordinates(IssmDouble **pxyz_front, IssmDouble *xyz_list, int levelsetenum, IssmDouble level)
Definition: Tria.cpp:2200
BedEnum
@ BedEnum
Definition: EnumDefinitions.h:499
Tria::ControlToVectors
void ControlToVectors(Vector< IssmPDouble > *vector_control, Vector< IssmPDouble > *vector_gradient, int control_enum)
Definition: Tria.cpp:1136
Seg::iscollapsed
int iscollapsed
Definition: Seg.h:30
Tria::RignotMeltParameterization
void RignotMeltParameterization()
Definition: Tria.cpp:3852
P0Enum
@ P0Enum
Definition: EnumDefinitions.h:661
TransientInput2
Definition: TransientInput2.h:13
TriaInput2::Serve
void Serve(int numindices, int *indices)
Definition: TriaInput2.cpp:202
Tria::SetCurrentConfiguration
void SetCurrentConfiguration(Elements *elements, Loads *loads, Nodes *nodes, Materials *materials, Parameters *parameters)
Definition: Tria.cpp:3996
EsaRotationrateEnum
@ EsaRotationrateEnum
Definition: EnumDefinitions.h:562
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
Tria::EdgeOnBaseIndex
int EdgeOnBaseIndex()
Definition: Tria.cpp:1196
Material::copy2
virtual Material * copy2(Element *element)=0
Elements
Declaration of Elements class.
Definition: Elements.h:17
Tria::SpawnBasalElement
Element * SpawnBasalElement(void)
Definition: Tria.cpp:4032
StressTensorzzEnum
@ StressTensorzzEnum
Definition: EnumDefinitions.h:816
CalvingCrevasseDepthEnum
@ CalvingCrevasseDepthEnum
Definition: EnumDefinitions.h:96
Tria::AverageOntoPartition
void AverageOntoPartition(Vector< IssmDouble > *partition_contributions, Vector< IssmDouble > *partition_areas, IssmDouble *vertex_response, IssmDouble *qmu_part)
Definition: Tria.cpp:259
EsaYmotionEnum
@ EsaYmotionEnum
Definition: EnumDefinitions.h:568
Material::ViscosityHO
virtual void ViscosityHO(IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)=0
GaussTria::GaussNode
void GaussNode(int finitelement, int iv)
Definition: GaussTria.cpp:492
Tria::TimeAdapt
IssmDouble TimeAdapt()
Definition: Tria.cpp:4223
PressureEnum
@ PressureEnum
Definition: EnumDefinitions.h:664
MaterialsRhoIceEnum
@ MaterialsRhoIceEnum
Definition: EnumDefinitions.h:264
MeshNumberofverticesEnum
@ MeshNumberofverticesEnum
Definition: EnumDefinitions.h:273
P1DGEnum
@ P1DGEnum
Definition: EnumDefinitions.h:1215
SealevelEustaticMaskEnum
@ SealevelEustaticMaskEnum
Definition: EnumDefinitions.h:676
Tria::EdgeOnBaseIndices
void EdgeOnBaseIndices(int *pindex1, int *pindex)
Definition: Tria.cpp:1214
Tria::ComputeSigmaNN
void ComputeSigmaNN()
Definition: Tria.cpp:958
Tria::TotalCalvingMeltingFluxLevelset
IssmDouble TotalCalvingMeltingFluxLevelset(bool scaled)
Definition: Tria.cpp:4390
Tria::WriteFieldIsovalueSegment
void WriteFieldIsovalueSegment(DataSet *segments, int fieldenum, IssmDouble fieldvalue)
Definition: Tria.cpp:4885
TransientInput2::numtimesteps
int numtimesteps
Definition: TransientInput2.h:21
Element::vertices
Vertex ** vertices
Definition: Element.h:49
EsaHemisphereEnum
@ EsaHemisphereEnum
Definition: EnumDefinitions.h:132
Material
Definition: Material.h:21
TransientInputEnum
@ TransientInputEnum
Definition: EnumDefinitions.h:1314
AnalysisCounterEnum
@ AnalysisCounterEnum
Definition: EnumDefinitions.h:35
PentaInput2::Serve
void Serve(int numindices, int *indices)
Definition: PentaInput2.cpp:208
Tria::InputUpdateFromSolutionOneDof
void InputUpdateFromSolutionOneDof(IssmDouble *solution, int enum_type)
Definition: Tria.cpp:3092
VertexLIdEnum
@ VertexLIdEnum
Definition: EnumDefinitions.h:1323
FrontalForcingsThermalForcingEnum
@ FrontalForcingsThermalForcingEnum
Definition: EnumDefinitions.h:587
Gauss::GaussNode
virtual void GaussNode(int finitelement, int iv)=0
BedSlopeXEnum
@ BedSlopeXEnum
Definition: EnumDefinitions.h:500
ControlInputSizeMEnum
@ ControlInputSizeMEnum
Definition: EnumDefinitions.h:105
Contour
Definition: Contour.h:15
Tria::PressureInterpolation
int PressureInterpolation()
Definition: Tria.cpp:3745
SolidearthSettingsRigidEnum
@ SolidearthSettingsRigidEnum
Definition: EnumDefinitions.h:329
P1bubblecondensedEnum
@ P1bubblecondensedEnum
Definition: EnumDefinitions.h:1219
ConstantsYtsEnum
@ ConstantsYtsEnum
Definition: EnumDefinitions.h:104
GaussTria::begin
int begin(void)
Definition: GaussTria.cpp:356
MaterialsRheologyNEnum
@ MaterialsRheologyNEnum
Definition: EnumDefinitions.h:651
Tria::CreateDistanceInputFromSegmentlist
void CreateDistanceInputFromSegmentlist(IssmDouble *distances, int distanceenum)
Definition: Tria.cpp:1170
Tria::ComputeEsaStrainAndVorticity
void ComputeEsaStrainAndVorticity()
Definition: Tria.cpp:916
Element::IsFloating
bool IsFloating()
Definition: Element.cpp:1987
Tria::NodalFunctionsTensor
void NodalFunctionsTensor(IssmDouble *basis, Gauss *gauss)
Definition: Tria.cpp:3610
Vertex::Lid
int Lid(void)
Definition: Vertex.cpp:166
Tria::IceVolume
IssmDouble IceVolume(bool scaled)
Definition: Tria.cpp:2906
DeviatoricStressxyEnum
@ DeviatoricStressxyEnum
Definition: EnumDefinitions.h:525
Element::Sid
int Sid()
Definition: Element.cpp:3578
Input2::copy
virtual Input2 * copy()=0
SolidearthSettingsHorizEnum
@ SolidearthSettingsHorizEnum
Definition: EnumDefinitions.h:323
MaterialsMantleShearModulusEnum
@ MaterialsMantleShearModulusEnum
Definition: EnumDefinitions.h:258
EsaUElasticEnum
@ EsaUElasticEnum
Definition: EnumDefinitions.h:134
StressTensorxyEnum
@ StressTensorxyEnum
Definition: EnumDefinitions.h:812
Inputs2::SetTriaInput
void SetTriaInput(int enum_in, int interpolation, int row, IssmDouble values)
Definition: Inputs2.cpp:768
Element::isonbase
bool isonbase
Definition: Element.h:53
FSApproximationEnum
@ FSApproximationEnum
Definition: EnumDefinitions.h:1060
Tria::NumberofNodesPressure
int NumberofNodesPressure(void)
Definition: Tria.cpp:3710
StrainRateperpendicularEnum
@ StrainRateperpendicularEnum
Definition: EnumDefinitions.h:803
Tria::MassFlux
IssmDouble MassFlux(IssmDouble *segment)
Definition: Tria.cpp:3433
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
ElementHook
Definition: ElementHook.h:11
Inputs2::SetArrayInput
void SetArrayInput(int enum_in, int row, IssmDouble *layers, int numlayers)
Definition: Inputs2.cpp:623
GaussTria::GaussFromCoords
void GaussFromCoords(IssmDouble x1, IssmDouble y1, IssmDouble *xyz_list)
Definition: GaussTria.cpp:453
Tria::ElementResponse
void ElementResponse(IssmDouble *presponse, int response_enum)
Definition: Tria.cpp:1272
Hook::reset
void reset(void)
Definition: Hook.cpp:211
TriaRef::VelocityInterpolation
int VelocityInterpolation(int fe_stokes)
Definition: TriaRef.cpp:518
Tria::HasEdgeOnSurface
bool HasEdgeOnSurface()
Definition: Tria.cpp:2573
EsaStrainrateyyEnum
@ EsaStrainrateyyEnum
Definition: EnumDefinitions.h:565
Input2::GetInputMaxAbs
virtual IssmDouble GetInputMaxAbs(void)
Definition: Input2.h:35
Input2::ChangeEnum
void ChangeEnum(int newenumtype)
Definition: Input2.h:26
Tria::SpawnSeg
Seg * SpawnSeg(int index1, int index2)
Definition: Tria.cpp:4050
SolidearthSettingsOceanAreaScalingEnum
@ SolidearthSettingsOceanAreaScalingEnum
Definition: EnumDefinitions.h:325
GiaDeflectionCorex
void GiaDeflectionCorex(IssmDouble *pwi, IssmDouble *pdwidt, GiaDeflectionCoreArgs *arguments)
Definition: GiaDeflectionCorex.cpp:44
Input2::GetInputMax
virtual IssmDouble GetInputMax(void)
Definition: Input2.h:34
CalvingMeltingrateEnum
@ CalvingMeltingrateEnum
Definition: EnumDefinitions.h:504
Tria::StrainRateperpendicular
void StrainRateperpendicular()
Definition: Tria.cpp:4146
SealevelriseGUEnum
@ SealevelriseGUEnum
Definition: EnumDefinitions.h:695
ElementHook::hmaterial
Hook * hmaterial
Definition: ElementHook.h:17
ElementInput2
Definition: ElementInput2.h:7
EsaStrainratexyEnum
@ EsaStrainratexyEnum
Definition: EnumDefinitions.h:564
MaterialsRheologyBbarEnum
@ MaterialsRheologyBbarEnum
Definition: EnumDefinitions.h:644
Tria::GetVerticesCoordinatesTop
void GetVerticesCoordinatesTop(IssmDouble **pxyz_list)
Definition: Tria.cpp:2508
Tria::CreateInputTimeAverage
void CreateInputTimeAverage(int transientinput_enum, int averagedinput_enum, IssmDouble init_time, IssmDouble end_time, int averaging_method)
Definition: Tria.cpp:2116
GaussTria::GaussVertex
void GaussVertex(int iv)
Definition: GaussTria.cpp:550
Tria::ControlInputSetGradient
void ControlInputSetGradient(IssmDouble *gradient, int enum_type, int control_index, int offset, int N, int M)
Definition: Tria.cpp:1099
Tria::NodalFunctionsPressure
void NodalFunctionsPressure(IssmDouble *basis, Gauss *gauss)
Definition: Tria.cpp:3582
Tria::GetLevelsetPositivePart
void GetLevelsetPositivePart(int *point1, IssmDouble *fraction1, IssmDouble *fraction2, bool *mainlynegative, IssmDouble *levelsetvalues)
Definition: Tria.cpp:2315
P0DGEnum
@ P0DGEnum
Definition: EnumDefinitions.h:1214
Element::nodes
Node ** nodes
Definition: Element.h:48
Element
Definition: Element.h:41
Tria::NodalFunctionsDerivatives
void NodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)
Definition: Tria.cpp:3568
DeviatoricStresszzEnum
@ DeviatoricStresszzEnum
Definition: EnumDefinitions.h:529
Tria::VelocityInterpolation
int VelocityInterpolation()
Definition: Tria.cpp:4876
Tria::CalvingMeltingFluxLevelset
void CalvingMeltingFluxLevelset()
Definition: Tria.cpp:683
Tria::IcefrontMassFlux
IssmDouble IcefrontMassFlux(bool scaled)
Definition: Tria.cpp:2594
IoModel::numberofvertices
int numberofvertices
Definition: IoModel.h:99
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
Tria::CalvingCrevasseDepth
void CalvingCrevasseDepth()
Definition: Tria.cpp:392
Tria::ComputeBasalStress
void ComputeBasalStress(void)
Definition: Tria.cpp:837
TriaInput2::copy
Input2 * copy()
Definition: TriaInput2.cpp:72
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
ElementMatrix::StaticCondensation
void StaticCondensation(int numindices, int *indices)
Definition: ElementMatrix.cpp:524
MaterialsLithosphereShearModulusEnum
@ MaterialsLithosphereShearModulusEnum
Definition: EnumDefinitions.h:256
TaylorHoodEnum
@ TaylorHoodEnum
Definition: EnumDefinitions.h:1299
Element::IsIceOnlyInElement
bool IsIceOnlyInElement()
Definition: Element.cpp:2026
CalvingrateyEnum
@ CalvingrateyEnum
Definition: EnumDefinitions.h:511
GaussTria
Definition: GaussTria.h:12
DslComputeFingerprintsEnum
@ DslComputeFingerprintsEnum
Definition: EnumDefinitions.h:128
Tria::InputServe
void InputServe(Input2 *input_in)
Definition: Tria.cpp:1974
GiaDeflectionCoreArgs::currenttime
IssmDouble currenttime
Definition: GiaDeflectionCoreArgs.h:11
SealevelriseGNEnum
@ SealevelriseGNEnum
Definition: EnumDefinitions.h:697
TriaRef::PressureInterpolation
int PressureInterpolation(int fe_stokes)
Definition: TriaRef.cpp:491
LATaylorHoodEnum
@ LATaylorHoodEnum
Definition: EnumDefinitions.h:1139
Tria::NormalTop
void NormalTop(IssmDouble *normal, IssmDouble *xyz_list)
Definition: Tria.cpp:3686
TriaInput2::GetInputAverage
void GetInputAverage(IssmDouble *pvalue)
Definition: TriaInput2.cpp:256
Tria::GetVectorFromControlInputs
void GetVectorFromControlInputs(Vector< IssmDouble > *gradient, int control_enum, int control_index, const char *data, int offset)
Definition: Tria.cpp:2434
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
Object
Definition: Object.h:13
PentaInput2::ServeCollapsed
void ServeCollapsed(int row, int state)
Definition: PentaInput2.cpp:240
SolidearthPlanetRadiusEnum
@ SolidearthPlanetRadiusEnum
Definition: EnumDefinitions.h:303
GiaMantleViscosityEnum
@ GiaMantleViscosityEnum
Definition: EnumDefinitions.h:590
PentaInput2::SetServeCollapsed
void SetServeCollapsed(int)
Definition: PentaInput2.cpp:263
TriaInput2Enum
@ TriaInput2Enum
Definition: EnumDefinitions.h:1124
Tria::NormalBase
void NormalBase(IssmDouble *normal, IssmDouble *xyz_list)
Definition: Tria.cpp:3655
ConstantsGEnum
@ ConstantsGEnum
Definition: EnumDefinitions.h:102
Tria::GetLevelsetIntersection
void GetLevelsetIntersection(int **pindices, int *pnumiceverts, IssmDouble *fraction, int levelset_enum, IssmDouble level)
Definition: Tria.cpp:2239
Hook::delivers
Object * delivers(void)
Definition: Hook.cpp:191
Tria::ComputeStressTensor
void ComputeStressTensor()
Definition: Tria.cpp:1018
VertexSIdEnum
@ VertexSIdEnum
Definition: EnumDefinitions.h:1325
GiaDeflectionCoreArgs::yts
IssmDouble yts
Definition: GiaDeflectionCoreArgs.h:33
BasalforcingsGroundediceMeltingRateEnum
@ BasalforcingsGroundediceMeltingRateEnum
Definition: EnumDefinitions.h:478
InputToExtrudeEnum
@ InputToExtrudeEnum
Definition: EnumDefinitions.h:205
Element::inputs2
Inputs2 * inputs2
Definition: Element.h:47
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
Materials
Declaration of Materials class.
Definition: Materials.h:16
Element::id
int id
Definition: Element.h:44
Tria::CalvingRateVonmises
void CalvingRateVonmises()
Definition: Tria.cpp:297
TransientInput2::GetTimeByOffset
IssmDouble GetTimeByOffset(int offset)
Definition: TransientInput2.cpp:539
CalvingratexAverageEnum
@ CalvingratexAverageEnum
Definition: EnumDefinitions.h:508
Tria::ObjectEnum
int ObjectEnum()
Definition: Tria.cpp:3704
Element::sid
int sid
Definition: Element.h:45
Vector::SetValues
void SetValues(int ssize, int *list, doubletype *values, InsMode mode)
Definition: Vector.h:153
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
Tria::GetArea3D
IssmDouble GetArea3D(void)
Definition: Tria.cpp:1443
VxAverageEnum
@ VxAverageEnum
Definition: EnumDefinitions.h:845
GiaDeflectionCoreArgs::iedge
int iedge
Definition: GiaDeflectionCoreArgs.h:27
Tria::ReduceMatrices
void ReduceMatrices(ElementMatrix *Ke, ElementVector *pe)
Definition: Tria.cpp:3749
xDelete
void xDelete(T **&aT_pp)
Definition: MemOps.h:97
ApproximationEnum
@ ApproximationEnum
Definition: EnumDefinitions.h:470
FrontalForcingsNumberofBasinsEnum
@ FrontalForcingsNumberofBasinsEnum
Definition: EnumDefinitions.h:153
TimesteppingCflCoefficientEnum
@ TimesteppingCflCoefficientEnum
Definition: EnumDefinitions.h:428
DeviatoricStress1Enum
@ DeviatoricStress1Enum
Definition: EnumDefinitions.h:530
Tria::GetInputAveragesUpToCurrentTime
void GetInputAveragesUpToCurrentTime(int input_enum, IssmDouble **pvalues, IssmDouble **ptimes, int *pnumtimes, IssmDouble currenttime)
Definition: Tria.cpp:2129
TriaRef::GetNodalFunctions
void GetNodalFunctions(IssmDouble *basis, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:147
SurfaceCrevasseEnum
@ SurfaceCrevasseEnum
Definition: EnumDefinitions.h:822
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
TriaInput2
Definition: TriaInput2.h:8
Hook
Definition: Hook.h:16
GiaDeflectionCoreArgs::ri
IssmDouble ri
Definition: GiaDeflectionCoreArgs.h:14
DeviatoricStressyyEnum
@ DeviatoricStressyyEnum
Definition: EnumDefinitions.h:527
Element::element_type_list
int * element_type_list
Definition: Element.h:55
Tria::JacobianDeterminantSurface
void JacobianDeterminantSurface(IssmDouble *pJdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: Tria.cpp:3305
Hook::configure
void configure(DataSet *dataset)
Definition: Hook.cpp:145
NodesEnum
@ NodesEnum
Definition: EnumDefinitions.h:275
Tria::Masscon
IssmDouble Masscon(IssmDouble *levelset)
Definition: Tria.cpp:3319
Tria::Configure
void Configure(Elements *elements, Loads *loads, Nodes *nodesin, Vertices *verticesin, Materials *materials, Parameters *parameters, Inputs2 *inputs2in)
Definition: Tria.cpp:1070
GsetEnum
@ GsetEnum
Definition: EnumDefinitions.h:1093
Tria::CharacteristicLength
IssmDouble CharacteristicLength(void)
Definition: Tria.cpp:832
IoModel::elementtoedgeconnectivity
int * elementtoedgeconnectivity
Definition: IoModel.h:83
SealevelriseUElasticEnum
@ SealevelriseUElasticEnum
Definition: EnumDefinitions.h:333
Matrix2x2Eigen
void Matrix2x2Eigen(IssmDouble *plambda1, IssmDouble *plambda2, IssmDouble *pvx, IssmDouble *pvy, IssmDouble a11, IssmDouble a21, IssmDouble a22)
Definition: MatrixUtils.cpp:348
BasalforcingsFloatingiceMeltingRateEnum
@ BasalforcingsFloatingiceMeltingRateEnum
Definition: EnumDefinitions.h:476
Tria::UpdateConstraintsExtrudeFromTop
void UpdateConstraintsExtrudeFromTop(void)
Definition: Tria.cpp:4826
Domain3DsurfaceEnum
@ Domain3DsurfaceEnum
Definition: EnumDefinitions.h:1039
ElementEnum
@ ElementEnum
Definition: EnumDefinitions.h:1049
alpha
IssmDouble alpha(IssmDouble x, IssmDouble y, IssmDouble z, int testid)
Definition: fsanalyticals.cpp:221
Tria::FloatingArea
IssmDouble FloatingArea(bool scaled)
Definition: Tria.cpp:1322
Tria::GetNumberOfNodes
int GetNumberOfNodes(void)
Definition: Tria.cpp:2377
Tria::GetAreaCoordinates
void GetAreaCoordinates(IssmDouble *area_coordinates, IssmDouble *xyz_zero, IssmDouble *xyz_list, int numpoints)
Definition: Tria.cpp:1523
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
DamageDEnum
@ DamageDEnum
Definition: EnumDefinitions.h:516
P2bubbleEnum
@ P2bubbleEnum
Definition: EnumDefinitions.h:1224
StrainRateeffectiveEnum
@ StrainRateeffectiveEnum
Definition: EnumDefinitions.h:801
Element::GetInput2Value
void GetInput2Value(bool *pvalue, int enum_type)
Definition: Element.cpp:1185
Material::ViscosityFS
virtual void ViscosityFS(IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *vz_input)=0
MARSHALLING
#define MARSHALLING(FIELD)
Definition: Marshalling.h:29
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
DatasetInput2::GetPentaInputByOffset
PentaInput2 * GetPentaInputByOffset(int i)
Definition: DatasetInput2.cpp:237
GiaDeflectionCoreArgs::mantle_viscosity
IssmDouble mantle_viscosity
Definition: GiaDeflectionCoreArgs.h:24
SurfaceloadWaterHeightChangeEnum
@ SurfaceloadWaterHeightChangeEnum
Definition: EnumDefinitions.h:692
Tria::NormalSection
void NormalSection(IssmDouble *normal, IssmDouble *xyz_list)
Definition: Tria.cpp:3671
StressTensoryyEnum
@ StressTensoryyEnum
Definition: EnumDefinitions.h:814
P1P1Enum
@ P1P1Enum
Definition: EnumDefinitions.h:1216
Tria::TotalGroundedBmb
IssmDouble TotalGroundedBmb(bool scaled)
Definition: Tria.cpp:4576
MINIcondensedEnum
@ MINIcondensedEnum
Definition: EnumDefinitions.h:1157
GeometryHydrostaticRatioEnum
@ GeometryHydrostaticRatioEnum
Definition: EnumDefinitions.h:588
SigmaVMEnum
@ SigmaVMEnum
Definition: EnumDefinitions.h:705
INS_VAL
@ INS_VAL
Definition: toolkitsenums.h:14
Tria::NodalFunctions
void NodalFunctions(IssmDouble *basis, Gauss *gauss)
Definition: Tria.cpp:3561
TriaRef::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: TriaRef.h:30
ElementInput2::GetInterpolation
virtual int GetInterpolation()=0
Tria::IsNodeOnShelfFromFlags
bool IsNodeOnShelfFromFlags(IssmDouble *flags)
Definition: Tria.cpp:3258
GaussTria::GaussPoint
void GaussPoint(int ig)
Definition: GaussTria.cpp:479
Tria::Tria
Tria()
Definition: Tria.h:35
SolidearthPlanetAreaEnum
@ SolidearthPlanetAreaEnum
Definition: EnumDefinitions.h:304
Tria::NewGaussBase
Gauss * NewGaussBase(int order)
Definition: Tria.cpp:3547
SurfaceEnum
@ SurfaceEnum
Definition: EnumDefinitions.h:823
Gauss::Enum
virtual int Enum(void)=0
PentaInput2
Definition: PentaInput2.h:8
Inputs2
Declaration of Inputs class.
Definition: Inputs2.h:23
Tria::IcefrontMassFluxLevelset
IssmDouble IcefrontMassFluxLevelset(bool scaled)
Definition: Tria.cpp:2650
TriaInput2::GetInterpolation
int GetInterpolation()
Definition: TriaInput2.cpp:253
GiaLithosphereThicknessEnum
@ GiaLithosphereThicknessEnum
Definition: EnumDefinitions.h:589
TriaRef::GetInputDerivativeValue
void GetInputDerivativeValue(IssmDouble *pp, IssmDouble *plist, IssmDouble *xyz_list, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:34
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
MaterialsRhoSeawaterEnum
@ MaterialsRhoSeawaterEnum
Definition: EnumDefinitions.h:265
GiaDeflectionCoreArgs::re
IssmDouble re
Definition: GiaDeflectionCoreArgs.h:15
SealevelriseGEnum
@ SealevelriseGEnum
Definition: EnumDefinitions.h:694
PI
const double PI
Definition: constants.h:11
Tria::FiniteElement
int FiniteElement(void)
Definition: Tria.cpp:1318
Hook::copy
Object * copy(void)
Definition: Hook.cpp:61
MaterialsLithosphereDensityEnum
@ MaterialsLithosphereDensityEnum
Definition: EnumDefinitions.h:255
Tria::GetDatasetInput2
DatasetInput2 * GetDatasetInput2(int inputenum)
Definition: Tria.cpp:2044
IsInputEnum
bool IsInputEnum(int enum_in)
Definition: EnumToStringx.cpp:1368
P1bubbleEnum
@ P1bubbleEnum
Definition: EnumDefinitions.h:1218
Tria::Misfit
IssmDouble Misfit(int modelenum, int observationenum, int weightsenum)
Definition: Tria.cpp:3437
Inputs2::GetPentaInput
PentaInput2 * GetPentaInput(int enum_type)
Definition: Inputs2.cpp:363
ElementHook::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: ElementHook.cpp:67
DamageDbarEnum
@ DamageDbarEnum
Definition: EnumDefinitions.h:518
Object::ObjectEnum
virtual int ObjectEnum()=0
Vertex::Connectivity
int Connectivity(void)
Definition: Vertex.cpp:138
GiaDeflectionCoreArgs::hes
IssmDouble * hes
Definition: GiaDeflectionCoreArgs.h:12
StrainRateparallelEnum
@ StrainRateparallelEnum
Definition: EnumDefinitions.h:802
Tria::copy
Object * copy()
Definition: Tria.cpp:86
Input2
Definition: Input2.h:18
Element::GetDofListLocal
void GetDofListLocal(int **pdoflist, int approximation_enum, int setenum)
Definition: Element.cpp:984
VertexEnum
@ VertexEnum
Definition: EnumDefinitions.h:1322
Element::GetVerticesSidList
void GetVerticesSidList(int *sidlist)
Definition: Element.cpp:1456
DeviatoricStresseffectiveEnum
@ DeviatoricStresseffectiveEnum
Definition: EnumDefinitions.h:523
VertexPIdEnum
@ VertexPIdEnum
Definition: EnumDefinitions.h:1324
GiaDeflectionCoreArgs::lithosphere_density
IssmDouble lithosphere_density
Definition: GiaDeflectionCoreArgs.h:19
DatasetInput2::GetNumIds
int GetNumIds() const
Definition: DatasetInput2.h:24
Seg
Definition: Seg.h:27
Tria::GetIcefrontCoordinates
void GetIcefrontCoordinates(IssmDouble **pxyz_front, IssmDouble *xyz_list, int levelsetenum)
Definition: Tria.cpp:1844
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
Gauss::GaussVertex
virtual void GaussVertex(int iv)=0
Tria::MisfitArea
IssmDouble MisfitArea(int weightsenum)
Definition: Tria.cpp:3478
Inputs2::GetControlInput2Data
ElementInput2 * GetControlInput2Data(int enum_type, const char *data)
Definition: Inputs2.cpp:423
DoubleVecParam::GetParameterValueByPointer
void GetParameterValueByPointer(IssmDouble **pIssmDoublearray, int *pM)
Definition: DoubleVecParam.cpp:117
Tria::GetAreaSpherical
IssmDouble GetAreaSpherical(void)
Definition: Tria.cpp:1495
Tria::GetInputValue
void GetInputValue(IssmDouble *pvalue, Node *node, int enumtype)
Definition: Tria.cpp:2172
AreaEnum
@ AreaEnum
Definition: EnumDefinitions.h:819
CalvingFluxLevelsetEnum
@ CalvingFluxLevelsetEnum
Definition: EnumDefinitions.h:512
Inputs2::GetTransientInput
TransientInput2 * GetTransientInput(int enum_type)
Definition: Inputs2.cpp:406
TriaRef::GetNodalFunctionsDerivatives
void GetNodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:202
SealevelMasks::notfullygrounded
bool * notfullygrounded
Definition: SealevelMasks.h:16
TriaRef::TensorInterpolation
int TensorInterpolation(int fe_stokes)
Definition: TriaRef.cpp:509
Material::GetBbar
virtual IssmDouble GetBbar(Gauss *gauss)=0
LACrouzeixRaviartEnum
@ LACrouzeixRaviartEnum
Definition: EnumDefinitions.h:1138
Element::IsIceInElement
bool IsIceInElement()
Definition: Element.cpp:2021
Tria::NodalFunctionsP2
void NodalFunctionsP2(IssmDouble *basis, Gauss *gauss)
Definition: Tria.cpp:3603
IoModel::Data
IssmDouble * Data(const char *data_name)
Definition: IoModel.cpp:437
PentaInput2Enum
@ PentaInput2Enum
Definition: EnumDefinitions.h:1125
Loads
Declaration of Loads class.
Definition: Loads.h:16
Element::IsOceanInElement
bool IsOceanInElement()
Definition: Element.cpp:2036
Node
Definition: Node.h:23
Tria::GetGroundedPortion
IssmDouble GetGroundedPortion(IssmDouble *xyz_list)
Definition: Tria.cpp:1619
Tria::SurfaceArea
IssmDouble SurfaceArea(void)
Definition: Tria.cpp:4192
Node::Sid
int Sid(void)
Definition: Node.cpp:622
ElementInput2::ObjectEnum
virtual int ObjectEnum()=0
CalvingStressThresholdFloatingiceEnum
@ CalvingStressThresholdFloatingiceEnum
Definition: EnumDefinitions.h:505
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
ElementHook::hvertices
Hook * hvertices
Definition: ElementHook.h:16
EsaXmotionEnum
@ EsaXmotionEnum
Definition: EnumDefinitions.h:567
Tria
Definition: Tria.h:29
SealevelriseGElasticEnum
@ SealevelriseGElasticEnum
Definition: EnumDefinitions.h:319
Tria::GetAreaIce
IssmDouble GetAreaIce(void)
Definition: Tria.cpp:1462
Inputs2::GetTriaInput
TriaInput2 * GetTriaInput(int enum_type)
Definition: Inputs2.cpp:318
MeshScaleFactorEnum
@ MeshScaleFactorEnum
Definition: EnumDefinitions.h:652
Node::DofInFSet
void DofInFSet(int dof)
Definition: Node.cpp:694
XZvectorsToCoordinateSystem
void XZvectorsToCoordinateSystem(IssmDouble *T, IssmDouble *xzvectors)
Definition: XZvectorsToCoordinateSystem.cpp:8
SealevelriseIndicesEnum
@ SealevelriseIndicesEnum
Definition: EnumDefinitions.h:693
MaterialsRheologyBEnum
@ MaterialsRheologyBEnum
Definition: EnumDefinitions.h:643
Element::parameters
Parameters * parameters
Definition: Element.h:51
Tria::NodalFunctionsP1Derivatives
void NodalFunctionsP1Derivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)
Definition: Tria.cpp:3596
Tria::GroundedArea
IssmDouble GroundedArea(bool scaled)
Definition: Tria.cpp:2525
GiaDeflectionCoreArgs::lithosphere_shear_modulus
IssmDouble lithosphere_shear_modulus
Definition: GiaDeflectionCoreArgs.h:20
Tria::IceVolumeAboveFloatation
IssmDouble IceVolumeAboveFloatation(bool scaled)
Definition: Tria.cpp:3010
Inputs2::SetTriaControlInputGradient
void SetTriaControlInputGradient(int enum_in, int interpolation, int numindices, int *indices, IssmDouble *values)
Definition: Inputs2.cpp:717
Tria::JacobianDeterminant
void JacobianDeterminant(IssmDouble *pJdet, IssmDouble *xyz_list, Gauss *gauss)
Definition: Tria.cpp:3291
Gauss::begin
virtual int begin(void)=0
Tria::FSContactMigration
void FSContactMigration(Vector< IssmDouble > *vertex_sigmann, Vector< IssmDouble > *vertex_waterpressure)
Definition: Tria.cpp:1349
VxEnum
@ VxEnum
Definition: EnumDefinitions.h:846
MeshVertexonsurfaceEnum
@ MeshVertexonsurfaceEnum
Definition: EnumDefinitions.h:655
Node::DofInSSet
void DofInSSet(int dof)
Definition: Node.cpp:709
SurfaceloadIceThicknessChangeEnum
@ SurfaceloadIceThicknessChangeEnum
Definition: EnumDefinitions.h:691
Material::ViscositySSA
virtual void ViscositySSA(IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)=0
min
IssmDouble min(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:14
Tria::AddControlInput
void AddControlInput(int input_enum, Inputs2 *inputs2, IoModel *iomodel, IssmDouble *values, IssmDouble *values_min, IssmDouble *values_max, int interpolation_enum, int id)
Definition: Tria.cpp:211
DoubleVecParam
Definition: DoubleVecParam.h:20
Tria::JacobianDeterminantTop
void JacobianDeterminantTop(IssmDouble *pJdet, IssmDouble *xyz_list_base, Gauss *gauss)
Definition: Tria.cpp:3312
GiaDeflectionCoreArgs
Definition: GiaDeflectionCoreArgs.h:8
Tria::GetArea
IssmDouble GetArea(void)
Definition: Tria.cpp:1423
P2bubblecondensedEnum
@ P2bubblecondensedEnum
Definition: EnumDefinitions.h:1225
CalvingCalvingrateEnum
@ CalvingCalvingrateEnum
Definition: EnumDefinitions.h:502
ElementInput2::GetInputInterpolationType
int GetInputInterpolationType()
Definition: ElementInput2.cpp:32
GiaDeflectionCoreArgs::lithosphere_thickness
IssmDouble lithosphere_thickness
Definition: GiaDeflectionCoreArgs.h:21
Gauss::GaussPoint
virtual void GaussPoint(int ig)=0
Input2::GetInputMin
virtual IssmDouble GetInputMin(void)
Definition: Input2.h:36
TriaRef::GetInputValue
void GetInputValue(IssmDouble *pp, IssmDouble *plist, Gauss *gauss, int finiteelement)
Definition: TriaRef.cpp:68
NodeSIdEnum
@ NodeSIdEnum
Definition: EnumDefinitions.h:1200
GaussTriaEnum
@ GaussTriaEnum
Definition: EnumDefinitions.h:1081
StressTensorxzEnum
@ StressTensorxzEnum
Definition: EnumDefinitions.h:813
Tria::ValueP1DerivativesOnGauss
void ValueP1DerivativesOnGauss(IssmDouble *dvalue, IssmDouble *values, IssmDouble *xyz_list, Gauss *gauss)
Definition: Tria.cpp:4868
Tria::DatasetInputCreate
void DatasetInputCreate(IssmDouble *array, int M, int N, int *individual_enums, int num_inputs, Inputs2 *inputs2, IoModel *iomodel, int input_enum)
Definition: Tria.cpp:233
VyAverageEnum
@ VyAverageEnum
Definition: EnumDefinitions.h:849
Tria::IsIcefront
bool IsIcefront(void)
Definition: Tria.cpp:3239
TriaRef::NumberofNodes
int NumberofNodes(int finiteelement)
Definition: TriaRef.cpp:463
ElementHook::hneighbors
Hook * hneighbors
Definition: ElementHook.h:18
Tria::EdgeOnSurfaceIndex
int EdgeOnSurfaceIndex()
Definition: Tria.cpp:1234
Tria::ResetHooks
void ResetHooks()
Definition: Tria.cpp:3836
Parameters::FindParam
void FindParam(bool *pinteger, int enum_type)
Definition: Parameters.cpp:262
MaterialsMantleDensityEnum
@ MaterialsMantleDensityEnum
Definition: EnumDefinitions.h:257
ThicknessEnum
@ ThicknessEnum
Definition: EnumDefinitions.h:840
ElementInput2::element_values
IssmDouble * element_values
Definition: ElementInput2.h:18
WaterheightEnum
@ WaterheightEnum
Definition: EnumDefinitions.h:863
Element::GetVerticesPidList
void GetVerticesPidList(int *pidlist)
Definition: Element.cpp:1433
Tria::UpdatePotentialUngrounding
int UpdatePotentialUngrounding(IssmDouble *vertices_potentially_ungrounding, Vector< IssmDouble > *vec_nodes_on_iceshelf, IssmDouble *nodes_on_iceshelf)
Definition: Tria.cpp:4849
Tria::SpawnTopElement
Element * SpawnTopElement(void)
Definition: Tria.cpp:4082
NUMVERTICES
#define NUMVERTICES
Definition: Tria.cpp:29
Element::GetNodeIndex
int GetNodeIndex(Node *node)
Definition: Element.cpp:1212
SSAApproximationEnum
@ SSAApproximationEnum
Definition: EnumDefinitions.h:1255
FrontalForcingsBasinIdEnum
@ FrontalForcingsBasinIdEnum
Definition: EnumDefinitions.h:585
P2Enum
@ P2Enum
Definition: EnumDefinitions.h:1223
GiaDeflectionCoreArgs::mantle_shear_modulus
IssmDouble mantle_shear_modulus
Definition: GiaDeflectionCoreArgs.h:23
Tria::IsFaceOnBoundary
bool IsFaceOnBoundary(void)
Definition: Tria.cpp:3219
Tria::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Tria.cpp:146
Tria::NodalValue
int NodalValue(IssmDouble *pvalue, int index, int natureofdataenum)
Definition: Tria.cpp:3624
VelEnum
@ VelEnum
Definition: EnumDefinitions.h:844
GiaDeflectionCoreArgs::mantle_density
IssmDouble mantle_density
Definition: GiaDeflectionCoreArgs.h:22
Tria::CalvingRateLevermann
void CalvingRateLevermann()
Definition: Tria.cpp:490
Inputs2::GetDatasetInput2
DatasetInput2 * GetDatasetInput2(int enum_type)
Definition: Inputs2.cpp:438
Tria::PotentialUngrounding
void PotentialUngrounding(Vector< IssmDouble > *potential_sheet_ungrounding)
Definition: Tria.cpp:3718
Tria::NodalFunctionsP1
void NodalFunctionsP1(IssmDouble *basis, Gauss *gauss)
Definition: Tria.cpp:3589
ElementHook::hnodes
Hook ** hnodes
Definition: ElementHook.h:15
Node::ApplyConstraint
void ApplyConstraint(int dof, IssmDouble value)
Definition: Node.cpp:646
ElementVector
Definition: ElementVector.h:20
IoModel::elements
int * elements
Definition: IoModel.h:79
GiaDeflectionCoreArgs::times
IssmDouble * times
Definition: GiaDeflectionCoreArgs.h:16
Element::StrainRateSSA
void StrainRateSSA(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4138
Element::MarshallElement
void MarshallElement(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction, int numanalyses)
Definition: Element.cpp:2222
Tria::AddInput2
void AddInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Tria.cpp:185
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
Tria::IsZeroLevelset
bool IsZeroLevelset(int levelset_enum)
Definition: Tria.cpp:3272
Tria::InputUpdateFromIoModel
void InputUpdateFromIoModel(int index, IoModel *iomodel)
Definition: Tria.cpp:3064
Vertex
Definition: Vertex.h:19
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
P1P1GLSEnum
@ P1P1GLSEnum
Definition: EnumDefinitions.h:1217
Element::HasNodeOnBase
bool HasNodeOnBase()
Definition: Element.cpp:1561
Tria::SetElementInput
void SetElementInput(int enum_in, IssmDouble values)
Definition: Tria.cpp:4012
IoModel
Definition: IoModel.h:48
Inputs2::SetTriaDatasetInput
void SetTriaDatasetInput(int enum_in, int id, int interpolation, int numindices, int *indices, IssmDouble *values)
Definition: Inputs2.cpp:743
SigmaNNEnum
@ SigmaNNEnum
Definition: EnumDefinitions.h:704
Tria::InputDepthAverageAtBase
void InputDepthAverageAtBase(int enum_type, int average_enum_type)
Definition: Tria.cpp:3046
Tria::TotalSmb
IssmDouble TotalSmb(bool scaled)
Definition: Tria.cpp:4621
max
IssmDouble max(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:24
Tria::TotalCalvingFluxLevelset
IssmDouble TotalCalvingFluxLevelset(bool scaled)
Definition: Tria.cpp:4261
IssmPDouble
IssmDouble IssmPDouble
Definition: types.h:38
TransientInput2::GetTriaInput
TriaInput2 * GetTriaInput()
Definition: TransientInput2.cpp:270
Parameters::FindParamObject
Param * FindParamObject(int enum_type)
Definition: Parameters.cpp:588
DataSet
Declaration of DataSet class.
Definition: DataSet.h:14
Inputs2::GetArrayPtr
void GetArrayPtr(int enum_in, int row, IssmDouble **pvalues, int *pN)
Definition: Inputs2.cpp:468
Tria::VertexConnectivity
int VertexConnectivity(int vertexindex)
Definition: Tria.cpp:4880
Tria::UpdateConstraintsExtrudeFromBase
void UpdateConstraintsExtrudeFromBase(void)
Definition: Tria.cpp:4802
Tria::NewGauss
Gauss * NewGauss(void)
Definition: Tria.cpp:3515
SealevelriseGRigidEnum
@ SealevelriseGRigidEnum
Definition: EnumDefinitions.h:318
SolidearthSettingsElasticEnum
@ SolidearthSettingsElasticEnum
Definition: EnumDefinitions.h:308
Element::GetInputListOnVertices
void GetInputListOnVertices(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1131
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
Tria::GetGroundedPart
void GetGroundedPart(int *point1, IssmDouble *fraction1, IssmDouble *fraction2, bool *mainlyfloating)
Definition: Tria.cpp:1565
EsaStrainratexxEnum
@ EsaStrainratexxEnum
Definition: EnumDefinitions.h:563
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
BasalCrevasseEnum
@ BasalCrevasseEnum
Definition: EnumDefinitions.h:475
ElementMatrix
Definition: ElementMatrix.h:19
FrontalForcingsSubglacialDischargeEnum
@ FrontalForcingsSubglacialDischargeEnum
Definition: EnumDefinitions.h:586
Element::GetInputListOnNodesVelocity
void GetInputListOnNodesVelocity(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1114
Inputs2::AddInput
void AddInput(Input2 *in_input)
Definition: Inputs2.cpp:147
Vector< IssmDouble >
Element::GradientIndexing
void GradientIndexing(int *indexing, int control_index)
Definition: Element.cpp:1510
CalvingrateyAverageEnum
@ CalvingrateyAverageEnum
Definition: EnumDefinitions.h:510
Tria::NewGaussTop
Gauss * NewGaussTop(int order)
Definition: Tria.cpp:3554
Tria::NumberofNodesVelocity
int NumberofNodesVelocity(void)
Definition: Tria.cpp:3714
Input2::GetInputAverage
virtual void GetInputAverage(IssmDouble *pvalue)
Definition: Input2.h:33
Element::isonsurface
bool isonsurface
Definition: Element.h:52
CrevasseDepthEnum
@ CrevasseDepthEnum
Definition: EnumDefinitions.h:515
Tria::CalvingFluxLevelset
void CalvingFluxLevelset()
Definition: Tria.cpp:547
Tria::GetIcefrontArea
IssmDouble GetIcefrontArea()
Definition: Tria.cpp:1744
Element::element_type
int element_type
Definition: Element.h:56
Tria::GetInputListOnVertices
void GetInputListOnVertices(IssmDouble *pvalue, Input2 *input, IssmDouble default_value)
Definition: Tria.cpp:1934
Node::GetNumberOfDofs
int GetNumberOfDofs(int approximation_enum, int setenum)
Definition: Node.cpp:741
Gauss
Definition: Gauss.h:8
Element::material
Material * material
Definition: Element.h:50
Tria::GetInput2
Input2 * GetInput2(int enumtype)
Definition: Tria.cpp:1880
TriaEnum
@ TriaEnum
Definition: EnumDefinitions.h:1318
Tria::InputUpdateFromVector
void InputUpdateFromVector(IssmDouble *vector, int name, int type)
Definition: Tria.cpp:3119
Tria::GetVertexIndex
int GetVertexIndex(Vertex *vertex)
Definition: Tria.cpp:2368
CalvingratexEnum
@ CalvingratexEnum
Definition: EnumDefinitions.h:509
Element::GetVerticesLidList
void GetVerticesLidList(int *lidlist)
Definition: Element.cpp:1426
Tria::GetElementType
int GetElementType(void)
Definition: Tria.cpp:1558
Tria::TotalFloatingBmb
IssmDouble TotalFloatingBmb(bool scaled)
Definition: Tria.cpp:4531
TransientInput2::AddTriaTimeInput
void AddTriaTimeInput(IssmDouble time, int numindices, int *indices, IssmDouble *values_in, int interp_in)
Definition: TransientInput2.cpp:138
Vector::SetValue
void SetValue(int dof, doubletype value, InsMode mode)
Definition: Vector.h:163
SealevelMasks::isoceanin
bool * isoceanin
Definition: SealevelMasks.h:17
GetNumberOfDofs
int GetNumberOfDofs(Node **nodes, int numnodes, int setenum, int approximation)
Definition: Node.cpp:1129
Tria::ResetFSBasalBoundaryCondition
void ResetFSBasalBoundaryCondition(void)
Definition: Tria.cpp:3786
SealevelMasks
Definition: SealevelMasks.h:10
Vertex::Sid
int Sid(void)
Definition: Vertex.cpp:168
XTaylorHoodEnum
@ XTaylorHoodEnum
Definition: EnumDefinitions.h:1329
SealevelriseGEEnum
@ SealevelriseGEEnum
Definition: EnumDefinitions.h:696
Tria::HasEdgeOnBase
bool HasEdgeOnBase()
Definition: Tria.cpp:2552
DatasetInput2::GetTriaInputByOffset
TriaInput2 * GetTriaInputByOffset(int i)
Definition: DatasetInput2.cpp:222
IoModel::numberofedges
int numberofedges
Definition: IoModel.h:93
Tria::NodalFunctionsVelocity
void NodalFunctionsVelocity(IssmDouble *basis, Gauss *gauss)
Definition: Tria.cpp:3617
GiaCrossSectionShapeEnum
@ GiaCrossSectionShapeEnum
Definition: EnumDefinitions.h:158
StressTensoryzEnum
@ StressTensoryzEnum
Definition: EnumDefinitions.h:815
ElementInput2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)=0
Inputs2::SetDoubleInput
void SetDoubleInput(int enum_in, int index, IssmDouble value)
Definition: Inputs2.cpp:606
Tria::GetVerticesCoordinatesBase
void GetVerticesCoordinatesBase(IssmDouble **pxyz_list)
Definition: Tria.cpp:2491
ElementHook::numanalyses
int numanalyses
Definition: ElementHook.h:14
Tria::TensorInterpolation
int TensorInterpolation()
Definition: Tria.cpp:4219
Generated on Thu Jul 2 2020 08:09:17 for Ice Sheet System Model by   doxygen 1.8.19