Ice Sheet System Model  4.18
Code documentation
Public Member Functions
FreeSurfaceTopAnalysis Class Reference

#include <FreeSurfaceTopAnalysis.h>

Inheritance diagram for FreeSurfaceTopAnalysis:
Analysis

Public Member Functions

void CreateConstraints (Constraints *constraints, IoModel *iomodel)
 
void CreateLoads (Loads *loads, IoModel *iomodel)
 
void CreateNodes (Nodes *nodes, IoModel *iomodel, bool isamr=false)
 
int DofsPerNode (int **doflist, int domaintype, int approximation)
 
void UpdateElements (Elements *elements, Inputs2 *inputs2, IoModel *iomodel, int analysis_counter, int analysis_type)
 
void UpdateParameters (Parameters *parameters, IoModel *iomodel, int solution_enum, int analysis_enum)
 
void Core (FemModel *femmodel)
 
ElementVector * CreateDVector (Element *element)
 
ElementMatrix * CreateJacobianMatrix (Element *element)
 
ElementMatrix * CreateKMatrix (Element *element)
 
ElementVector * CreatePVector (Element *element)
 
void GetB (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBprime (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetSolutionFromInputs (Vector< IssmDouble > *solution, Element *element)
 
void GradientJ (Vector< IssmDouble > *gradient, Element *element, int control_type, int control_index)
 
void InputUpdateFromSolution (IssmDouble *solution, Element *element)
 
void UpdateConstraints (FemModel *femmodel)
 
- Public Member Functions inherited from Analysis
virtual ~Analysis ()
 

Detailed Description

Definition at line 11 of file FreeSurfaceTopAnalysis.h.

Member Function Documentation

◆ CreateConstraints()

void FreeSurfaceTopAnalysis::CreateConstraints ( Constraints *  constraints,
IoModel *  iomodel 
)
virtual

Implements Analysis.

Definition at line 8 of file FreeSurfaceTopAnalysis.cpp.

8  {/*{{{*/
9 }/*}}}*/

◆ CreateLoads()

void FreeSurfaceTopAnalysis::CreateLoads ( Loads *  loads,
IoModel *  iomodel 
)
virtual

Implements Analysis.

Definition at line 10 of file FreeSurfaceTopAnalysis.cpp.

10  {/*{{{*/
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 }/*}}}*/

◆ CreateNodes()

void FreeSurfaceTopAnalysis::CreateNodes ( Nodes *  nodes,
IoModel *  iomodel,
bool  isamr = false 
)
virtual

Implements Analysis.

Definition at line 48 of file FreeSurfaceTopAnalysis.cpp.

48  {/*{{{*/
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 }/*}}}*/

◆ DofsPerNode()

int FreeSurfaceTopAnalysis::DofsPerNode ( int **  doflist,
int  domaintype,
int  approximation 
)
virtual

Implements Analysis.

Definition at line 54 of file FreeSurfaceTopAnalysis.cpp.

54  {/*{{{*/
55  return 1;
56 }/*}}}*/

◆ UpdateElements()

void FreeSurfaceTopAnalysis::UpdateElements ( Elements *  elements,
Inputs2 *  inputs2,
IoModel *  iomodel,
int  analysis_counter,
int  analysis_type 
)
virtual

Implements Analysis.

Definition at line 57 of file FreeSurfaceTopAnalysis.cpp.

57  {/*{{{*/
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 }/*}}}*/

◆ UpdateParameters()

void FreeSurfaceTopAnalysis::UpdateParameters ( Parameters *  parameters,
IoModel *  iomodel,
int  solution_enum,
int  analysis_enum 
)
virtual

Implements Analysis.

Definition at line 98 of file FreeSurfaceTopAnalysis.cpp.

98  {/*{{{*/
99 }/*}}}*/

◆ Core()

void FreeSurfaceTopAnalysis::Core ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 102 of file FreeSurfaceTopAnalysis.cpp.

102  {/*{{{*/
103  _error_("not implemented");
104 }/*}}}*/

◆ CreateDVector()

ElementVector * FreeSurfaceTopAnalysis::CreateDVector ( Element *  element)
virtual

Implements Analysis.

Definition at line 105 of file FreeSurfaceTopAnalysis.cpp.

105  {/*{{{*/
106  /*Default, return NULL*/
107  return NULL;
108 }/*}}}*/

◆ CreateJacobianMatrix()

ElementMatrix * FreeSurfaceTopAnalysis::CreateJacobianMatrix ( Element *  element)
virtual

Implements Analysis.

Definition at line 109 of file FreeSurfaceTopAnalysis.cpp.

109  {/*{{{*/
110 _error_("Not implemented");
111 }/*}}}*/

◆ CreateKMatrix()

ElementMatrix * FreeSurfaceTopAnalysis::CreateKMatrix ( Element *  element)
virtual

Implements Analysis.

Definition at line 112 of file FreeSurfaceTopAnalysis.cpp.

112  {/*{{{*/
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 }/*}}}*/

◆ CreatePVector()

ElementVector * FreeSurfaceTopAnalysis::CreatePVector ( Element *  element)
virtual

Implements Analysis.

Definition at line 237 of file FreeSurfaceTopAnalysis.cpp.

237  {/*{{{*/
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 }/*}}}*/

◆ GetB()

void FreeSurfaceTopAnalysis::GetB ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 308 of file FreeSurfaceTopAnalysis.cpp.

308  {/*{{{*/
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 }/*}}}*/

◆ GetBprime()

void FreeSurfaceTopAnalysis::GetBprime ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 336 of file FreeSurfaceTopAnalysis.cpp.

336  {/*{{{*/
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 }/*}}}*/

◆ GetSolutionFromInputs()

void FreeSurfaceTopAnalysis::GetSolutionFromInputs ( Vector< IssmDouble > *  solution,
Element *  element 
)
virtual

Implements Analysis.

Definition at line 365 of file FreeSurfaceTopAnalysis.cpp.

365  {/*{{{*/
366  _error_("not implemented yet");
367 }/*}}}*/

◆ GradientJ()

void FreeSurfaceTopAnalysis::GradientJ ( Vector< IssmDouble > *  gradient,
Element *  element,
int  control_type,
int  control_index 
)
virtual

Implements Analysis.

Definition at line 368 of file FreeSurfaceTopAnalysis.cpp.

368  {/*{{{*/
369  _error_("Not implemented yet");
370 }/*}}}*/

◆ InputUpdateFromSolution()

void FreeSurfaceTopAnalysis::InputUpdateFromSolution ( IssmDouble *  solution,
Element *  element 
)
virtual

Implements Analysis.

Definition at line 371 of file FreeSurfaceTopAnalysis.cpp.

371  {/*{{{*/
372 
373  element->InputUpdateFromSolutionOneDof(solution,SurfaceEnum);
374 }/*}}}*/

◆ UpdateConstraints()

void FreeSurfaceTopAnalysis::UpdateConstraints ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 375 of file FreeSurfaceTopAnalysis.cpp.

375  {/*{{{*/
376  /*Default, do nothing*/
377  return;
378 }/*}}}*/
The documentation for this class was generated from the following files:
FreeSurfaceTopAnalysisEnum
@ FreeSurfaceTopAnalysisEnum
Definition: EnumDefinitions.h:1072
SmbMassBalanceEnum
@ SmbMassBalanceEnum
Definition: EnumDefinitions.h:748
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
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
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
TimesteppingTimeStepEnum
@ TimesteppingTimeStepEnum
Definition: EnumDefinitions.h:433
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
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
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
Penpair
Definition: Penpair.h:16
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
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
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
Input2
Definition: Input2.h:18
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
FreeSurfaceTopAnalysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: FreeSurfaceTopAnalysis.cpp:48
_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
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
Element::IsOnSurface
bool IsOnSurface()
Definition: Element.cpp:1981
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
ElementMatrix
Definition: ElementMatrix.h:19
Input2::GetInputAverage
virtual void GetInputAverage(IssmDouble *pvalue)
Definition: Input2.h:33
Gauss
Definition: Gauss.h:8
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
Generated on Thu Jul 2 2020 08:09:27 for Ice Sheet System Model by   doxygen 1.8.19