Ice Sheet System Model  4.18
Code documentation
FreeSurfaceBaseAnalysis.cpp
Go to the documentation of this file.
1 #include "./FreeSurfaceBaseAnalysis.h"
2 #include "../toolkits/toolkits.h"
3 #include "../classes/classes.h"
4 #include "../shared/shared.h"
5 #include "../modules/modules.h"
6 
7 /*Model processing*/
8 void FreeSurfaceBaseAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
9 }/*}}}*/
10 void FreeSurfaceBaseAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
11 
12  /*Intermediaries*/
13  int penpair_ids[2];
14  int count=0;
15  int numvertex_pairing;
16 
17  /*Create Penpair for vertex_pairing: */
18  IssmDouble *vertex_pairing=NULL;
19  IssmDouble *nodeonbase=NULL;
20  iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,"md.masstransport.vertex_pairing");
21  if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,"md.mesh.vertexonbase");
22  for(int i=0;i<numvertex_pairing;i++){
23 
24  if(iomodel->my_vertices[reCast<int>(vertex_pairing[2*i+0])-1]){
25 
26  /*In debugging mode, check that the second node is in the same cpu*/
27  _assert_(iomodel->my_vertices[reCast<int>(vertex_pairing[2*i+1])-1]);
28 
29  /*Skip if one of the two is not on the bed*/
30  if(iomodel->domaintype!=Domain2DhorizontalEnum){
31  if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
32  }
33 
34  /*Get node ids*/
35  penpair_ids[0]=reCast<int>(vertex_pairing[2*i+0]);
36  penpair_ids[1]=reCast<int>(vertex_pairing[2*i+1]);
37 
38  /*Create Load*/
39  loads->AddObject(new Penpair(count+1, &penpair_ids[0]));
40  count++;
41  }
42  }
43 
44  /*free ressources: */
45  iomodel->DeleteData(vertex_pairing,"md.masstransport.vertex_pairing");
46  iomodel->DeleteData(nodeonbase,"md.mesh.vertexonbase");
47 }/*}}}*/
48 void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr){/*{{{*/
49 
50  if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
51  ::CreateNodes(nodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum);
52  iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
53 }/*}}}*/
54 int FreeSurfaceBaseAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/
55  return 1;
56 }/*}}}*/
57 void FreeSurfaceBaseAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
58 
59  /*Now, is the model 3d? otherwise, do nothing: */
60  if (iomodel->domaintype==Domain2DhorizontalEnum)return;
61 
62  /*Finite element type*/
63  int finiteelement = P1Enum;
64 
65  /*Update elements: */
66  int counter=0;
67  for(int i=0;i<iomodel->numberofelements;i++){
68  if(iomodel->my_elements[i]){
69  Element* element=(Element*)elements->GetObjectByOffset(counter);
70  element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
71  counter++;
72  }
73  }
74 
75  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
76  iomodel->FetchDataToInput(inputs2,elements,"md.solidearth.sealevel",SealevelEnum,0);
77  iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
78  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum,0.);
79  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
80  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
81  if(iomodel->domaindim==3){
82  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
83  }
84  if(iomodel->domaintype!=Domain2DhorizontalEnum){
85  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
86  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
87  }
88 
89  /*Get what we need for ocean-induced basal melting*/
90  int basalforcing_model;
91  iomodel->FindConstant(&basalforcing_model,"md.basalforcings.model");
92  switch(basalforcing_model){
93  case FloatingMeltRateEnum:
94  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
95  break;
96  case LinearFloatingMeltRateEnum:
97  break;
98  case MismipFloatingMeltRateEnum:
99  break;
100  case MantlePlumeGeothermalFluxEnum:
101  break;
102  case SpatialLinearFloatingMeltRateEnum:
103  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
104  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
105  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
106  break;
107  case BasalforcingsPicoEnum:
108  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
109  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.overturning_coeff",BasalforcingsPicoOverturningCoeffEnum);
110  break;
111  case BasalforcingsIsmip6Enum:
112  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
113  break;
114  case BeckmannGoosseFloatingMeltRateEnum:
115  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
116  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
117  break;
118  default:
119  _error_("Basal forcing model "<<EnumToStringx(basalforcing_model)<<" not supported yet");
120  }
121 }/*}}}*/
122 void FreeSurfaceBaseAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
123 }/*}}}*/
124 
125 /*Finite Element Analysis*/
126 void FreeSurfaceBaseAnalysis::Core(FemModel* femmodel){/*{{{*/
127  _error_("not implemented");
128 }/*}}}*/
129 ElementVector* FreeSurfaceBaseAnalysis::CreateDVector(Element* element){/*{{{*/
130  /*Default, return NULL*/
131  return NULL;
132 }/*}}}*/
133 ElementMatrix* FreeSurfaceBaseAnalysis::CreateJacobianMatrix(Element* element){/*{{{*/
134 _error_("Not implemented");
135 }/*}}}*/
136 ElementMatrix* FreeSurfaceBaseAnalysis::CreateKMatrix(Element* element){/*{{{*/
137 
138  /*Intermediaries*/
139  int domaintype,dim,stabilization;
140  Element* basalelement = NULL;
141  IssmDouble *xyz_list = NULL;
142  IssmDouble Jdet,D_scalar,dt,h;
143  IssmDouble vel,vx,vy;
144 
145  /*Get basal element*/
146  element->FindParam(&domaintype,DomainTypeEnum);
147  switch(domaintype){
148  case Domain2DhorizontalEnum:
149  basalelement = element;
150  dim = 2;
151  break;
152  case Domain2DverticalEnum:
153  if(!element->IsOnBase()) return NULL;
154  basalelement = element->SpawnBasalElement();
155  dim = 1;
156  break;
157  case Domain3DEnum:
158  if(!element->IsOnBase()) return NULL;
159  basalelement = element->SpawnBasalElement();
160  dim = 2;
161  break;
162  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
163  }
164 
165  /*Fetch number of nodes and dof for this finite element*/
166  int numnodes = basalelement->GetNumberOfNodes();
167 
168  /*Initialize Element vector*/
169  ElementMatrix* Ke = basalelement->NewElementMatrix(NoneApproximationEnum);
170  IssmDouble* basis = xNew<IssmDouble>(numnodes);
171  IssmDouble* B = xNew<IssmDouble>(dim*numnodes);
172  IssmDouble* Bprime = xNew<IssmDouble>(dim*numnodes);
173  IssmDouble* D = xNew<IssmDouble>(dim*dim);
174 
175  /*Retrieve all inputs and parameters*/
176  basalelement->GetVerticesCoordinates(&xyz_list);
177  basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
178  basalelement->FindParam(&stabilization,MasstransportStabilizationEnum);
179  Input2* vx_input=basalelement->GetInput2(VxEnum); _assert_(vx_input);
180  Input2* vy_input=NULL;
181  if(dim>1){vy_input = basalelement->GetInput2(VyEnum); _assert_(vy_input);}
182  h = basalelement->CharacteristicLength();
183 
184  /* Start looping on the number of gaussian points: */
185  Gauss* gauss=basalelement->NewGauss(2);
186  for(int ig=gauss->begin();ig<gauss->end();ig++){
187  gauss->GaussPoint(ig);
188 
189  basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
190  basalelement->NodalFunctions(basis,gauss);
191 
192  vx_input->GetInputValue(&vx,gauss);
193  if(dim==2) vy_input->GetInputValue(&vy,gauss);
194 
195  D_scalar=gauss->weight*Jdet;
196  TripleMultiply(basis,1,numnodes,1,
197  &D_scalar,1,1,0,
198  basis,1,numnodes,0,
199  &Ke->values[0],1);
200 
201  GetB(B,basalelement,dim,xyz_list,gauss);
202  GetBprime(Bprime,basalelement,dim,xyz_list,gauss);
203 
204  D_scalar=dt*gauss->weight*Jdet;
205  for(int i=0;i<dim*dim;i++) D[i]=0.;
206  D[0] = D_scalar*vx;
207  if(dim==2) D[1*dim+1] = D_scalar*vy;
208 
209  TripleMultiply(B,dim,numnodes,1,
210  D,dim,dim,0,
211  Bprime,dim,numnodes,0,
212  &Ke->values[0],1);
213 
214  if(stabilization==2){
215  /*Streamline upwinding*/
216  if(dim==1){
217  vel=fabs(vx)+1.e-8;
218  D[0] = h/(2.*vel)*vx*vx;
219  }
220  else{
221  vel=sqrt(vx*vx+vy*vy)+1.e-8;
222  D[0*dim+0]=h/(2*vel)*vx*vx;
223  D[1*dim+0]=h/(2*vel)*vy*vx;
224  D[0*dim+1]=h/(2*vel)*vx*vy;
225  D[1*dim+1]=h/(2*vel)*vy*vy;
226  }
227  }
228  else if(stabilization==1){
229  /*SSA*/
230  if(dim==1){
231  vx_input->GetInputAverage(&vx);
232  D[0]=h/2.*fabs(vx);
233  }
234  else{
235  vx_input->GetInputAverage(&vx);
236  vy_input->GetInputAverage(&vy);
237  D[0*dim+0]=h/2.0*fabs(vx);
238  D[1*dim+1]=h/2.0*fabs(vy);
239  }
240  }
241  if(stabilization==1 || stabilization==2){
242  for(int i=0;i<dim*dim;i++) D[i]=D_scalar*D[i];
243  TripleMultiply(Bprime,dim,numnodes,1,
244  D,dim,dim,0,
245  Bprime,dim,numnodes,0,
246  &Ke->values[0],1);
247  }
248  }
249 
250  /*Clean up and return*/
251  xDelete<IssmDouble>(xyz_list);
252  xDelete<IssmDouble>(basis);
253  xDelete<IssmDouble>(B);
254  xDelete<IssmDouble>(Bprime);
255  xDelete<IssmDouble>(D);
256  delete gauss;
257  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
258  return Ke;
259 }/*}}}*/
260 ElementVector* FreeSurfaceBaseAnalysis::CreatePVector(Element* element){/*{{{*/
261  /*Intermediaries*/
262  int domaintype,dim;
263  IssmDouble Jdet,dt;
264  IssmDouble gmb,fmb,mb,bed,phi,vz;
265  Element* basalelement = NULL;
266  IssmDouble *xyz_list = NULL;
267 
268  /*Get basal element*/
269  element->FindParam(&domaintype,DomainTypeEnum);
270  switch(domaintype){
271  case Domain2DhorizontalEnum:
272  basalelement = element;
273  dim = 2;
274  break;
275  case Domain2DverticalEnum:
276  if(!element->IsOnBase()) return NULL;
277  basalelement = element->SpawnBasalElement();
278  dim = 1;
279  break;
280  case Domain3DEnum:
281  if(!element->IsOnBase()) return NULL;
282  basalelement = element->SpawnBasalElement();
283  dim = 2;
284  break;
285  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
286  }
287 
288  /*Fetch number of nodes and dof for this finite element*/
289  int numnodes = basalelement->GetNumberOfNodes();
290 
291  /*Initialize Element vector and other vectors*/
292  ElementVector* pe = basalelement->NewElementVector();
293  IssmDouble* basis = xNew<IssmDouble>(numnodes);
294 
295  /*Retrieve all inputs and parameters*/
296  basalelement->GetVerticesCoordinates(&xyz_list);
297  basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
298  Input2* groundedice_input = basalelement->GetInput2(MaskOceanLevelsetEnum); _assert_(groundedice_input);
299  Input2* gmb_input = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(gmb_input);
300  Input2* fmb_input = basalelement->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(fmb_input);
301  Input2* base_input = basalelement->GetInput2(BaseEnum); _assert_(base_input);
302  Input2* vz_input = NULL;
303  switch(dim){
304  case 1: vz_input = basalelement->GetInput2(VyEnum); _assert_(vz_input); break;
305  case 2: vz_input = basalelement->GetInput2(VzEnum); _assert_(vz_input); break;
306  default: _error_("not implemented");
307  }
308 
309  /* Start looping on the number of gaussian points: */
310  Gauss* gauss=basalelement->NewGauss(2);
311  for(int ig=gauss->begin();ig<gauss->end();ig++){
312  gauss->GaussPoint(ig);
313 
314  basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
315  basalelement->NodalFunctions(basis,gauss);
316 
317  vz_input->GetInputValue(&vz,gauss);
318  gmb_input->GetInputValue(&gmb,gauss);
319  fmb_input->GetInputValue(&fmb,gauss);
320  base_input->GetInputValue(&bed,gauss);
321  groundedice_input->GetInputValue(&phi,gauss);
322  if(phi>0) mb=gmb;
323  else mb=fmb;
324 
325  for(int i=0;i<numnodes;i++) pe->values[i]+=Jdet*gauss->weight*(bed+dt*(mb) + dt*vz)*basis[i];
326  }
327 
328  /*Clean up and return*/
329  xDelete<IssmDouble>(xyz_list);
330  xDelete<IssmDouble>(basis);
331  delete gauss;
332  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
333  return pe;
334 
335 }/*}}}*/
336 void FreeSurfaceBaseAnalysis::GetB(IssmDouble* B,Element* element,int dim,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
337  /*Compute B matrix. B=[B1 B2 B3] where Bi is of size 3*2.
338  * For node i, Bi can be expressed in the actual coordinate system
339  * by:
340  * Bi=[ N ]
341  * [ N ]
342  * where N is the finiteelement function for node i.
343  *
344  * We assume B_prog has been allocated already, of size: 2x(1*numnodes)
345  */
346 
347  /*Fetch number of nodes for this finite element*/
348  int numnodes = element->GetNumberOfNodes();
349 
350  /*Get nodal functions*/
351  IssmDouble* basis=xNew<IssmDouble>(numnodes);
352  element->NodalFunctions(basis,gauss);
353 
354  /*Build B: */
355  for(int i=0;i<numnodes;i++){
356  for(int j=0;j<dim;j++){
357  B[numnodes*j+i] = basis[i];
358  }
359  }
360 
361  /*Clean-up*/
362  xDelete<IssmDouble>(basis);
363 }/*}}}*/
364 void FreeSurfaceBaseAnalysis::GetBprime(IssmDouble* Bprime,Element* element,int dim,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
365  /*Compute B' matrix. B'=[B1' B2' B3'] where Bi' is of size 3*2.
366  * For node i, Bi' can be expressed in the actual coordinate system
367  * by:
368  * Bi_prime=[ dN/dx ]
369  * [ dN/dy ]
370  * where N is the finiteelement function for node i.
371  *
372  * We assume B' has been allocated already, of size: 3x(2*numnodes)
373  */
374 
375  /*Fetch number of nodes for this finite element*/
376  int numnodes = element->GetNumberOfNodes();
377 
378  /*Get nodal functions derivatives*/
379  IssmDouble* dbasis=xNew<IssmDouble>(dim*numnodes);
380  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
381 
382  /*Build B': */
383  for(int i=0;i<numnodes;i++){
384  for(int j=0;j<dim;j++){
385  Bprime[numnodes*j+i] = dbasis[j*numnodes+i];
386  }
387  }
388 
389  /*Clean-up*/
390  xDelete<IssmDouble>(dbasis);
391 
392 }/*}}}*/
393 void FreeSurfaceBaseAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
394  _error_("not implemented yet");
395 }/*}}}*/
396 void FreeSurfaceBaseAnalysis::GradientJ(Vector<IssmDouble>* gradient,Element* element,int control_type,int control_index){/*{{{*/
397  _error_("Not implemented yet");
398 }/*}}}*/
399 void FreeSurfaceBaseAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
400  element->InputUpdateFromSolutionOneDof(solution,BaseEnum);
401 }/*}}}*/
402 void FreeSurfaceBaseAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
403 
404  /*Intermediary*/
405  IssmDouble phi,isonbase,base;
406 
407  for(int i=0;i<femmodel->elements->Size();i++){
408 
409  Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
410  if(!element->IsOnBase()) continue;
411 
412  int numnodes = element->GetNumberOfNodes();
413  Input2* groundedice_input = element->GetInput2(MaskOceanLevelsetEnum); _assert_(groundedice_input);
414  Input2* onbase_input = element->GetInput2(MeshVertexonbaseEnum); _assert_(onbase_input);
415  Input2* base_input = element->GetInput2(BaseEnum); _assert_(base_input);
416 
417  Gauss* gauss=element->NewGauss();
418  for(int iv=0;iv<numnodes;iv++){
419  gauss->GaussNode(element->GetElementType(),iv);
420  onbase_input->GetInputValue(&isonbase,gauss);
421  if(isonbase==1.){
422  groundedice_input->GetInputValue(&phi,gauss);
423  if(phi>=0.){
424  base_input->GetInputValue(&base,gauss);
425  element->nodes[iv]->ApplyConstraint(0,base);
426  }
427  else{
428  element->nodes[iv]->DofInFSet(0);
429  }
430  }
431  }
432  delete gauss;
433  }
434 }/*}}}*/
DataSet::Size
int Size()
Definition: DataSet.cpp:399
BasalforcingsPicoBasinIdEnum
@ BasalforcingsPicoBasinIdEnum
Definition: EnumDefinitions.h:486
BasalforcingsOceanTempEnum
@ BasalforcingsOceanTempEnum
Definition: EnumDefinitions.h:485
BaseEnum
@ BaseEnum
Definition: EnumDefinitions.h:495
Element::GetElementType
virtual int GetElementType(void)=0
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
Nodes
Declaration of Nodes class.
Definition: Nodes.h:19
Element::GetNumberOfNodes
virtual int GetNumberOfNodes(void)=0
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
FreeSurfaceBaseAnalysis::UpdateConstraints
void UpdateConstraints(FemModel *femmodel)
Definition: FreeSurfaceBaseAnalysis.cpp:402
MaskOceanLevelsetEnum
@ MaskOceanLevelsetEnum
Definition: EnumDefinitions.h:640
Parameters
Declaration of Parameters class.
Definition: Parameters.h:18
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
TimesteppingTimeStepEnum
@ TimesteppingTimeStepEnum
Definition: EnumDefinitions.h:433
Constraints
Declaration of Constraints class.
Definition: Constraints.h:13
Element::SpawnBasalElement
virtual Element * SpawnBasalElement(void)=0
FreeSurfaceBaseAnalysis::GetBprime
void GetBprime(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: FreeSurfaceBaseAnalysis.cpp:364
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
Elements
Declaration of Elements class.
Definition: Elements.h:17
TripleMultiply
int TripleMultiply(IssmDouble *a, int nrowa, int ncola, int itrna, IssmDouble *b, int nrowb, int ncolb, int itrnb, IssmDouble *c, int nrowc, int ncolc, int itrnc, IssmDouble *d, int iaddd)
Definition: MatrixUtils.cpp:20
MismipFloatingMeltRateEnum
@ MismipFloatingMeltRateEnum
Definition: EnumDefinitions.h:1190
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
FreeSurfaceBaseAnalysisEnum
@ FreeSurfaceBaseAnalysisEnum
Definition: EnumDefinitions.h:1071
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
BasalforcingsPicoEnum
@ BasalforcingsPicoEnum
Definition: EnumDefinitions.h:990
MasstransportStabilizationEnum
@ MasstransportStabilizationEnum
Definition: EnumDefinitions.h:249
Gauss::GaussNode
virtual void GaussNode(int finitelement, int iv)=0
BasalforcingsUpperwaterElevationEnum
@ BasalforcingsUpperwaterElevationEnum
Definition: EnumDefinitions.h:94
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
BasalforcingsDeepwaterMeltingRateEnum
@ BasalforcingsDeepwaterMeltingRateEnum
Definition: EnumDefinitions.h:62
IoModel::my_vertices
bool * my_vertices
Definition: IoModel.h:72
Element::GetInput2
virtual Input2 * GetInput2(int inputenum)=0
Element::DeleteMaterials
void DeleteMaterials(void)
Definition: Element.cpp:429
Element::nodes
Node ** nodes
Definition: Element.h:48
Element
Definition: Element.h:41
Element::NodalFunctions
virtual void NodalFunctions(IssmDouble *basis, Gauss *gauss)=0
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
Element::NewElementVector
ElementVector * NewElementVector(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2505
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
FreeSurfaceBaseAnalysis::GetSolutionFromInputs
void GetSolutionFromInputs(Vector< IssmDouble > *solution, Element *element)
Definition: FreeSurfaceBaseAnalysis.cpp:393
FreeSurfaceBaseAnalysis::CreateKMatrix
ElementMatrix * CreateKMatrix(Element *element)
Definition: FreeSurfaceBaseAnalysis.cpp:136
FreeSurfaceBaseAnalysis::GradientJ
void GradientJ(Vector< IssmDouble > *gradient, Element *element, int control_type, int control_index)
Definition: FreeSurfaceBaseAnalysis.cpp:396
BasalforcingsGroundediceMeltingRateEnum
@ BasalforcingsGroundediceMeltingRateEnum
Definition: EnumDefinitions.h:478
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
FreeSurfaceBaseAnalysis::CreateConstraints
void CreateConstraints(Constraints *constraints, IoModel *iomodel)
Definition: FreeSurfaceBaseAnalysis.cpp:8
FreeSurfaceBaseAnalysis::CreateDVector
ElementVector * CreateDVector(Element *element)
Definition: FreeSurfaceBaseAnalysis.cpp:129
Penpair
Definition: Penpair.h:16
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
FreeSurfaceBaseAnalysis::GetB
void GetB(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: FreeSurfaceBaseAnalysis.cpp:336
Element::NewGauss
virtual Gauss * NewGauss(void)=0
FloatingMeltRateEnum
@ FloatingMeltRateEnum
Definition: EnumDefinitions.h:1069
FreeSurfaceBaseAnalysis::UpdateParameters
void UpdateParameters(Parameters *parameters, IoModel *iomodel, int solution_enum, int analysis_enum)
Definition: FreeSurfaceBaseAnalysis.cpp:122
BasalforcingsOceanSalinityEnum
@ BasalforcingsOceanSalinityEnum
Definition: EnumDefinitions.h:484
VzEnum
@ VzEnum
Definition: EnumDefinitions.h:853
Element::InputUpdateFromSolutionOneDof
virtual void InputUpdateFromSolutionOneDof(IssmDouble *solution, int inputenum)=0
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
LinearFloatingMeltRateEnum
@ LinearFloatingMeltRateEnum
Definition: EnumDefinitions.h:1143
BeckmannGoosseFloatingMeltRateEnum
@ BeckmannGoosseFloatingMeltRateEnum
Definition: EnumDefinitions.h:991
MantlePlumeGeothermalFluxEnum
@ MantlePlumeGeothermalFluxEnum
Definition: EnumDefinitions.h:1158
BasalforcingsFloatingiceMeltingRateEnum
@ BasalforcingsFloatingiceMeltingRateEnum
Definition: EnumDefinitions.h:476
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
FreeSurfaceBaseAnalysis::Core
void Core(FemModel *femmodel)
Definition: FreeSurfaceBaseAnalysis.cpp:126
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
BasalforcingsPicoOverturningCoeffEnum
@ BasalforcingsPicoOverturningCoeffEnum
Definition: EnumDefinitions.h:488
FreeSurfaceBaseAnalysis::CreateJacobianMatrix
ElementMatrix * CreateJacobianMatrix(Element *element)
Definition: FreeSurfaceBaseAnalysis.cpp:133
SpatialLinearFloatingMeltRateEnum
@ SpatialLinearFloatingMeltRateEnum
Definition: EnumDefinitions.h:1278
SurfaceEnum
@ SurfaceEnum
Definition: EnumDefinitions.h:823
IoModel::FetchData
void FetchData(bool *pboolean, const char *data_name)
Definition: IoModel.cpp:933
Inputs2
Declaration of Inputs class.
Definition: Inputs2.h:23
IoModel::domaindim
int domaindim
Definition: IoModel.h:77
FreeSurfaceBaseAnalysis::DofsPerNode
int DofsPerNode(int **doflist, int domaintype, int approximation)
Definition: FreeSurfaceBaseAnalysis.cpp:54
FreeSurfaceBaseAnalysis::CreatePVector
ElementVector * CreatePVector(Element *element)
Definition: FreeSurfaceBaseAnalysis.cpp:260
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
BasalforcingsIsmip6Enum
@ BasalforcingsIsmip6Enum
Definition: EnumDefinitions.h:989
FemModel::elements
Elements * elements
Definition: FemModel.h:44
Input2
Definition: Input2.h:18
FemModel
Definition: FemModel.h:31
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
FreeSurfaceBaseAnalysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: FreeSurfaceBaseAnalysis.cpp:48
BasalforcingsIsmip6BasinIdEnum
@ BasalforcingsIsmip6BasinIdEnum
Definition: EnumDefinitions.h:480
Loads
Declaration of Loads class.
Definition: Loads.h:16
FreeSurfaceBaseAnalysis::InputUpdateFromSolution
void InputUpdateFromSolution(IssmDouble *solution, Element *element)
Definition: FreeSurfaceBaseAnalysis.cpp:399
FreeSurfaceBaseAnalysis::UpdateElements
void UpdateElements(Elements *elements, Inputs2 *inputs2, IoModel *iomodel, int analysis_counter, int analysis_type)
Definition: FreeSurfaceBaseAnalysis.cpp:57
BasalforcingsDeepwaterElevationEnum
@ BasalforcingsDeepwaterElevationEnum
Definition: EnumDefinitions.h:61
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Node::DofInFSet
void DofInFSet(int dof)
Definition: Node.cpp:694
Gauss::begin
virtual int begin(void)=0
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
Element::CharacteristicLength
virtual IssmDouble CharacteristicLength(void)=0
VxEnum
@ VxEnum
Definition: EnumDefinitions.h:846
MeshVertexonsurfaceEnum
@ MeshVertexonsurfaceEnum
Definition: EnumDefinitions.h:655
Element::JacobianDeterminant
virtual void JacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)=0
Gauss::GaussPoint
virtual void GaussPoint(int ig)=0
Element::Update
virtual void Update(Inputs2 *inputs2, int index, IoModel *iomodel, int analysis_counter, int analysis_type, int finite_element)=0
IoModel::FetchDataToInput
void FetchDataToInput(Inputs2 *inputs2, Elements *elements, const char *vector_name, int input_enum)
Definition: IoModel.cpp:1651
Node::ApplyConstraint
void ApplyConstraint(int dof, IssmDouble value)
Definition: Node.cpp:646
ElementVector
Definition: ElementVector.h:20
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
IoModel
Definition: IoModel.h:48
FreeSurfaceBaseAnalysis.h
: header file for generic external result object
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
ElementMatrix
Definition: ElementMatrix.h:19
Vector< IssmDouble >
Input2::GetInputAverage
virtual void GetInputAverage(IssmDouble *pvalue)
Definition: Input2.h:33
FreeSurfaceBaseAnalysis::CreateLoads
void CreateLoads(Loads *loads, IoModel *iomodel)
Definition: FreeSurfaceBaseAnalysis.cpp:10
Gauss
Definition: Gauss.h:8
Element::NodalFunctionsDerivatives
virtual void NodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
ElementMatrix::values
IssmDouble * values
Definition: ElementMatrix.h:26
Element::NewElementMatrix
ElementMatrix * NewElementMatrix(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2497
femmodel
FemModel * femmodel
Definition: esmfbinders.cpp:16
Generated on Thu Jul 2 2020 08:09:15 for Ice Sheet System Model by   doxygen 1.8.19