Ice Sheet System Model  4.18
Code documentation
FreeSurfaceTopAnalysis.cpp
Go to the documentation of this file.
1 #include "./FreeSurfaceTopAnalysis.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 FreeSurfaceTopAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
9 }/*}}}*/
10 void FreeSurfaceTopAnalysis::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 *nodeonsurface=NULL;
20  iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,"md.masstransport.vertex_pairing");
21  if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,"md.mesh.vertexonsurface");
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>(nodeonsurface[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonsurface[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(nodeonsurface,"md.mesh.vertexonsurface");
47 }/*}}}*/
48 void FreeSurfaceTopAnalysis::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,FreeSurfaceTopAnalysisEnum,P1Enum);
52  iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
53 }/*}}}*/
54 int FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/
55  return 1;
56 }/*}}}*/
57 void FreeSurfaceTopAnalysis::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  int smb_model;
63  int finiteelement = P1Enum;
64 
65  /*Fetch data needed: */
66  iomodel->FindConstant(&smb_model,"md.smb.model");
67 
68  /*Update elements: */
69  int counter=0;
70  for(int i=0;i<iomodel->numberofelements;i++){
71  if(iomodel->my_elements[i]){
72  Element* element=(Element*)elements->GetObjectByOffset(counter);
73  element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
74  counter++;
75  }
76  }
77 
78  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
79  iomodel->FetchDataToInput(inputs2,elements,"md.solidearth.sealevel",SealevelEnum,0);
80  iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
81  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
82  if(iomodel->domaintype!=Domain2DhorizontalEnum){
83  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
84  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
85  }
86  if(iomodel->domaindim==3){
87  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
88  }
89  switch(smb_model){
90  case SMBforcingEnum:
91  iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum,0.);
92  break;
93  default:
94  /*Nothing for now*/
95  ;
96  }
97 }/*}}}*/
98 void FreeSurfaceTopAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
99 }/*}}}*/
100 
101 /*Finite Element Analysis*/
102 void FreeSurfaceTopAnalysis::Core(FemModel* femmodel){/*{{{*/
103  _error_("not implemented");
104 }/*}}}*/
105 ElementVector* FreeSurfaceTopAnalysis::CreateDVector(Element* element){/*{{{*/
106  /*Default, return NULL*/
107  return NULL;
108 }/*}}}*/
109 ElementMatrix* FreeSurfaceTopAnalysis::CreateJacobianMatrix(Element* element){/*{{{*/
110 _error_("Not implemented");
111 }/*}}}*/
112 ElementMatrix* FreeSurfaceTopAnalysis::CreateKMatrix(Element* element){/*{{{*/
113 
114  /*Intermediaries*/
115  int domaintype,dim,stabilization;
116  Element* topelement = NULL;
117  IssmDouble *xyz_list = NULL;
118  IssmDouble Jdet,D_scalar,dt,h;
119  IssmDouble vel,vx,vy;
120 
121  /*Get top element*/
122  element->FindParam(&domaintype,DomainTypeEnum);
123  switch(domaintype){
124  case Domain2DhorizontalEnum:
125  topelement = element;
126  dim = 2;
127  break;
128  case Domain2DverticalEnum:
129  if(!element->IsOnSurface()) return NULL;
130  topelement = element->SpawnTopElement();
131  dim = 1;
132  break;
133  case Domain3DEnum:
134  if(!element->IsOnSurface()) return NULL;
135  topelement = element->SpawnTopElement();
136  dim = 2;
137  break;
138  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
139  }
140 
141  /*Fetch number of nodes and dof for this finite element*/
142  int numnodes = topelement->GetNumberOfNodes();
143 
144  /*Initialize Element vector*/
145  ElementMatrix* Ke = topelement->NewElementMatrix(NoneApproximationEnum);
146  IssmDouble* basis = xNew<IssmDouble>(numnodes);
147  IssmDouble* B = xNew<IssmDouble>(dim*numnodes);
148  IssmDouble* Bprime = xNew<IssmDouble>(dim*numnodes);
149  IssmDouble* D = xNew<IssmDouble>(dim*dim);
150 
151  /*Retrieve all inputs and parameters*/
152  topelement->GetVerticesCoordinates(&xyz_list);
153  topelement->FindParam(&dt,TimesteppingTimeStepEnum);
154  topelement->FindParam(&stabilization,MasstransportStabilizationEnum);
155  Input2* vx_input=topelement->GetInput2(VxEnum); _assert_(vx_input);
156  Input2* vy_input=NULL;
157  if(dim>1){vy_input = topelement->GetInput2(VyEnum); _assert_(vy_input);}
158  h = topelement->CharacteristicLength();
159 
160  /* Start looping on the number of gaussian points: */
161  Gauss* gauss=topelement->NewGauss(2);
162  for(int ig=gauss->begin();ig<gauss->end();ig++){
163  gauss->GaussPoint(ig);
164 
165  topelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
166  topelement->NodalFunctions(basis,gauss);
167 
168  vx_input->GetInputValue(&vx,gauss);
169  if(dim==2) vy_input->GetInputValue(&vy,gauss);
170 
171  D_scalar=gauss->weight*Jdet;
172  TripleMultiply(basis,1,numnodes,1,
173  &D_scalar,1,1,0,
174  basis,1,numnodes,0,
175  &Ke->values[0],1);
176 
177  GetB(B,topelement,dim,xyz_list,gauss);
178  GetBprime(Bprime,topelement,dim,xyz_list,gauss);
179 
180  D_scalar=dt*gauss->weight*Jdet;
181  for(int i=0;i<dim*dim;i++) D[i]=0.;
182  D[0] = D_scalar*vx;
183  if(dim==2) D[1*dim+1]=D_scalar*vy;
184 
185  TripleMultiply(B,dim,numnodes,1,
186  D,dim,dim,0,
187  Bprime,dim,numnodes,0,
188  &Ke->values[0],1);
189 
190  if(stabilization==2){
191  /*Streamline upwinding*/
192  if(dim==1){
193  vel=fabs(vx)+1.e-8;
194  D[0] = h/(2.*vel)*vx*vx;
195  }
196  else{
197  vel=sqrt(vx*vx+vy*vy)+1.e-8;
198  D[0*dim+0]=h/(2*vel)*vx*vx;
199  D[1*dim+0]=h/(2*vel)*vy*vx;
200  D[0*dim+1]=h/(2*vel)*vx*vy;
201  D[1*dim+1]=h/(2*vel)*vy*vy;
202  }
203  }
204  else if(stabilization==1){
205  /*SSA*/
206  if(dim==1){
207  vx_input->GetInputAverage(&vx);
208  D[0]=h/2.*fabs(vx);
209  }
210  else{
211  vx_input->GetInputAverage(&vx);
212  vy_input->GetInputAverage(&vy);
213 
214  D[0*dim+0]=h/2.0*fabs(vx);
215  D[1*dim+1]=h/2.0*fabs(vy);
216  }
217  }
218  if(stabilization==1 || stabilization==2){
219  for(int i=0;i<dim*dim;i++) D[i]=D_scalar*D[i];
220  TripleMultiply(Bprime,dim,numnodes,1,
221  D,dim,dim,0,
222  Bprime,dim,numnodes,0,
223  &Ke->values[0],1);
224  }
225  }
226 
227  /*Clean up and return*/
228  xDelete<IssmDouble>(xyz_list);
229  xDelete<IssmDouble>(basis);
230  xDelete<IssmDouble>(B);
231  xDelete<IssmDouble>(Bprime);
232  xDelete<IssmDouble>(D);
233  delete gauss;
234  if(domaintype!=Domain2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
235  return Ke;
236 }/*}}}*/
237 ElementVector* FreeSurfaceTopAnalysis::CreatePVector(Element* element){/*{{{*/
238  /*Intermediaries*/
239  int domaintype,dim;
240  IssmDouble Jdet,dt;
241  IssmDouble ms,surface,vz;
242  Element* topelement = NULL;
243  IssmDouble *xyz_list = NULL;
244 
245  /*Get top element*/
246  element->FindParam(&domaintype,DomainTypeEnum);
247  switch(domaintype){
248  case Domain2DhorizontalEnum:
249  topelement = element;
250  dim = 2;
251  break;
252  case Domain2DverticalEnum:
253  if(!element->IsOnSurface()) return NULL;
254  topelement = element->SpawnTopElement();
255  dim = 1;
256  break;
257  case Domain3DEnum:
258  if(!element->IsOnSurface()) return NULL;
259  topelement = element->SpawnTopElement();
260  dim = 2;
261  break;
262  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
263  }
264 
265  /*Fetch number of nodes and dof for this finite element*/
266  int numnodes = topelement->GetNumberOfNodes();
267 
268  /*Initialize Element vector and other vectors*/
269  ElementVector* pe = topelement->NewElementVector();
270  IssmDouble* basis = xNew<IssmDouble>(numnodes);
271 
272  /*Retrieve all inputs and parameters*/
273  topelement->GetVerticesCoordinates(&xyz_list);
274  topelement->FindParam(&dt,TimesteppingTimeStepEnum);
275  Input2* ms_input = topelement->GetInput2(SmbMassBalanceEnum); _assert_(ms_input);
276  Input2* surface_input = topelement->GetInput2(SurfaceEnum); _assert_(surface_input);
277  Input2* vz_input = NULL;
278  switch(dim){
279  case 1: vz_input = topelement->GetInput2(VyEnum); _assert_(vz_input); break;
280  case 2: vz_input = topelement->GetInput2(VzEnum); _assert_(vz_input); break;
281  default: _error_("not implemented");
282  }
283 
284  /*Initialize mb_correction to 0, do not forget!:*/
285  /* Start looping on the number of gaussian points: */
286  Gauss* gauss=topelement->NewGauss(2);
287  for(int ig=gauss->begin();ig<gauss->end();ig++){
288  gauss->GaussPoint(ig);
289 
290  topelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
291  topelement->NodalFunctions(basis,gauss);
292 
293  ms_input->GetInputValue(&ms,gauss);
294  vz_input->GetInputValue(&vz,gauss);
295  surface_input->GetInputValue(&surface,gauss);
296 
297  for(int i=0;i<numnodes;i++) pe->values[i]+=Jdet*gauss->weight*(surface + dt*ms + dt*vz)*basis[i];
298  }
299 
300  /*Clean up and return*/
301  xDelete<IssmDouble>(xyz_list);
302  xDelete<IssmDouble>(basis);
303  delete gauss;
304  if(domaintype!=Domain2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
305  return pe;
306 
307 }/*}}}*/
308 void FreeSurfaceTopAnalysis::GetB(IssmDouble* B,Element* element,int dim,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
309  /*Compute B matrix. B=[B1 B2 B3] where Bi is of size 3*2.
310  * For node i, Bi can be expressed in the actual coordinate system
311  * by:
312  * Bi=[ N ]
313  * [ N ]
314  * where N is the finiteelement function for node i.
315  *
316  * We assume B_prog has been allocated already, of size: 2x(1*numnodes)
317  */
318 
319  /*Fetch number of nodes for this finite element*/
320  int numnodes = element->GetNumberOfNodes();
321 
322  /*Get nodal functions*/
323  IssmDouble* basis=xNew<IssmDouble>(numnodes);
324  element->NodalFunctions(basis,gauss);
325 
326  /*Build B: */
327  for(int i=0;i<numnodes;i++){
328  for(int j=0;j<dim;j++){
329  B[numnodes*j+i] = basis[i];
330  }
331  }
332 
333  /*Clean-up*/
334  xDelete<IssmDouble>(basis);
335 }/*}}}*/
336 void FreeSurfaceTopAnalysis::GetBprime(IssmDouble* Bprime,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_prime=[ dN/dx ]
341  * [ dN/dy ]
342  * where N is the finiteelement function for node i.
343  *
344  * We assume B' has been allocated already, of size: 3x(2*numnodes)
345  */
346 
347  /*Fetch number of nodes for this finite element*/
348  int numnodes = element->GetNumberOfNodes();
349 
350  /*Get nodal functions derivatives*/
351  IssmDouble* dbasis=xNew<IssmDouble>(dim*numnodes);
352  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
353 
354  /*Build B': */
355  for(int i=0;i<numnodes;i++){
356  for(int j=0;j<dim;j++){
357  Bprime[numnodes*j+i] = dbasis[j*numnodes+i];
358  }
359  }
360 
361  /*Clean-up*/
362  xDelete<IssmDouble>(dbasis);
363 
364 }/*}}}*/
365 void FreeSurfaceTopAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
366  _error_("not implemented yet");
367 }/*}}}*/
368 void FreeSurfaceTopAnalysis::GradientJ(Vector<IssmDouble>* gradient,Element* element,int control_type,int control_index){/*{{{*/
369  _error_("Not implemented yet");
370 }/*}}}*/
371 void FreeSurfaceTopAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
372 
373  element->InputUpdateFromSolutionOneDof(solution,SurfaceEnum);
374 }/*}}}*/
375 void FreeSurfaceTopAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
376  /*Default, do nothing*/
377  return;
378 }/*}}}*/
FreeSurfaceTopAnalysisEnum
@ FreeSurfaceTopAnalysisEnum
Definition: EnumDefinitions.h:1072
FreeSurfaceTopAnalysis::CreateLoads
void CreateLoads(Loads *loads, IoModel *iomodel)
Definition: FreeSurfaceTopAnalysis.cpp:10
FreeSurfaceTopAnalysis::CreateConstraints
void CreateConstraints(Constraints *constraints, IoModel *iomodel)
Definition: FreeSurfaceTopAnalysis.cpp:8
SmbMassBalanceEnum
@ SmbMassBalanceEnum
Definition: EnumDefinitions.h:748
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
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
Parameters
Declaration of Parameters class.
Definition: Parameters.h:18
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
FreeSurfaceTopAnalysis::CreateJacobianMatrix
ElementMatrix * CreateJacobianMatrix(Element *element)
Definition: FreeSurfaceTopAnalysis.cpp:109
TimesteppingTimeStepEnum
@ TimesteppingTimeStepEnum
Definition: EnumDefinitions.h:433
Constraints
Declaration of Constraints class.
Definition: Constraints.h:13
FreeSurfaceTopAnalysis::CreateKMatrix
ElementMatrix * CreateKMatrix(Element *element)
Definition: FreeSurfaceTopAnalysis.cpp:112
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
Elements
Declaration of Elements class.
Definition: Elements.h:17
FreeSurfaceTopAnalysis::GetSolutionFromInputs
void GetSolutionFromInputs(Vector< IssmDouble > *solution, Element *element)
Definition: FreeSurfaceTopAnalysis.cpp:365
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
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
MasstransportStabilizationEnum
@ MasstransportStabilizationEnum
Definition: EnumDefinitions.h:249
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
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
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
FreeSurfaceTopAnalysis.h
: header file for generic external result object
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
FreeSurfaceTopAnalysis::UpdateConstraints
void UpdateConstraints(FemModel *femmodel)
Definition: FreeSurfaceTopAnalysis.cpp:375
Penpair
Definition: Penpair.h:16
FreeSurfaceTopAnalysis::CreateDVector
ElementVector * CreateDVector(Element *element)
Definition: FreeSurfaceTopAnalysis.cpp:105
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
Element::NewGauss
virtual Gauss * NewGauss(void)=0
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
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
FreeSurfaceTopAnalysis::GetB
void GetB(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: FreeSurfaceTopAnalysis.cpp:308
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
FreeSurfaceTopAnalysis::GetBprime
void GetBprime(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: FreeSurfaceTopAnalysis.cpp:336
IoModel::domaindim
int domaindim
Definition: IoModel.h:77
FreeSurfaceTopAnalysis::InputUpdateFromSolution
void InputUpdateFromSolution(IssmDouble *solution, Element *element)
Definition: FreeSurfaceTopAnalysis.cpp:371
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
FreeSurfaceTopAnalysis::CreatePVector
ElementVector * CreatePVector(Element *element)
Definition: FreeSurfaceTopAnalysis.cpp:237
Input2
Definition: Input2.h:18
FemModel
Definition: FemModel.h:31
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
FreeSurfaceTopAnalysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: FreeSurfaceTopAnalysis.cpp:48
Loads
Declaration of Loads class.
Definition: Loads.h:16
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Element::SpawnTopElement
virtual Element * SpawnTopElement(void)=0
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
FreeSurfaceTopAnalysis::UpdateElements
void UpdateElements(Elements *elements, Inputs2 *inputs2, IoModel *iomodel, int analysis_counter, int analysis_type)
Definition: FreeSurfaceTopAnalysis.cpp:57
ElementVector
Definition: ElementVector.h:20
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
FreeSurfaceTopAnalysis::Core
void Core(FemModel *femmodel)
Definition: FreeSurfaceTopAnalysis.cpp:102
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
Element::IsOnSurface
bool IsOnSurface()
Definition: Element.cpp:1981
IoModel
Definition: IoModel.h:48
FreeSurfaceTopAnalysis::UpdateParameters
void UpdateParameters(Parameters *parameters, IoModel *iomodel, int solution_enum, int analysis_enum)
Definition: FreeSurfaceTopAnalysis.cpp:98
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
FreeSurfaceTopAnalysis::GradientJ
void GradientJ(Vector< IssmDouble > *gradient, Element *element, int control_type, int control_index)
Definition: FreeSurfaceTopAnalysis.cpp:368
Gauss
Definition: Gauss.h:8
FreeSurfaceTopAnalysis::DofsPerNode
int DofsPerNode(int **doflist, int domaintype, int approximation)
Definition: FreeSurfaceTopAnalysis.cpp:54
SMBforcingEnum
@ SMBforcingEnum
Definition: EnumDefinitions.h:1244
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