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

#include <HydrologyDCEfficientAnalysis.h>

Inheritance diagram for HydrologyDCEfficientAnalysis:
Analysis

Public Member Functions

int DofsPerNode (int **doflist, int domaintype, int approximation)
 
void UpdateParameters (Parameters *parameters, IoModel *iomodel, int solution_enum, int analysis_enum)
 
void UpdateElements (Elements *elements, Inputs2 *inputs2, IoModel *iomodel, int analysis_counter, int analysis_type)
 
void CreateNodes (Nodes *nodes, IoModel *iomodel, bool isamr=false)
 
void CreateConstraints (Constraints *constraints, IoModel *iomodel)
 
void CreateLoads (Loads *loads, IoModel *iomodel)
 
void InitZigZagCounter (FemModel *femmodel)
 
void ResetCounter (FemModel *femmodel)
 
void Core (FemModel *femmodel)
 
ElementVectorCreateDVector (Element *element)
 
ElementMatrixCreateJacobianMatrix (Element *element)
 
ElementMatrixCreateKMatrix (Element *element)
 
ElementVectorCreatePVector (Element *element)
 
void GetB (IssmDouble *B, Element *element, 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)
 
IssmDouble EplStoring (Element *element, Gauss *gauss, Input2 *epl_thick_input, Input2 *epl_head_input, Input2 *base_input)
 
IssmDouble EplTransmitivity (Element *element, Gauss *gauss, Input2 *epl_thick_input, Input2 *epl_head_input, Input2 *base_input)
 
void GetHydrologyDCInefficientHmax (IssmDouble *ph_max, Element *element, Node *innode)
 
IssmDouble GetHydrologyKMatrixTransfer (Element *element)
 
IssmDouble GetHydrologyPVectorTransfer (Element *element, Gauss *gauss, Input2 *sed_head_input)
 
void ComputeEPLThickness (FemModel *femmodel)
 
void HydrologyEPLGetMask (Vector< IssmDouble > *vec_mask, Vector< IssmDouble > *recurence, Element *element)
 
void HydrologyEPLGetActive (Vector< IssmDouble > *active_vec, Element *element)
 
- Public Member Functions inherited from Analysis
virtual ~Analysis ()
 

Detailed Description

Definition at line 12 of file HydrologyDCEfficientAnalysis.h.

Member Function Documentation

◆ DofsPerNode()

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

Implements Analysis.

Definition at line 8 of file HydrologyDCEfficientAnalysis.cpp.

8  {/*{{{*/
9  return 1;
10 }/*}}}*/

◆ UpdateParameters()

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

Implements Analysis.

Definition at line 11 of file HydrologyDCEfficientAnalysis.cpp.

11  {/*{{{*/
12 
13  int hydrology_model;
14  int eplflip_lock;
15  int eplthickcomp;
16  bool isefficientlayer;
17  /*retrieve some parameters: */
18  iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
19 
20  /*Now, do we really want DC?*/
21  if(hydrology_model!=HydrologydcEnum) return;
22 
23  /*Do we want an efficient layer*/
24  iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
25 
26  /*If not return*/
27  if(!isefficientlayer) return;
28 
29  /*If yes, initialize a flip flop counter*/
30  iomodel->FetchData(&eplflip_lock,"md.hydrology.eplflip_lock");
31  parameters->AddObject(new IntParam(HydrologydcEplflipLockEnum,eplflip_lock));
32 
33  iomodel->FetchData(&eplthickcomp,"md.hydrology.epl_thick_comp");
34  parameters->AddObject(new IntParam(HydrologydcEplThickCompEnum,eplthickcomp));
35 }/*}}}*/

◆ UpdateElements()

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

Implements Analysis.

Definition at line 36 of file HydrologyDCEfficientAnalysis.cpp.

36  {/*{{{*/
37 
38  bool isefficientlayer;
39  int hydrology_model;
40 
41  /*Now, do we really want DC?*/
42  iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
43  if(hydrology_model!=HydrologydcEnum) return;
44 
45  /*Do we want an efficient layer*/
46  iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
47  if(!isefficientlayer) return;
48 
49  /*Update elements: */
50  int counter=0;
51  for(int i=0;i<iomodel->numberofelements;i++){
52  if(iomodel->my_elements[i]){
53  Element* element=(Element*)elements->GetObjectByOffset(counter);
54  element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
55  counter++;
56  }
57  }
58  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
59  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
60  iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
61  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.epl_head",EplHeadSubstepEnum);
62  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.sediment_head",SedimentHeadSubstepEnum);
63  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.epl_thickness",HydrologydcEplThicknessSubstepEnum);
64  iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.basal_moulin_input",HydrologydcBasalMoulinInputEnum);
65  if(iomodel->domaintype!=Domain2DhorizontalEnum){
66  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
67  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
68  }
69 }/*}}}*/

◆ CreateNodes()

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

Implements Analysis.

Definition at line 70 of file HydrologyDCEfficientAnalysis.cpp.

70  {/*{{{*/
71 
72  /*Now, do we really want DC?*/
73  int hydrology_model;
74  iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
75  if(hydrology_model!=HydrologydcEnum) return;
76 
77  /*Do we want an efficient layer*/
78  bool isefficientlayer;
79  iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
80  if(!isefficientlayer) return;
81 
82  if(iomodel->domaintype!=Domain2DhorizontalEnum){
83  iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
84  }
86  iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
87 }/*}}}*/

◆ CreateConstraints()

void HydrologyDCEfficientAnalysis::CreateConstraints ( Constraints constraints,
IoModel iomodel 
)
virtual

Implements Analysis.

Definition at line 88 of file HydrologyDCEfficientAnalysis.cpp.

88  {/*{{{*/
89 
90  /*Do we really want DC?*/
91  int hydrology_model;
92  iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
93  if(hydrology_model!=HydrologydcEnum) return;
94 
95  /*Do we want an efficient layer*/
96  bool isefficientlayer;
97  iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
98  if(!isefficientlayer) return;
99 
100  IoModelToConstraintsx(constraints,iomodel,"md.hydrology.spcepl_head",HydrologyDCEfficientAnalysisEnum,P1Enum);
101 }/*}}}*/

◆ CreateLoads()

void HydrologyDCEfficientAnalysis::CreateLoads ( Loads loads,
IoModel iomodel 
)
virtual

Implements Analysis.

Definition at line 102 of file HydrologyDCEfficientAnalysis.cpp.

102  {/*{{{*/
103 
104  /*Do we really want DC?*/
105  int hydrology_model;
106  iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
107  if(hydrology_model!=HydrologydcEnum) return;
108 
109  /*Do we want an efficient layer*/
110  bool isefficientlayer;
111  iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
112  if(!isefficientlayer) return;
113 
114  /*Fetch parameters: */
115  if(iomodel->domaintype==Domain3DEnum){
116  iomodel->FetchData(1,"md.mesh.vertexonbase");
117  }
118 
119  //Add moulin inputs as loads
121  for(int i=0;i<iomodel->numberofvertices;i++){
122  if (iomodel->domaintype!=Domain3DEnum){
123  /*keep only this partition's nodes:*/
124  if(iomodel->my_vertices[i]){
125  loads->AddObject(new Moulin(i+1,i,iomodel));
126  }
127  }
128  else if(reCast<int>(iomodel->Data("md.mesh.vertexonbase")[i])){
129  if(iomodel->my_vertices[i]){
130  loads->AddObject(new Moulin(i+1,i,iomodel));
131  }
132  }
133  }
134  iomodel->DeleteData(1,"md.mesh.vertexonbase");
135 }/*}}}*/

◆ InitZigZagCounter()

void HydrologyDCEfficientAnalysis::InitZigZagCounter ( FemModel femmodel)

Definition at line 136 of file HydrologyDCEfficientAnalysis.cpp.

136  {/*{{{*/
137 
138  int* eplzigzag_counter =NULL;
139  eplzigzag_counter=xNewZeroInit<int>(femmodel->nodes->Size());
141  xDelete<int>(eplzigzag_counter);
142 }/*}}}*/

◆ ResetCounter()

void HydrologyDCEfficientAnalysis::ResetCounter ( FemModel femmodel)

Definition at line 143 of file HydrologyDCEfficientAnalysis.cpp.

143  {/*{{{*/
144 
145  int* eplzigzag_counter=NULL;
146  femmodel->parameters->FindParam(&eplzigzag_counter,NULL,EplZigZagCounterEnum);
147  for(int i=0;i<femmodel->nodes->Size();i++){
148  eplzigzag_counter[i]=0;
149  }
151  xDelete<int>(eplzigzag_counter);
152 }/*}}}*/

◆ Core()

void HydrologyDCEfficientAnalysis::Core ( FemModel femmodel)
virtual

Implements Analysis.

Definition at line 155 of file HydrologyDCEfficientAnalysis.cpp.

155  {/*{{{*/
156  _error_("not implemented");
157 }/*}}}*/

◆ CreateDVector()

ElementVector * HydrologyDCEfficientAnalysis::CreateDVector ( Element element)
virtual

Implements Analysis.

Definition at line 158 of file HydrologyDCEfficientAnalysis.cpp.

158  {/*{{{*/
159  /*Default, return NULL*/
160  return NULL;
161 }/*}}}*/

◆ CreateJacobianMatrix()

ElementMatrix * HydrologyDCEfficientAnalysis::CreateJacobianMatrix ( Element element)
virtual

Implements Analysis.

Definition at line 162 of file HydrologyDCEfficientAnalysis.cpp.

162  {/*{{{*/
163 _error_("Not implemented");
164 }/*}}}*/

◆ CreateKMatrix()

ElementMatrix * HydrologyDCEfficientAnalysis::CreateKMatrix ( Element element)
virtual

Implements Analysis.

Definition at line 165 of file HydrologyDCEfficientAnalysis.cpp.

165  {/*{{{*/
166 
167  /*Intermediaries*/
168  bool active_element;
169  int domaintype;
170  Element* basalelement;
171 
172  /*Get basal element*/
173  element->FindParam(&domaintype,DomainTypeEnum);
174  switch(domaintype){
176  basalelement = element;
177  break;
178  case Domain3DEnum:
179  if(!element->IsOnBase()) return NULL;
180  basalelement = element->SpawnBasalElement();
181  break;
182  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
183  }
184 
185  basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
186 
187  /*Check that all nodes are active, else return empty matrix*/
188  if(!active_element) {
189  if(domaintype!=Domain2DhorizontalEnum){
190  basalelement->DeleteMaterials();
191  delete basalelement;
192  }
193  return NULL;
194  }
195 
196  /* Intermediaries */
197  IssmDouble D_scalar,Jdet,dt;
198  IssmDouble transfer;
199  IssmDouble epl_transmitivity;
200  IssmDouble epl_storing;
201  IssmDouble *xyz_list = NULL;
202 
203  /*Fetch number of nodes and dof for this finite element*/
204  int numnodes = basalelement->GetNumberOfNodes();
205 
206  /*Initialize Element vector*/
207  ElementMatrix* Ke = basalelement->NewElementMatrix();
208  IssmDouble* B = xNew<IssmDouble>(2*numnodes);
209  IssmDouble* basis = xNew<IssmDouble>(numnodes);
210  IssmDouble D[2][2]={0.};
211 
212  /*Retrieve all inputs and parameters*/
213  basalelement->GetVerticesCoordinates(&xyz_list);
214  basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
215  Input2* epl_thick_input = basalelement->GetInput2(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
216  Input2* epl_head_input = basalelement->GetInput2(EplHeadSubstepEnum); _assert_(epl_head_input);
217  Input2* base_input = basalelement->GetInput2(BaseEnum); _assert_(base_input);
218 
219  /* Start looping on the number of gaussian points: */
220  Gauss* gauss = basalelement->NewGauss(2);
221  for(int ig=gauss->begin();ig<gauss->end();ig++){
222  gauss ->GaussPoint(ig);
223  basalelement ->JacobianDeterminant(&Jdet,xyz_list,gauss);
224 
225  epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
226  epl_storing = EplStoring(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
227 
228  /*Diffusivity*/
229  D_scalar=epl_transmitivity*gauss->weight*Jdet;
230  //D_scalar=gauss->weight*Jdet;
231  if(dt!=0.) D_scalar=D_scalar*dt;
232  D[0][0]=D_scalar;
233  D[1][1]=D_scalar;
234  GetB(B,basalelement,xyz_list,gauss);
235  TripleMultiply(B,2,numnodes,1,
236  &D[0][0],2,2,0,
237  B,2,numnodes,0,
238  &Ke->values[0],1);
239 
240  /*Transient*/
241  if(dt!=0.){
242  basalelement->NodalFunctions(&basis[0],gauss);
243  D_scalar=epl_storing*gauss->weight*Jdet;
244  //D_scalar=(epl_storing/epl_transmitivity)*gauss->weight*Jdet;
245  TripleMultiply(basis,numnodes,1,0,
246  &D_scalar,1,1,0,
247  basis,1,numnodes,0,
248  &Ke->values[0],1);
249 
250  /*Transfer EPL part*/
251  transfer=GetHydrologyKMatrixTransfer(basalelement);
252  D_scalar=dt*transfer*gauss->weight*Jdet;
253  //D_scalar=dt*(transfer/epl_transmitivity)*gauss->weight*Jdet;
254  TripleMultiply(basis,numnodes,1,0,
255  &D_scalar,1,1,0,
256  basis,1,numnodes,0,
257  &Ke->values[0],1);
258  }
259  }
260 
261  /*Clean up and return*/
262  xDelete<IssmDouble>(xyz_list);
263  xDelete<IssmDouble>(basis);
264  xDelete<IssmDouble>(B);
265  delete gauss;
266  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
267  return Ke;
268 }/*}}}*/

◆ CreatePVector()

ElementVector * HydrologyDCEfficientAnalysis::CreatePVector ( Element element)
virtual

Implements Analysis.

Definition at line 269 of file HydrologyDCEfficientAnalysis.cpp.

269  {/*{{{*/
270 
271  /*Intermediaries*/
272  bool active_element;
273  int domaintype;
274  Element* basalelement;
275 
276  /*Get basal element*/
277  element->FindParam(&domaintype,DomainTypeEnum);
278  switch(domaintype){
280  basalelement = element;
281  break;
282  case Domain3DEnum:
283  if(!element->IsOnBase()) return NULL;
284  basalelement = element->SpawnBasalElement();
285  break;
286  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
287  }
288 
289  basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
290 
291  /*Check that all nodes are active, else return empty matrix*/
292  if(!active_element) {
293  if(domaintype!=Domain2DhorizontalEnum){
294  basalelement->DeleteMaterials();
295  delete basalelement;
296  }
297  return NULL;
298  }
299  /*Intermediaries */
300  int smb_model;
301  int smb_averaging;
302  int smbsubstepping;
303  int hydrologysubstepping;
304  IssmDouble dt,scalar,water_head;
305  IssmDouble water_load,transfer,runoff_value;
306  IssmDouble epl_storing,epl_transmitivity;
307  IssmDouble Jdet;
308  IssmDouble residual,connectivity;
309 
310  IssmDouble *xyz_list = NULL;
311  Input2 *old_wh_input = NULL;
312  Input2 *dummy_input = NULL;
313  Input2 *surface_runoff_input = NULL;
314 
315  /*Fetch number of nodes and dof for this finite element*/
316  int numnodes = basalelement->GetNumberOfNodes();
317  int numvertices = basalelement->GetNumberOfVertices();
318 
319  /*Initialize Element vector*/
320  ElementVector* pe = basalelement->NewElementVector();
321  IssmDouble* basis = xNew<IssmDouble>(numnodes);
322 
323  /*Retrieve all inputs and parameters*/
324  basalelement->GetVerticesCoordinates(&xyz_list);
325  basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
326  basalelement ->FindParam(&smb_model,SmbEnum);
327  basalelement->FindParam(&smb_averaging,SmbAveragingEnum);
328 
329  Input2* epl_thick_input = basalelement->GetInput2(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
330  Input2* sed_head_input = basalelement->GetInput2(SedimentHeadSubstepEnum); _assert_(sed_head_input);
331  Input2* epl_head_input = basalelement->GetInput2(EplHeadSubstepEnum); _assert_(epl_head_input);
332  Input2* basal_melt_input = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melt_input);
333  Input2* residual_input = basalelement->GetInput2(SedimentHeadResidualEnum); _assert_(residual_input);
334  Input2* base_input = basalelement->GetInput2(BaseEnum); _assert_(base_input);
335 
336  IssmDouble time;
337  basalelement->FindParam(&time,TimeEnum);
338 
339  if(dt!= 0.){
340  old_wh_input = basalelement->GetInput2(EplHeadOldEnum); _assert_(old_wh_input);
341  }
342  if(smb_model==SMBgradientscomponentsEnum){
343  basalelement->FindParam(&smbsubstepping,SmbStepsPerStepEnum);
344  basalelement->FindParam(&hydrologysubstepping,HydrologyStepsPerStepEnum);
345 
346  if(smbsubstepping==1){
347  //no substeping for the smb we take the result from there
348  dummy_input = basalelement->GetInput2(SmbRunoffEnum); _assert_(dummy_input);
349  }
350  else if(smbsubstepping>1 && smbsubstepping<=hydrologysubstepping){
351  //finer hydro stepping, we take the value at the needed time
352  dummy_input = basalelement->GetInput2(SmbRunoffTransientEnum, time); _assert_(dummy_input);
353  }
354  else{
355  //finer stepping in smb, we average the runoff from transient input
356  dummy_input = basalelement->GetInput2(SmbRunoffTransientEnum,time-dt,time,smb_averaging); _assert_(dummy_input);
357  }
358  surface_runoff_input=xDynamicCast<Input2*>(dummy_input); _assert_(surface_runoff_input);
359  }
360 
361  /* Start looping on the number of gaussian points: */
362  Gauss* gauss = basalelement->NewGauss(2);
363  for(int ig=gauss->begin();ig<gauss->end();ig++){
364  gauss->GaussPoint(ig);
365  basalelement ->JacobianDeterminant(&Jdet,xyz_list,gauss);
366  basalelement ->NodalFunctions(basis,gauss);
367  epl_storing = EplStoring(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
368  epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
369 
370  /*Loading term*/
371  basal_melt_input->GetInputValue(&water_load,gauss);
372  if(surface_runoff_input) surface_runoff_input->GetInputValue(&runoff_value,gauss);
373  else runoff_value = 0.;
374  scalar = Jdet*gauss->weight*(water_load+runoff_value);
375  //scalar = Jdet*gauss->weight*(water_load)/epl_transmitivity;
376  if(dt!=0.) scalar = scalar*dt;
377  for(int i=0;i<numnodes;i++)pe->values[i]+=scalar*basis[i];
378 
379  /*Transient and transfer terms*/
380  if(dt!=0.){
381  old_wh_input->GetInputValue(&water_head,gauss);
382  /*Dealing with the epl part of the transfer term*/
383  transfer=GetHydrologyPVectorTransfer(basalelement,gauss,sed_head_input);
384  scalar = Jdet*gauss->weight*((water_head*epl_storing)+(dt*transfer));
385  //scalar = Jdet*gauss->weight*((water_head*epl_storing)+(dt*transfer))/epl_transmitivity;
386  for(int i=0;i<numnodes;i++)pe->values[i]+=scalar*basis[i];
387  }
388  }
389  delete gauss;
390 
391  /* Add residual if necessary*/
392  gauss = basalelement->NewGauss();
393  for(int iv=0;iv<numvertices;iv++){
394  gauss->GaussVertex(iv);
395  epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
396  connectivity = IssmDouble(basalelement->VertexConnectivity(iv));
397  residual_input->GetInputValue(&residual,gauss);
398  pe->values[iv]+=residual/connectivity;
399  //pe->values[iv]+=residual/(epl_transmitivity*connectivity);
400  }
401  /*Clean up and return*/
402  xDelete<IssmDouble>(xyz_list);
403  xDelete<IssmDouble>(basis);
404  delete gauss;
405  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
406  return pe;
407 }/*}}}*/

◆ GetB()

void HydrologyDCEfficientAnalysis::GetB ( IssmDouble B,
Element element,
IssmDouble xyz_list,
Gauss gauss 
)

Definition at line 408 of file HydrologyDCEfficientAnalysis.cpp.

408  {/*{{{*/
409  /*Compute B matrix. B=[B1 B2 B3] where Bi is of size 3*2.
410  * For node i, Bi can be expressed in the actual coordinate system
411  * by:
412  * Bi=[ dN/dx ]
413  * [ dN/dy ]
414  * where N is the finiteelement function for node i.
415  *
416  * We assume B has been allocated already, of size: 3x(2*numnodes)
417  */
418 
419  /*Fetch number of nodes for this finite element*/
420  int numnodes = element->GetNumberOfNodes();
421 
422  /*Get nodal functions derivatives*/
423  IssmDouble* dbasis=xNew<IssmDouble>(2*numnodes);
424  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
425 
426  /*Build B: */
427  for(int i=0;i<numnodes;i++){
428  B[numnodes*0+i] = dbasis[0*numnodes+i];
429  B[numnodes*1+i] = dbasis[1*numnodes+i];
430  }
431 
432  /*Clean-up*/
433  xDelete<IssmDouble>(dbasis);
434 }/*}}}*/

◆ GetSolutionFromInputs()

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

Implements Analysis.

Definition at line 435 of file HydrologyDCEfficientAnalysis.cpp.

435  {/*{{{*/
437 }/*}}}*/

◆ GradientJ()

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

Implements Analysis.

Definition at line 438 of file HydrologyDCEfficientAnalysis.cpp.

438  {/*{{{*/
439  _error_("Not implemented yet");
440 }/*}}}*/

◆ InputUpdateFromSolution()

void HydrologyDCEfficientAnalysis::InputUpdateFromSolution ( IssmDouble solution,
Element element 
)
virtual

Implements Analysis.

Definition at line 441 of file HydrologyDCEfficientAnalysis.cpp.

441  {/*{{{*/
442  /*Intermediaries*/
443  int domaintype;
444  Element* basalelement=NULL;
445 
446  /*Get basal element*/
447  element->FindParam(&domaintype,DomainTypeEnum);
448  switch(domaintype){
450  basalelement = element;
451  break;
452  case Domain3DEnum:
453  if(!element->IsOnBase()) return;
454  basalelement = element->SpawnBasalElement();
455  break;
456  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
457  }
458  /*Intermediary*/
459  int* doflist = NULL;
460 
461  /*Fetch number of nodes for this finite element*/
462  int numnodes = basalelement->GetNumberOfNodes();
463 
464  /*Fetch dof list and allocate solution vector*/
465  basalelement->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
466  IssmDouble* eplHeads = xNew<IssmDouble>(numnodes);
467 
468  /*Use the dof list to index into the solution vector: */
469  /*If the EPL is not active we revert to the bedrock elevation when deactivating*/
470  for(int i=0;i<numnodes;i++){
471  eplHeads[i]=solution[doflist[i]];
472  if(xIsNan<IssmDouble>(eplHeads[i])) _error_("NaN found in solution vector");
473  if(xIsInf<IssmDouble>(eplHeads[i])) _error_("Inf found in solution vector");
474  }
475  /*Add input to the element: */
476  element->AddBasalInput2(EplHeadSubstepEnum,eplHeads,P1Enum);
477 
478  /*Free ressources:*/
479  xDelete<IssmDouble>(eplHeads);
480  xDelete<int>(doflist);
481  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
482 } /*}}}*/

◆ UpdateConstraints()

void HydrologyDCEfficientAnalysis::UpdateConstraints ( FemModel femmodel)
virtual

Implements Analysis.

Definition at line 483 of file HydrologyDCEfficientAnalysis.cpp.

483  {/*{{{*/
484  /*Default, do nothing*/
485  return;
486 }/*}}}*/

◆ EplStoring()

IssmDouble HydrologyDCEfficientAnalysis::EplStoring ( Element element,
Gauss gauss,
Input2 epl_thick_input,
Input2 epl_head_input,
Input2 base_input 
)

Definition at line 489 of file HydrologyDCEfficientAnalysis.cpp.

489  {/*{{{*/
490  IssmDouble epl_storing;
491  IssmDouble water_sheet,storing;
492  IssmDouble epl_thickness,prestep_head,base_elev;
493  IssmDouble rho_freshwater = element->FindParam(MaterialsRhoFreshwaterEnum);
494  IssmDouble g = element->FindParam(ConstantsGEnum);
495  IssmDouble epl_porosity = element->FindParam(HydrologydcEplPorosityEnum);
496  IssmDouble epl_compressibility = element->FindParam(HydrologydcEplCompressibilityEnum);
497  IssmDouble water_compressibility = element->FindParam(HydrologydcWaterCompressibilityEnum);
498 
499  epl_thick_input->GetInputValue(&epl_thickness,gauss);
500  epl_head_input->GetInputValue(&prestep_head,gauss);
501  base_input->GetInputValue(&base_elev,gauss);
502  water_sheet=max(0.0,(prestep_head-base_elev));
503  storing=rho_freshwater*g*epl_porosity*epl_thickness*(water_compressibility+(epl_compressibility/epl_porosity));
504 
505  /* //porosity for unconfined region */
506  /* if (water_sheet<=0.9*epl_thickness){ */
507  /* epl_storing=epl_porosity; */
508  /* } */
509  /* //continuity ramp */
510  /* else if((water_sheet<epl_thickness) && (water_sheet>0.9*epl_thickness)){ */
511  /* epl_storing=(epl_thickness-water_sheet)*(epl_porosity-storing)/(0.1*epl_thickness)+storing; */
512  /* } */
513  /* //storing coefficient for confined */
514  /* else{ */
515  /* epl_storing=storing; */
516  /* } */
517  /* return epl_storing; */
518  return storing;
519 }/*}}}*/

◆ EplTransmitivity()

IssmDouble HydrologyDCEfficientAnalysis::EplTransmitivity ( Element element,
Gauss gauss,
Input2 epl_thick_input,
Input2 epl_head_input,
Input2 base_input 
)

Definition at line 520 of file HydrologyDCEfficientAnalysis.cpp.

520  {/*{{{*/
521  IssmDouble epl_transmitivity;
522  IssmDouble water_sheet;
523  IssmDouble epl_thickness,base_elev,prestep_head;
524  IssmDouble epl_conductivity = element->FindParam(HydrologydcEplConductivityEnum);
525  epl_thick_input->GetInputValue(&epl_thickness,gauss);
526  epl_head_input->GetInputValue(&prestep_head,gauss);
527  base_input->GetInputValue(&base_elev,gauss);
528 
529  water_sheet=max(0.0,(prestep_head-base_elev));
530  epl_transmitivity=epl_conductivity*epl_thickness;
531  //epl_transmitivity=max(1.0e-6,(epl_conductivity*min(water_sheet,epl_thickness)));
532  return epl_transmitivity;
533 }/*}}}*/

◆ GetHydrologyDCInefficientHmax()

void HydrologyDCEfficientAnalysis::GetHydrologyDCInefficientHmax ( IssmDouble ph_max,
Element element,
Node innode 
)

Definition at line 534 of file HydrologyDCEfficientAnalysis.cpp.

534  {/*{{{*/
535 
536  int hmax_flag;
537  IssmDouble h_max;
538  IssmDouble rho_ice,rho_water;
539  IssmDouble thickness,bed;
540  /*Get the flag to the limitation method*/
541  element->FindParam(&hmax_flag,HydrologydcSedimentlimitFlagEnum);
542 
543  /*Switch between the different cases*/
544  switch(hmax_flag){
545  case 0:
546  h_max=1.0e+10;
547  break;
548  case 1:
549  element->FindParam(&h_max,HydrologydcSedimentlimitEnum);
550  break;
551  case 2:
552  /*Compute max*/
553  rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
554  rho_ice = element->FindParam(MaterialsRhoIceEnum);
555  element-> GetInputValue(&thickness,innode,ThicknessEnum);
556  element-> GetInputValue(&bed,innode,BaseEnum);
557  h_max=((rho_ice*thickness)/rho_water)+bed;
558  break;
559  case 3:
560  _error_("Using normal stress not supported yet");
561  break;
562  default:
563  _error_("no case higher than 3 for SedimentlimitFlag");
564  }
565  /*Assign output pointer*/
566  *ph_max=h_max;
567 }

◆ GetHydrologyKMatrixTransfer()

IssmDouble HydrologyDCEfficientAnalysis::GetHydrologyKMatrixTransfer ( Element element)

Definition at line 569 of file HydrologyDCEfficientAnalysis.cpp.

569  {/*{{{*/
570 
571  int transfermethod;
572  IssmDouble leakage,transfer;
573 
574  element->FindParam(&transfermethod,HydrologydcTransferFlagEnum);
575  /*Switch between the different transfer methods cases*/
576  switch(transfermethod){
577  case 0:
578  /*Just keepping the transfer to zero*/
579  transfer=0.0;
580  break;
581  case 1:
582  element->FindParam(&leakage,HydrologydcLeakageFactorEnum);
583  transfer=+leakage;
584  break;
585  default:
586  _error_("no case higher than 1 for the Transfer method");
587  }
588  return transfer;
589 }/*}}}*/

◆ GetHydrologyPVectorTransfer()

IssmDouble HydrologyDCEfficientAnalysis::GetHydrologyPVectorTransfer ( Element element,
Gauss gauss,
Input2 sed_head_input 
)

Definition at line 590 of file HydrologyDCEfficientAnalysis.cpp.

590  {/*{{{*/
591 
592  int transfermethod;
593  IssmDouble sediment_head;
594  IssmDouble leakage,transfer;
595 
596  element->FindParam(&transfermethod,HydrologydcTransferFlagEnum);
597  /*Switch between the different transfer methods cases*/
598  switch(transfermethod){
599  case 0:
600  /*Just keepping the transfer to zero*/
601  transfer=0.0;
602  break;
603  case 1:
604  _assert_(sed_head_input);
605  sed_head_input->GetInputValue(&sediment_head,gauss);
606  element->FindParam(&leakage,HydrologydcLeakageFactorEnum);
607  transfer=+sediment_head*leakage;
608  break;
609  default:
610  _error_("no case higher than 1 for the Transfer method");
611  }
612 
613  return transfer;
614 }/*}}}*/

◆ ComputeEPLThickness()

void HydrologyDCEfficientAnalysis::ComputeEPLThickness ( FemModel femmodel)

Definition at line 615 of file HydrologyDCEfficientAnalysis.cpp.

615  {/*{{{*/
616 
617  bool active_element;
618  int iseplthickcomp;
619  int domaintype;
620  IssmDouble dt,A;
621  IssmDouble EPLgrad2;
622  IssmDouble EPL_N;
623  IssmDouble opening,closing;
624 
627  if(iseplthickcomp==0) return;
628 
629  for(int j=0;j<femmodel->elements->Size();j++){
630 
632 
633  /*skip element if 3d and not on base*/
634  if(domaintype==Domain3DEnum && !element->IsOnBase()) continue;
635 
636  int numnodes = element->GetNumberOfNodes();
637  IssmDouble* thickness = xNew<IssmDouble>(numnodes);
638  IssmDouble* B = xNew<IssmDouble>(numnodes);
639  IssmDouble* n = xNew<IssmDouble>(numnodes);
640  IssmDouble* eplhead = xNew<IssmDouble>(numnodes);
641  IssmDouble* epl_slopeX = xNew<IssmDouble>(numnodes);
642  IssmDouble* epl_slopeY = xNew<IssmDouble>(numnodes);
643  IssmDouble* old_thickness = xNew<IssmDouble>(numnodes);
644  IssmDouble* ice_thickness = xNew<IssmDouble>(numnodes);
645  IssmDouble* bed = xNew<IssmDouble>(numnodes);
646 
647  element->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
648  element->FindParam(&dt,TimesteppingTimeStepEnum);
649 
650  /*For now, assuming just one way to compute EPL thickness*/
651  IssmDouble gravity = element->FindParam(ConstantsGEnum);
652  IssmDouble rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
653  IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum);
654  IssmDouble latentheat = element->FindParam(MaterialsLatentheatEnum);
655  IssmDouble epl_conductivity = element->FindParam(HydrologydcEplConductivityEnum);
658 
659  switch(domaintype){
661  case Domain3DEnum: element->GetInputListOnVertices(&B[0],MaterialsRheologyBEnum); break;
662  default: _error_("not Implemented Yet");
663  }
664 
665  element->GetInputListOnVertices(&eplhead[0],EplHeadSubstepEnum);
666  element->GetInputListOnVertices(&epl_slopeX[0],EplHeadSlopeXEnum);
667  element->GetInputListOnVertices(&epl_slopeY[0],EplHeadSlopeYEnum);
668  element->GetInputListOnVertices(&old_thickness[0],HydrologydcEplThicknessOldEnum);
669  element->GetInputListOnVertices(&ice_thickness[0],ThicknessEnum);
670  element->GetInputListOnVertices(&bed[0],BaseEnum);
672 
673  if(!active_element){
674  /*Keeping thickness to initial value if EPL is not active*/
675  for(int i=0;i<numnodes;i++){
676  thickness[i]=init_thick;
677  }
678  }
679  else{
680  for(int i=0;i<numnodes;i++){
681  A=pow(B[i],-n[i]);
682  /*Compute first the effective pressure in the EPL*/
683  EPL_N=gravity*((rho_ice*ice_thickness[i])-(rho_water*(eplhead[i]-bed[i])));
684  if(EPL_N<0.0)EPL_N=0.0;
685  /*Get then the square of the gradient of EPL heads*/
686  EPLgrad2 = (epl_slopeX[i]*epl_slopeX[i])+(epl_slopeY[i]*epl_slopeY[i]);
687  /*And proceed to the real thing*/
688  opening=(rho_water*gravity*epl_conductivity*EPLgrad2*dt)/(rho_ice*latentheat);
689  closing=(2.0*A*dt*pow(EPL_N,n[i]))/(pow(n[i],n[i]));
690  /*implicit*/
691  thickness[i] = old_thickness[i]/(1.0-opening+closing);
692  /*explicit*/
693  //thickness[i] = old_thickness[i]*(1.0+opening-closing);
694  /*centered*/
695  //thickness[i] = old_thickness[i]*(1.0+opening-closing)/(1.0-opening+closing);
696  /*Take care of otherthikening*/
697  if(thickness[i]>max_thick){
698  thickness[i] = max_thick;
699  }
700  }
701  }
702  element->AddInput2(HydrologydcEplThicknessSubstepEnum,thickness,element->GetElementType());
703  xDelete<IssmDouble>(thickness);
704  xDelete<IssmDouble>(eplhead);
705  xDelete<IssmDouble>(epl_slopeX);
706  xDelete<IssmDouble>(epl_slopeY);
707  xDelete<IssmDouble>(old_thickness);
708  xDelete<IssmDouble>(ice_thickness);
709  xDelete<IssmDouble>(bed);
710  xDelete<IssmDouble>(B);
711  xDelete<IssmDouble>(n);
712  }
713 }/*}}}*/

◆ HydrologyEPLGetMask()

void HydrologyDCEfficientAnalysis::HydrologyEPLGetMask ( Vector< IssmDouble > *  vec_mask,
Vector< IssmDouble > *  recurence,
Element element 
)

Definition at line 714 of file HydrologyDCEfficientAnalysis.cpp.

714  {/*{{{*/
715 
716  bool active_element;
717  int domaintype;
718  IssmDouble h_max;
719  IssmDouble sedheadmin;
720  Element* basalelement=NULL;
721 
722  /*Get basal element*/
723  element->FindParam(&domaintype,DomainTypeEnum);
724  switch(domaintype){
726  basalelement = element;
727  break;
728  case Domain3DEnum:
729  if(!element->IsOnBase()) return;
730  basalelement = element->SpawnBasalElement();
731  break;
732  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
733  }
734  /*Intermediaries*/
735  int numnodes =basalelement->GetNumberOfNodes();
736  IssmDouble* epl_thickness =xNew<IssmDouble>(numnodes);
737  IssmDouble* old_active =xNew<IssmDouble>(numnodes);
738  IssmDouble* sedhead =xNew<IssmDouble>(numnodes);
739  IssmDouble* eplhead =xNew<IssmDouble>(numnodes);
740  IssmDouble* residual =xNew<IssmDouble>(numnodes);
741  IssmDouble* base =xNew<IssmDouble>(numnodes);
742 
743  IssmDouble init_thick =basalelement->FindParam(HydrologydcEplInitialThicknessEnum);
744  IssmDouble colapse_thick =basalelement->FindParam(HydrologydcEplColapseThicknessEnum);
745 
746  basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
747 
748  basalelement-> GetInputListOnVertices(&old_active[0],HydrologydcMaskEplactiveNodeEnum);
749  basalelement-> GetInputListOnVertices(&epl_thickness[0],HydrologydcEplThicknessSubstepEnum);
750  basalelement-> GetInputListOnVertices(&sedhead[0],SedimentHeadSubstepEnum);
751  basalelement-> GetInputListOnVertices(&eplhead[0],EplHeadSubstepEnum);
752  basalelement-> GetInputListOnVertices(&residual[0],SedimentHeadResidualEnum);
753  basalelement-> GetInputListOnVertices(&base[0],BaseEnum);
754 
755  /*Get minimum sediment head of the element*/
756  sedheadmin=sedhead[0];
757  for(int i=1;i<numnodes;i++) if(sedhead[i]<=sedheadmin)sedheadmin=sedhead[i];
758  for(int i=0;i<numnodes;i++){
759  GetHydrologyDCInefficientHmax(&h_max,basalelement,basalelement->nodes[i]);
760  /*If mask was already one, keep one or colapse*/
761  if(old_active[i]>0.){
762  vec_mask->SetValue(basalelement->nodes[i]->Sid(),1.,INS_VAL);
763  /* If epl thickness gets under colapse thickness, close the layer if there is no residual*/
764  if(epl_thickness[i]<colapse_thick && residual[i]<=0.){
765  vec_mask->SetValue(basalelement->nodes[i]->Sid(),0.,INS_VAL);
766  recurence->SetValue(basalelement->nodes[i]->Sid(),1.,INS_VAL);
767  }
768  }
769  else if (old_active[i]==0.){
770  /*Activate if we have a residual from sediment*/
771  if(residual[i]>0.){
772  vec_mask->SetValue(basalelement->nodes[i]->Sid(),1.,INS_VAL);
773  recurence->SetValue(basalelement->nodes[i]->Sid(),1.,INS_VAL);
774  }
775  else{
776  /*If node is now closed bring its thickness back to initial*/
777  epl_thickness[i]=init_thick;
778  vec_mask->SetValue(basalelement->nodes[i]->Sid(),0.,INS_VAL);
779  }
780  }
781  /*Increase of the efficient system is needed if the epl head reach the maximum value (sediment max value for now)*/
782  if(eplhead[i]>=h_max && active_element){
783  for(int j=0;j<numnodes;j++){
784  /*Increase of the domain is on the downstream node in term of sediment head*/
785  if((sedhead[j] == sedheadmin) && (i!=j)){
786  vec_mask->SetValue(basalelement->nodes[j]->Sid(),1.,INS_VAL);
787  if(old_active[j]==0.){
788  recurence->SetValue(basalelement->nodes[j]->Sid(),1.,INS_VAL);
789  }
790  }
791  }
792  }
793  }
794  element->AddBasalInput2(HydrologydcEplThicknessSubstepEnum,epl_thickness,basalelement->GetElementType());
795 
796  if(domaintype!=Domain2DhorizontalEnum){
797  basalelement->DeleteMaterials();
798  delete basalelement;
799  }
800  xDelete<IssmDouble>(epl_thickness);
801  xDelete<IssmDouble>(old_active);
802  xDelete<IssmDouble>(sedhead);
803  xDelete<IssmDouble>(eplhead);
804  xDelete<IssmDouble>(residual);
805  xDelete<IssmDouble>(base);
806 }

◆ HydrologyEPLGetActive()

void HydrologyDCEfficientAnalysis::HydrologyEPLGetActive ( Vector< IssmDouble > *  active_vec,
Element element 
)

Definition at line 808 of file HydrologyDCEfficientAnalysis.cpp.

808  {/*{{{*/
809  /*Constants*/
810  int domaintype;
811  Element* basalelement=NULL;
812 
813  /*Get basal element*/
814  element->FindParam(&domaintype,DomainTypeEnum);
815  switch(domaintype){
817  basalelement = element;
818  break;
819  case Domain3DEnum:
820  if(!element->IsOnBase()) return;
821  basalelement = element->SpawnBasalElement();
822  break;
823  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
824  }
825 
826  const int numnodes = basalelement->GetNumberOfNodes();
827  IssmDouble flag = 0.;
828  IssmDouble* active = xNew<IssmDouble>(numnodes);
829  bool active_element;
830 
831  /*Pass the activity mask from elements to nodes*/
833  basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
834 
835  for(int i=0;i<numnodes;i++) flag+=active[i];
836 
837  /*If any node is active all the node in the element are active*/
838  if(flag>0.){
839  for(int i=0;i<numnodes;i++){
840  active_vec->SetValue(basalelement->nodes[i]->Sid(),1.,INS_VAL);
841  }
842  }
843  /*If the element is active all its nodes are active*/
844  else if(active_element){
845  for(int i=0;i<numnodes;i++){
846  active_vec->SetValue(basalelement->nodes[i]->Sid(),1.,INS_VAL);
847  }
848  }
849  else{
850  /*Do not do anything: at least one node is active for this element but this element is not solved for*/
851  }
852  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
853  xDelete<IssmDouble>(active);
854 }

The documentation for this class was generated from the following files:
DataSet::Size
int Size()
Definition: DataSet.cpp:399
BaseEnum
@ BaseEnum
Definition: EnumDefinitions.h:495
Element::GetElementType
virtual int GetElementType(void)=0
SmbEnum
@ SmbEnum
Definition: EnumDefinitions.h:358
EplHeadSlopeXEnum
@ EplHeadSlopeXEnum
Definition: EnumDefinitions.h:555
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
HydrologydcEplColapseThicknessEnum
@ HydrologydcEplColapseThicknessEnum
Definition: EnumDefinitions.h:177
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
Element::GetNumberOfNodes
virtual int GetNumberOfNodes(void)=0
SmbAveragingEnum
@ SmbAveragingEnum
Definition: EnumDefinitions.h:349
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
HydrologydcEnum
@ HydrologydcEnum
Definition: EnumDefinitions.h:1106
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
HydrologydcMaskEplactiveNodeEnum
@ HydrologydcMaskEplactiveNodeEnum
Definition: EnumDefinitions.h:608
HydrologydcEplInitialThicknessEnum
@ HydrologydcEplInitialThicknessEnum
Definition: EnumDefinitions.h:180
Moulin
Definition: Moulin.h:21
HydrologyDCEfficientAnalysis::GetHydrologyDCInefficientHmax
void GetHydrologyDCInefficientHmax(IssmDouble *ph_max, Element *element, Node *innode)
Definition: HydrologyDCEfficientAnalysis.cpp:534
HydrologyDCEfficientAnalysis::GetB
void GetB(IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: HydrologyDCEfficientAnalysis.cpp:408
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
FemModel::parameters
Parameters * parameters
Definition: FemModel.h:46
TimeEnum
@ TimeEnum
Definition: EnumDefinitions.h:427
MaterialsRhoFreshwaterEnum
@ MaterialsRhoFreshwaterEnum
Definition: EnumDefinitions.h:263
TimesteppingTimeStepEnum
@ TimesteppingTimeStepEnum
Definition: EnumDefinitions.h:433
Element::SpawnBasalElement
virtual Element * SpawnBasalElement(void)=0
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
HydrologydcEplThicknessSubstepEnum
@ HydrologydcEplThicknessSubstepEnum
Definition: EnumDefinitions.h:605
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
MaterialsLatentheatEnum
@ MaterialsLatentheatEnum
Definition: EnumDefinitions.h:254
MaterialsRhoIceEnum
@ MaterialsRhoIceEnum
Definition: EnumDefinitions.h:264
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
HydrologyDCEfficientAnalysis::GetHydrologyKMatrixTransfer
IssmDouble GetHydrologyKMatrixTransfer(Element *element)
Definition: HydrologyDCEfficientAnalysis.cpp:569
MaterialsRheologyNEnum
@ MaterialsRheologyNEnum
Definition: EnumDefinitions.h:651
IntVecParam
Definition: IntVecParam.h:20
HydrologydcEplThicknessOldEnum
@ HydrologydcEplThicknessOldEnum
Definition: EnumDefinitions.h:604
Parameters::AddObject
void AddObject(Param *newparam)
Definition: Parameters.cpp:67
IoModel::my_vertices
bool * my_vertices
Definition: IoModel.h:72
SmbStepsPerStepEnum
@ SmbStepsPerStepEnum
Definition: EnumDefinitions.h:389
MaterialsRheologyBbarEnum
@ MaterialsRheologyBbarEnum
Definition: EnumDefinitions.h:644
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
SedimentHeadResidualEnum
@ SedimentHeadResidualEnum
Definition: EnumDefinitions.h:702
IoModel::numberofvertices
int numberofvertices
Definition: IoModel.h:99
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
Element::NewElementVector
ElementVector * NewElementVector(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2505
Parameters::SetParam
void SetParam(bool boolean, int enum_type)
Definition: Parameters.cpp:441
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
ConstantsGEnum
@ ConstantsGEnum
Definition: EnumDefinitions.h:102
BasalforcingsGroundediceMeltingRateEnum
@ BasalforcingsGroundediceMeltingRateEnum
Definition: EnumDefinitions.h:478
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
FemModel::nodes
Nodes * nodes
Definition: FemModel.h:56
Element::AddInput2
virtual void AddInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Element.h:216
Element::NewGauss
virtual Gauss * NewGauss(void)=0
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
SMBgradientscomponentsEnum
@ SMBgradientscomponentsEnum
Definition: EnumDefinitions.h:1248
GsetEnum
@ GsetEnum
Definition: EnumDefinitions.h:1093
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
EplZigZagCounterEnum
@ EplZigZagCounterEnum
Definition: EnumDefinitions.h:130
HydrologydcLeakageFactorEnum
@ HydrologydcLeakageFactorEnum
Definition: EnumDefinitions.h:186
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
HydrologydcEplThickCompEnum
@ HydrologydcEplThickCompEnum
Definition: EnumDefinitions.h:183
IntParam
Definition: IntParam.h:20
INS_VAL
@ INS_VAL
Definition: toolkitsenums.h:14
HydrologydcEplMaxThicknessEnum
@ HydrologydcEplMaxThicknessEnum
Definition: EnumDefinitions.h:181
HydrologydcEplConductivityEnum
@ HydrologydcEplConductivityEnum
Definition: EnumDefinitions.h:179
HydrologydcSedimentlimitEnum
@ HydrologydcSedimentlimitEnum
Definition: EnumDefinitions.h:192
IoModel::FetchData
void FetchData(bool *pboolean, const char *data_name)
Definition: IoModel.cpp:933
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
HydrologyDCEfficientAnalysis::EplStoring
IssmDouble EplStoring(Element *element, Gauss *gauss, Input2 *epl_thick_input, Input2 *epl_head_input, Input2 *base_input)
Definition: HydrologyDCEfficientAnalysis.cpp:489
HydrologyDCEfficientAnalysisEnum
@ HydrologyDCEfficientAnalysisEnum
Definition: EnumDefinitions.h:1098
CreateSingleNodeToElementConnectivity
void CreateSingleNodeToElementConnectivity(IoModel *iomodel)
Definition: CreateSingleNodeToElementConnectivity.cpp:10
FemModel::elements
Elements * elements
Definition: FemModel.h:44
HydrologydcWaterCompressibilityEnum
@ HydrologydcWaterCompressibilityEnum
Definition: EnumDefinitions.h:198
Input2
Definition: Input2.h:18
Element::GetDofListLocal
void GetDofListLocal(int **pdoflist, int approximation_enum, int setenum)
Definition: Element.cpp:984
HydrologydcEplflipLockEnum
@ HydrologydcEplflipLockEnum
Definition: EnumDefinitions.h:184
HydrologydcSedimentlimitFlagEnum
@ HydrologydcSedimentlimitFlagEnum
Definition: EnumDefinitions.h:193
Element::AddBasalInput2
virtual void AddBasalInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Element.h:215
Gauss::GaussVertex
virtual void GaussVertex(int iv)=0
SedimentHeadSubstepEnum
@ SedimentHeadSubstepEnum
Definition: EnumDefinitions.h:700
SmbRunoffEnum
@ SmbRunoffEnum
Definition: EnumDefinitions.h:772
IoModel::Data
IssmDouble * Data(const char *data_name)
Definition: IoModel.cpp:437
Element::GetSolutionFromInputsOneDof
void GetSolutionFromInputsOneDof(Vector< IssmDouble > *solution, int solutionenum)
Definition: Element.cpp:1281
Node::Sid
int Sid(void)
Definition: Node.cpp:622
HydrologyDCEfficientAnalysis::GetHydrologyPVectorTransfer
IssmDouble GetHydrologyPVectorTransfer(Element *element, Gauss *gauss, Input2 *sed_head_input)
Definition: HydrologyDCEfficientAnalysis.cpp:590
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
MaterialsRheologyBEnum
@ MaterialsRheologyBEnum
Definition: EnumDefinitions.h:643
Gauss::begin
virtual int begin(void)=0
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
MeshVertexonsurfaceEnum
@ MeshVertexonsurfaceEnum
Definition: EnumDefinitions.h:655
HydrologyDCEfficientAnalysis::EplTransmitivity
IssmDouble EplTransmitivity(Element *element, Gauss *gauss, Input2 *epl_thick_input, Input2 *epl_head_input, Input2 *base_input)
Definition: HydrologyDCEfficientAnalysis.cpp:520
HydrologydcBasalMoulinInputEnum
@ HydrologydcBasalMoulinInputEnum
Definition: EnumDefinitions.h:602
SmbRunoffTransientEnum
@ SmbRunoffTransientEnum
Definition: EnumDefinitions.h:774
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
Element::GetInputValue
void GetInputValue(bool *pvalue, int enum_type)
Definition: Element.cpp:1177
HydrologyStepsPerStepEnum
@ HydrologyStepsPerStepEnum
Definition: EnumDefinitions.h:175
Parameters::FindParam
void FindParam(bool *pinteger, int enum_type)
Definition: Parameters.cpp:262
ThicknessEnum
@ ThicknessEnum
Definition: EnumDefinitions.h:840
IoModel::FetchDataToInput
void FetchDataToInput(Inputs2 *inputs2, Elements *elements, const char *vector_name, int input_enum)
Definition: IoModel.cpp:1651
HydrologydcTransferFlagEnum
@ HydrologydcTransferFlagEnum
Definition: EnumDefinitions.h:196
Element::VertexConnectivity
virtual int VertexConnectivity(int vertexindex)=0
EplHeadOldEnum
@ EplHeadOldEnum
Definition: EnumDefinitions.h:554
IoModelToConstraintsx
void IoModelToConstraintsx(Constraints *constraints, IoModel *iomodel, const char *spc_name, int analysis_type, int finite_element, int dof)
Definition: IoModelToConstraintsx.cpp:10
ElementVector
Definition: ElementVector.h:20
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
HydrologyDCEfficientAnalysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: HydrologyDCEfficientAnalysis.cpp:70
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
EplHeadSubstepEnum
@ EplHeadSubstepEnum
Definition: EnumDefinitions.h:557
HydrologydcEplCompressibilityEnum
@ HydrologydcEplCompressibilityEnum
Definition: EnumDefinitions.h:178
max
IssmDouble max(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:24
Element::GetNumberOfVertices
virtual int GetNumberOfVertices(void)=0
Element::GetInputListOnVertices
void GetInputListOnVertices(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1131
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
EplHeadSlopeYEnum
@ EplHeadSlopeYEnum
Definition: EnumDefinitions.h:556
ElementMatrix
Definition: ElementMatrix.h:19
HydrologydcEplPorosityEnum
@ HydrologydcEplPorosityEnum
Definition: EnumDefinitions.h:182
HydrologydcMaskEplactiveEltEnum
@ HydrologydcMaskEplactiveEltEnum
Definition: EnumDefinitions.h:607
Gauss
Definition: Gauss.h:8
Vector::SetValue
void SetValue(int dof, doubletype value, InsMode mode)
Definition: Vector.h:163
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