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

#include <StressbalanceAnalysis.h>

Inheritance diagram for StressbalanceAnalysis:
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 GetSolutionFromInputs (Vector< IssmDouble > *solution, Element *element)
 
void GetSolutionFromInputsHoriz (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)
 
ElementMatrix * CreateJacobianMatrixSSA (Element *element)
 
ElementMatrix * CreateKMatrixSSA (Element *element)
 
ElementMatrix * CreateKMatrixSSAFriction (Element *element)
 
ElementMatrix * CreateKMatrixSSALateralFriction (Element *element)
 
ElementMatrix * CreateKMatrixSSAViscous (Element *element)
 
ElementVector * CreatePVectorSSA (Element *element)
 
ElementVector * CreatePVectorSSAFront (Element *element)
 
ElementVector * CreatePVectorSSADrivingStress (Element *element)
 
void GetBSSA (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBSSAFriction (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBSSAprime (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void InputUpdateFromSolutionSSA (IssmDouble *solution, Element *element)
 
ElementMatrix * CreateKMatrixL1L2 (Element *element)
 
ElementMatrix * CreateKMatrixL1L2Friction (Element *element)
 
ElementMatrix * CreateKMatrixL1L2Viscous (Element *element)
 
ElementVector * CreatePVectorL1L2 (Element *element)
 
ElementVector * CreatePVectorL1L2Front (Element *element)
 
ElementVector * CreatePVectorL1L2DrivingStress (Element *element)
 
void InputUpdateFromSolutionL1L2 (IssmDouble *solution, Element *element)
 
ElementMatrix * CreateJacobianMatrixHO (Element *element)
 
ElementMatrix * CreateKMatrixHO (Element *element)
 
ElementMatrix * CreateKMatrixHOFriction (Element *element)
 
ElementMatrix * CreateKMatrixHOViscous (Element *element)
 
ElementVector * CreatePVectorHO (Element *element)
 
ElementVector * CreatePVectorHOFront (Element *element)
 
ElementVector * CreatePVectorHODrivingStress (Element *element)
 
void GetBHO (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBHOFriction (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBHOprime (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void InputUpdateFromSolutionHO (IssmDouble *solution, Element *element)
 
ElementVector * CreateDVectorFS (Element *element)
 
ElementMatrix * CreateJacobianMatrixFS (Element *element)
 
ElementMatrix * CreateKMatrixFS (Element *element)
 
ElementMatrix * CreateKMatrixFSFriction (Element *element)
 
ElementMatrix * CreateKMatrixFSShelf (Element *element)
 
ElementMatrix * CreateKMatrixFSViscous (Element *element)
 
ElementMatrix * CreateKMatrixFSViscousLA (Element *element)
 
ElementMatrix * CreateKMatrixFSViscousXTH (Element *element)
 
ElementMatrix * CreatePressureMassMatrix (Element *element)
 
ElementMatrix * CreateSchurPrecondMatrix (Element *element)
 
ElementVector * CreatePVectorFS (Element *element)
 
ElementVector * CreatePVectorFSFriction (Element *element)
 
ElementVector * CreatePVectorFSFront (Element *element)
 
ElementVector * CreatePVectorFSShelf (Element *element)
 
ElementVector * CreatePVectorFSStress (Element *element)
 
ElementVector * CreatePVectorFSViscous (Element *element)
 
ElementVector * CreatePVectorFSViscousLA (Element *element)
 
ElementVector * CreatePVectorFSViscousXTH (Element *element)
 
void GetBFS (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBFSFriction (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBFSprime (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBFSprimeUzawa (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBFSprimevel (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBFSUzawa (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBFSvel (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetCFS (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetCFSprime (IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
 
void GetSolutionFromInputsFS (Vector< IssmDouble > *solution, Element *element)
 
void InitializeXTH (Elements *elements, Parameters *parameters)
 
void InputUpdateFromSolutionFS (IssmDouble *solution, Element *element)
 
void InputUpdateFromSolutionFSXTH_d (Elements *elements, Parameters *parameters)
 
void InputUpdateFromSolutionFSXTH_tau (Elements *elements, Parameters *parameters)
 
ElementMatrix * CreateKMatrixCouplingHOFS (Element *element)
 
ElementMatrix * CreateKMatrixCouplingSSAFS (Element *element)
 
ElementMatrix * CreateKMatrixCouplingSSAFSFriction (Element *element)
 
ElementMatrix * CreateKMatrixCouplingSSAFSViscous (Element *element)
 
ElementMatrix * CreateKMatrixCouplingSSAHO (Element *element)
 
ElementMatrix * CreateKMatrixCouplingSSAHOFriction (Element *element)
 
ElementMatrix * CreateKMatrixCouplingSSAHOViscous (Element *element)
 
ElementMatrix * CreateKMatrixHOFS (Element *element)
 
ElementMatrix * CreateKMatrixSSAFS (Element *element)
 
ElementMatrix * CreateKMatrixSSAHO (Element *element)
 
ElementMatrix * CreateKMatrixSSA3d (Element *element)
 
ElementMatrix * CreateKMatrixSSA3dFriction (Element *element)
 
ElementMatrix * CreateKMatrixSSA3dViscous (Element *element)
 
ElementVector * CreatePVectorSSAFS (Element *element)
 
ElementVector * CreatePVectorSSAHO (Element *element)
 
ElementVector * CreatePVectorCouplingSSAFS (Element *element)
 
ElementVector * CreatePVectorCouplingSSAFSFriction (Element *element)
 
ElementVector * CreatePVectorCouplingSSAFSViscous (Element *element)
 
ElementVector * CreatePVectorHOFS (Element *element)
 
ElementVector * CreatePVectorCouplingHOFS (Element *element)
 
ElementVector * CreatePVectorCouplingHOFSFriction (Element *element)
 
ElementVector * CreatePVectorCouplingHOFSViscous (Element *element)
 
void GetBprimeSSAFS (IssmDouble *Bprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBprimeSSAFSTria (IssmDouble *Bprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBSSAFS (IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBSSAFSTria (IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetBSSAHO (IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetLFSSSA (IssmDouble *L, Element *element, Gauss *gauss)
 
void GetLprimeFSSSA (IssmDouble *Lprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetLprimeSSAFS (IssmDouble *Lprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
 
void GetLSSAFS (IssmDouble *L, Element *element, Gauss *gauss)
 
void InputUpdateFromSolutionHOFS (IssmDouble *solution, Element *element)
 
void InputUpdateFromSolutionSSAFS (IssmDouble *solution, Element *element)
 
void InputUpdateFromSolutionSSAHO (IssmDouble *solution, Element *element)
 
- Public Member Functions inherited from Analysis
virtual ~Analysis ()
 

Detailed Description

Definition at line 11 of file StressbalanceAnalysis.h.

Member Function Documentation

◆ CreateConstraints()

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

Implements Analysis.

Definition at line 24 of file StressbalanceAnalysis.cpp.

24  {/*{{{*/
25 
26  /*Intermediary*/
27  int i,j;
28  int finiteelement,p_fe,v_fe;
29  IssmDouble g;
30  IssmDouble rho_ice;
31  IssmDouble FSreconditioning;
32  bool isSIA,isSSA,isL1L2,isHO,isFS,iscoupling;
33  bool spcpresent = false;
34  int Mx,Nx;
35  int My,Ny;
36  int Mz,Nz;
37  IssmDouble *spcvx = NULL;
38  IssmDouble *spcvy = NULL;
39  IssmDouble *spcvz = NULL;
40  IssmDouble *nodeonSSA = NULL;
41  IssmDouble *nodeonHO = NULL;
42  IssmDouble *nodeonFS = NULL;
43  IssmDouble *nodeonbase = NULL;
44  IssmDouble *groundedice_ls = NULL;
45  IssmDouble *vertices_type = NULL;
46  IssmDouble *surface = NULL;
47  IssmDouble *z = NULL;
48  IssmDouble *timesx=NULL;
49  IssmDouble *timesy=NULL;
50  IssmDouble *timesz=NULL;
51  IssmDouble* values=NULL;
52 
53  /*Fetch parameters: */
54  iomodel->FindConstant(&g,"md.constants.g");
55  iomodel->FindConstant(&rho_ice,"md.materials.rho_ice");
56  iomodel->FindConstant(&FSreconditioning,"md.stressbalance.FSreconditioning");
57  iomodel->FindConstant(&isSIA,"md.flowequation.isSIA");
58  iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
59  iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
60  iomodel->FindConstant(&isHO,"md.flowequation.isHO");
61  iomodel->FindConstant(&isFS,"md.flowequation.isFS");
62 
63  /*Now, is the flag macayaealHO on? otherwise, do nothing: */
64  if(!isSSA && !isHO && !isFS && !isL1L2) return;
65 
66  /*Do we have coupling*/
67  if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
68  iscoupling = true;
69  else
70  iscoupling = false;
71 
72  /*If no coupling, call Regular IoModelToConstraintsx, else, use P1 elements only*/
73  if(!iscoupling){
74 
75  /*Get finite element type*/
76  if(isSSA) iomodel->FindConstant(&finiteelement,"md.flowequation.fe_SSA");
77  else if(isL1L2) finiteelement = P1Enum;
78  else if(isHO) iomodel->FindConstant(&finiteelement,"md.flowequation.fe_HO");
79  else if(isFS){ iomodel->FindConstant(&finiteelement,"md.flowequation.fe_FS");
80  /*Deduce velocity interpolation from finite element*/
81  switch(finiteelement){
82  case P1P1Enum : v_fe = P1Enum; p_fe = P1Enum; break;
83  case P1P1GLSEnum : v_fe = P1Enum; p_fe = P1Enum; break;
84  case MINIcondensedEnum : v_fe = P1bubbleEnum; p_fe = P1Enum; break;
85  case MINIEnum : v_fe = P1bubbleEnum; p_fe = P1Enum; break;
86  case TaylorHoodEnum : v_fe = P2Enum; p_fe = P1Enum; break;
87  case XTaylorHoodEnum : v_fe = P2Enum; p_fe = P1Enum; break;
88  case LATaylorHoodEnum : v_fe = P2Enum; p_fe = NoneEnum; break;
89  case LACrouzeixRaviartEnum : v_fe = P2bubbleEnum; p_fe = NoneEnum; break;
90  case OneLayerP4zEnum : v_fe = P2xP4Enum; p_fe = P1Enum; break;
91  case CrouzeixRaviartEnum : v_fe = P2bubbleEnum; p_fe = P1DGEnum; break;
92  default: _error_("finite element "<<EnumToStringx(finiteelement)<<" not supported");
93  }
94  }
95  else{
96  _error_("model not supported yet");
97  }
98 
99  if(isFS){
100 
101  /*Constraint at the bedrock interface (v.n = vz = 0) (Coordinates will be updated according to the bed slope)*/
102  iomodel->FetchData(&vertices_type,NULL,NULL,"md.flowequation.vertex_equation");
103  iomodel->FetchData(&nodeonFS,NULL,NULL,"md.flowequation.borderFS");
104  iomodel->FetchData(&nodeonbase,NULL,NULL,"md.mesh.vertexonbase");
105  iomodel->FetchData(&groundedice_ls,NULL,NULL,"md.mask.ocean_levelset");
106  if(iomodel->domaintype==Domain3DEnum){
107  iomodel->FetchData(&spcvz,&Mz,&Nz,"md.stressbalance.spcvz");
108  }
109  else if (iomodel->domaintype==Domain2DverticalEnum){
110  iomodel->FetchData(&spcvz,&Mz,&Nz,"md.stressbalance.spcvy");
111  }
112  else{
113  _error_("not supported yet");
114  }
115  if(iomodel->domaintype==Domain3DEnum){
116  IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx",StressbalanceAnalysisEnum,v_fe,0);
117  IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvy",StressbalanceAnalysisEnum,v_fe,1);
118  IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,v_fe,2);
119  iomodel->DeleteData(spcvz,"md.stressbalance.spcvz");
120  }
121  else if (iomodel->domaintype==Domain2DverticalEnum){
122  IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx",StressbalanceAnalysisEnum,v_fe,0);
123  IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,v_fe,1);
124  iomodel->DeleteData(spcvz,"md.stressbalance.spcvy");
125  }
126  else{
127  _error_("not supported yet");
128  }
129  iomodel->DeleteData(vertices_type,"md.flowequation.vertex_equation");
130  iomodel->DeleteData(nodeonFS,"md.flowequation.borderFS");
131  iomodel->DeleteData(nodeonbase,"md.mesh.vertexonbase");
132  iomodel->DeleteData(groundedice_ls,"md.mask.ocean_levelset");
133 
134  /*Pressure spc*/
135  int count = constraints->Size();
136  iomodel->FetchData(&vertices_type,NULL,NULL,"md.flowequation.vertex_equation");
137  iomodel->FetchData(&surface,NULL,NULL,"md.geometry.surface");
138  iomodel->FetchData(&z,NULL,NULL,"md.mesh.z");
139  bool addpressurespc = false;
140  for(i=0;i<iomodel->numberofvertices;i++){
141  if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum && iomodel->my_vertices[i]){
142  addpressurespc = true;
143  break;
144  }
145  }
146  if(addpressurespc){
147  switch(finiteelement){
148  case P1P1Enum: case P1P1GLSEnum:
149  for(i=0;i<iomodel->numberofvertices;i++){
150  if(iomodel->my_vertices[i]){
151  if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
152  constraints->AddObject(new SpcStatic(count+1,iomodel->numberofvertices+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
153  count++;
154  }
155  }
156  }
157  break;
158  case MINIEnum: case MINIcondensedEnum:
159  for(i=0;i<iomodel->numberofvertices;i++){
160  if(iomodel->my_vertices[i]){
161  if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
162  constraints->AddObject(new SpcStatic(count+1,iomodel->numberofvertices+iomodel->numberofelements+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
163  count++;
164  }
165  }
166  }
167  break;
168  case TaylorHoodEnum:
169  for(i=0;i<iomodel->numberofvertices;i++){
170  if(iomodel->my_vertices[i]){
171  if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
172  constraints->AddObject(new SpcStatic(count+1,iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberofverticalfaces+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
173  count++;
174  }
175  }
176  }
177  break;
178  default:
179  _error_("not implemented yet");
180  }
181  }
182  iomodel->DeleteData(vertices_type,"md.flowequation.vertex_equation");
183  iomodel->DeleteData(surface,"md.geometry.surface");
184  iomodel->DeleteData(z,"md.mesh.z");
185  }
186  else{
187  IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx",StressbalanceAnalysisEnum,finiteelement,0);
188  if(iomodel->domaintype!=Domain2DverticalEnum){
189  IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvy",StressbalanceAnalysisEnum,finiteelement,1);
190  }
191  }
192 
193  return;
194  }
195 
196  /*Constraints: fetch data: */
197  iomodel->FetchData(&spcvx,&Mx,&Nx,"md.stressbalance.spcvx");
198  iomodel->FetchData(&spcvy,&My,&Ny,"md.stressbalance.spcvy");
199  iomodel->FetchData(&spcvz,&Mz,&Nz,"md.stressbalance.spcvz");
200  iomodel->FetchData(&nodeonSSA,NULL,NULL,"md.flowequation.borderSSA");
201  if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,"md.flowequation.borderHO");
202  if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,"md.flowequation.borderFS");
203  if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,"md.mesh.vertexonbase");
204  if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,"md.mask.ocean_levelset");
205  iomodel->FetchData(&vertices_type,NULL,NULL,"md.flowequation.vertex_equation");
206  iomodel->FetchData(&surface,NULL,NULL,"md.geometry.surface");
207  iomodel->FetchData(&z,NULL,NULL,"md.mesh.z");
208 
209  /*Initialize counter: */
210  int count=0;
211 
212  /*figure out times: */
213  timesx=xNew<IssmDouble>(Nx);
214  for(j=0;j<Nx;j++){
215  timesx[j]=spcvx[(Mx-1)*Nx+j];
216  }
217  /*figure out times: */
218  timesy=xNew<IssmDouble>(Ny);
219  for(j=0;j<Ny;j++){
220  timesy[j]=spcvy[(My-1)*Ny+j];
221  }
222  /*figure out times: */
223  timesz=xNew<IssmDouble>(Nz);
224  for(j=0;j<Nz;j++){
225  timesz[j]=spcvz[(Mz-1)*Nz+j];
226  }
227 
228  /*Create spcs from x,y,z, as well as the spc values on those spcs: */
229  for(i=0;i<iomodel->numberofvertices;i++){
230  if(iomodel->my_vertices[i]){
231 
232  /*Start with adding spcs of coupling: zero at the border SSA/HO for the appropriate dofs*/
233  if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SSAHOApproximationEnum){
234  /*If grionSSA, spc HO dofs: 3 & 4*/
235  if (reCast<int,IssmDouble>(nodeonHO[i])){
236  constraints->AddObject(new SpcStatic(count+1,i+1,0,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
237  count++;
238  constraints->AddObject(new SpcStatic(count+1,i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
239  count++;
240  if (!xIsNan<IssmDouble>(spcvx[i])){
241  constraints->AddObject(new SpcStatic(count+1,i+1,2,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
242  count++;
243  }
244  if (!xIsNan<IssmDouble>(spcvy[i])){
245  constraints->AddObject(new SpcStatic(count+1,i+1,3,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
246  count++;
247  }
248 
249  }
250  else if (reCast<int,IssmDouble>(nodeonSSA[i])){
251  constraints->AddObject(new SpcStatic(count+1,i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
252  count++;
253  constraints->AddObject(new SpcStatic(count+1,i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
254  count++;
255  if (!xIsNan<IssmDouble>(spcvx[i])){
256  constraints->AddObject(new SpcStatic(count+1,i+1,0,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
257  count++;
258  }
259  if (!xIsNan<IssmDouble>(spcvy[i])){
260  constraints->AddObject(new SpcStatic(count+1,i+1,1,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
261  count++;
262  }
263 
264  }
265  else _error_("if vertices_type is SSAHO, you shoud have nodeonHO or nodeonSSA");
266  }
267  /*Also add spcs of coupling: zero at the border HO/FS for the appropriate dofs*/
268  else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==HOFSApproximationEnum){
269  /*If grion,HO spc FS dofs: 3 4 & 5*/
270  if (reCast<int,IssmDouble>(nodeonHO[i])){
271  constraints->AddObject(new SpcStatic(count+1,i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
272  count++;
273  constraints->AddObject(new SpcStatic(count+1,i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
274  count++;
275  constraints->AddObject(new SpcStatic(count+1,i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
276  count++;
277  if (!xIsNan<IssmDouble>(spcvx[i])){
278  constraints->AddObject(new SpcStatic(count+1,i+1,0,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
279  count++;
280  }
281  if (!xIsNan<IssmDouble>(spcvy[i])){
282  constraints->AddObject(new SpcStatic(count+1,i+1,1,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
283  count++;
284  }
285 
286  }
287  else if (reCast<int,IssmDouble>(nodeonFS[i])){ //spc HO nodes: 1 & 2
288  constraints->AddObject(new SpcStatic(count+1,i+1,0,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
289  count++;
290  constraints->AddObject(new SpcStatic(count+1,i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
291  count++;
292  if (!xIsNan<IssmDouble>(spcvx[i])){
293  constraints->AddObject(new SpcStatic(count+1,i+1,2,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
294  count++;
295  }
296  if (!xIsNan<IssmDouble>(spcvy[i])){
297  constraints->AddObject(new SpcStatic(count+1,i+1,3,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
298  count++;
299  }
300  if (!xIsNan<IssmDouble>(spcvz[i])){
301  constraints->AddObject(new SpcStatic(count+1,i+1,4,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
302  count++;
303  }
304  }
305  else _error_("if vertices_type is HOFS, you shoud have nodeonHO or nodeonFS");
306  }
307  /*Also add spcs of coupling: zero at the border HO/FS for the appropriate dofs*/
308  else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SSAFSApproximationEnum){
309  /*If grion,HO spc FS dofs: 3 4 & 5*/
310  if (reCast<int,IssmDouble>(nodeonSSA[i])){
311  constraints->AddObject(new SpcStatic(count+1,i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
312  count++;
313  constraints->AddObject(new SpcStatic(count+1,i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
314  count++;
315  constraints->AddObject(new SpcStatic(count+1,i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
316  count++;
317  if (!xIsNan<IssmDouble>(spcvx[i])){
318  constraints->AddObject(new SpcStatic(count+1,i+1,0,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
319  count++;
320  }
321  if (!xIsNan<IssmDouble>(spcvy[i])){
322  constraints->AddObject(new SpcStatic(count+1,i+1,1,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
323  count++;
324  }
325 
326  }
327  else if (reCast<int,IssmDouble>(nodeonFS[i])){ //spc SSA nodes: 1 & 2
328  constraints->AddObject(new SpcStatic(count+1,i+1,0,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
329  count++;
330  constraints->AddObject(new SpcStatic(count+1,i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
331  count++;
332  if (!xIsNan<IssmDouble>(spcvx[i])){
333  constraints->AddObject(new SpcStatic(count+1,i+1,2,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
334  count++;
335  }
336  if (!xIsNan<IssmDouble>(spcvy[i])){
337  constraints->AddObject(new SpcStatic(count+1,i+1,3,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
338  count++;
339  }
340  if (!xIsNan<IssmDouble>(spcvz[i])){
341  constraints->AddObject(new SpcStatic(count+1,i+1,4,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
342  count++;
343  }
344  }
345  else _error_("if vertices_type is SSAFS, you shoud have nodeonSSA or nodeonFS");
346  }
347  /*Now add the regular spcs*/
348  else{
349  if (Mx==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvx[i])){
350  constraints->AddObject(new SpcStatic(count+1,i+1,0,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
351  count++;
352 
353  }
354  else if (Mx==iomodel->numberofvertices+1) {
355  /*figure out times and values: */
356  values=xNew<IssmDouble>(Nx);
357  spcpresent=false;
358  for(j=0;j<Nx;j++){
359  values[j]=spcvx[i*Nx+j];
360  if(!xIsNan<IssmDouble>(values[j]))spcpresent=true; //NaN means no spc by default
361  }
362 
363  if(spcpresent){
364  constraints->AddObject(new SpcTransient(count+1,i+1,0,Nx,timesx,values,StressbalanceAnalysisEnum));
365  count++;
366  }
367  xDelete<IssmDouble>(values);
368  }
369  else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SIAApproximationEnum){
370  constraints->AddObject(new SpcDynamic(count+1,i+1,0,StressbalanceAnalysisEnum));
371  count++;
372  }
373 
374  if (My==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvy[i])){
375  constraints->AddObject(new SpcStatic(count+1,i+1,1,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vy.
376  count++;
377  }
378  else if (My==iomodel->numberofvertices+1){
379  /*figure out times and values: */
380  values=xNew<IssmDouble>(Ny);
381  spcpresent=false;
382  for(j=0;j<Ny;j++){
383  values[j]=spcvy[i*Ny+j];
384  if(!xIsNan<IssmDouble>(values[j]))spcpresent=true; //NaN means no spc by default
385  }
386  if(spcpresent){
387  constraints->AddObject(new SpcTransient(count+1,i+1,1,Ny,timesy,values,StressbalanceAnalysisEnum));
388  count++;
389  }
390  xDelete<IssmDouble>(values);
391  }
392  else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SIAApproximationEnum){
393  constraints->AddObject(new SpcDynamic(count+1,i+1,1,StressbalanceAnalysisEnum));
394  count++;
395  }
396 
397  if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==FSApproximationEnum || (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum)){
398  if (Mz==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
399  constraints->AddObject(new SpcStatic(count+1,i+1,2,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
400  count++;
401  }
402  else if (Mz==iomodel->numberofvertices+1){
403  /*figure out times and values: */
404  values=xNew<IssmDouble>(Nz);
405  spcpresent=false;
406  for(j=0;j<Nz;j++){
407  values[j]=spcvz[i*Nz+j];
408  if(!xIsNan<IssmDouble>(values[j]))spcpresent=true; //NaN means no spc by default
409  }
410  if(spcpresent){
411  constraints->AddObject(new SpcTransient(count+1,i+1,2,Nz,timesz,values,StressbalanceAnalysisEnum));
412  count++;
413  }
414  xDelete<IssmDouble>(values);
415  }
416 
417  }
418  if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
419  constraints->AddObject(new SpcStatic(count+1,iomodel->numberofvertices+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
420  count++;
421  }
422  }
423  }
424  }
425 
426  /*Free data: */
427  iomodel->DeleteData(spcvx,"md.stressbalance.spcvx");
428  iomodel->DeleteData(spcvy,"md.stressbalance.spcvy");
429  iomodel->DeleteData(spcvz,"md.stressbalance.spcvz");
430  iomodel->DeleteData(nodeonSSA,"md.flowequation.borderSSA");
431  if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonHO,"md.flowequation.borderHO");
432  if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonFS,"md.flowequation.borderFS");
433  if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonbase,"md.mesh.vertexonbase");
434  if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(groundedice_ls,"md.mask.ocean_levelset");
435  iomodel->DeleteData(vertices_type,"md.flowequation.vertex_equation");
436  iomodel->DeleteData(surface,"md.geometry.surface");
437  iomodel->DeleteData(z,"md.mesh.z");
438 
439  /*Free resources:*/
440  xDelete<IssmDouble>(timesx);
441  xDelete<IssmDouble>(timesy);
442  xDelete<IssmDouble>(timesz);
443  xDelete<IssmDouble>(values);
444 
445 }/*}}}*/

◆ CreateLoads()

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

Implements Analysis.

Definition at line 446 of file StressbalanceAnalysis.cpp.

446  {/*{{{*/
447 
448  /*Intermediary*/
449  const int RIFTINFOSIZE = 12;
450  int i;
451  int count;
452  int penpair_ids[2];
453  bool isSSA,isL1L2,isHO,isFS;
454  int numpenalties,numrifts,numriftsegments;
455  IssmDouble *riftinfo = NULL;
456  IssmDouble *penalties = NULL;
457  int assert_int;
458 
459  /*Fetch parameters: */
460  iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
461  iomodel->FindConstant(&isFS,"md.flowequation.isFS");
462  iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
463  iomodel->FindConstant(&isHO,"md.flowequation.isHO");
464  iomodel->FindConstant(&numrifts,"md.rifts.numrifts");
465 
466  /*Now, is the flag macayaealHO on? otherwise, do nothing: */
467  if(!isSSA && !isHO && !isFS && !isL1L2) return;
468 
469  /*Initialize counter: */
470  count=0;
471 
472  /*Create Penpair for penalties: */
473  iomodel->FetchData(&penalties,&numpenalties,NULL,"md.stressbalance.vertex_pairing");
474 
475  for(i=0;i<numpenalties;i++){
476 
477  if(iomodel->my_vertices[reCast<int,IssmDouble>(penalties[2*i+0]-1)]){
478 
479  /*In debugging mode, check that the second node is in the same cpu*/
480  assert_int=iomodel->my_vertices[reCast<int,IssmDouble>(penalties[2*i+1]-1)]; _assert_(assert_int);
481 
482  /*Get node ids*/
483  penpair_ids[0]=reCast<int,IssmDouble>(penalties[2*i+0]);
484  penpair_ids[1]=reCast<int,IssmDouble>(penalties[2*i+1]);
485 
486  /*Create Load*/
487  loads->AddObject(new Penpair(count+1,&penpair_ids[0]));
488  count++;
489  }
490  }
491 
492  /*free ressources: */
493  iomodel->DeleteData(penalties,"md.stressbalance.vertex_pairing");
494 
495  /*Create Riffront loads for rifts: */
496  if(numrifts){
497  iomodel->FetchData(&riftinfo,&numriftsegments,NULL,"md.rifts.riftstruct");
498  iomodel->FetchData(5,"md.rifts.riftstruct","md.geometry.thickness","md.geometry.base","md.geometry.surface","md.mask.ocean_levelset");
499  for(i=0;i<numriftsegments;i++){
500  if(iomodel->my_elements[reCast<int,IssmDouble>(*(riftinfo+RIFTINFOSIZE*i+2))-1]){
501  loads->AddObject(new Riftfront(count+1,i,iomodel));
502  count++;
503  }
504  }
505  iomodel->DeleteData(5,"md.rifts.riftstruct","md.geometry.thickness","md.geometry.base","md.geometry.surface","md.mask.ocean_levelset");
506  xDelete<IssmDouble>(riftinfo);
507  }
508 }/*}}}*/

◆ CreateNodes()

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

Implements Analysis.

Definition at line 509 of file StressbalanceAnalysis.cpp.

509  {/*{{{*/
510 
511  /*Intermediary*/
512  bool isSSA,isL1L2,isHO,isFS,iscoupling;
513  int finiteelement=-1,approximation=-1;
514 
515  /*Fetch parameters: */
516  iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
517  iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
518  iomodel->FindConstant(&isHO,"md.flowequation.isHO");
519  iomodel->FindConstant(&isFS,"md.flowequation.isFS");
520 
521  /*Now, check that we have non SIA elements */
522  if(!isSSA & !isL1L2 & !isHO & !isFS) return;
523 
524  /*Do we have coupling*/
525  if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
526  iscoupling = true;
527  else
528  iscoupling = false;
529 
530  /*If no coupling, call Regular CreateNodes, else, use P1 elements only*/
531  if(!iscoupling){
532 
533  /*Get finite element type*/
534  if(isSSA){
535  approximation=SSAApproximationEnum;
536  iomodel->FindConstant(&finiteelement,"md.flowequation.fe_SSA");
537  }
538  else if(isL1L2){
539  approximation = L1L2ApproximationEnum;
540  finiteelement = P1Enum;
541  }
542  else if(isHO){
543  approximation = HOApproximationEnum;
544  iomodel->FindConstant(&finiteelement,"md.flowequation.fe_HO");
545  }
546  else if(isFS){
547  approximation = FSApproximationEnum;
548  iomodel->FindConstant(&finiteelement,"md.flowequation.fe_FS");
549  }
550  if(!isamr){
551  iomodel->FetchData(3,"md.flowequation.borderSSA","md.flowequation.vertex_equation","md.stressbalance.referential");
552  if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(3,"md.mesh.vertexonbase","md.mesh.vertexonsurface","md.flowequation.borderFS");
553  }
554  ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,isamr,approximation);
555  if(!isamr){
556  iomodel->DeleteData(6,"md.mesh.vertexonbase","md.mesh.vertexonsurface","md.flowequation.borderSSA","md.flowequation.vertex_equation",
557  "md.stressbalance.referential","md.flowequation.borderFS");
558  }
559  }
560  else{
561  /*Coupling: we are going to create P1 Elements only*/
562  iomodel->FetchData(6,"md.mesh.vertexonbase","md.mesh.vertexonsurface","md.flowequation.borderSSA","md.flowequation.borderFS",
563  "md.flowequation.vertex_equation","md.stressbalance.referential");
564  if(isFS){
565  int* approximations = xNew<int>(2*iomodel->numberofvertices+iomodel->numberofelements);
566  for(int i=0;i<iomodel->numberofvertices;i++){
567  approximation = IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]));
568  if(approximation==FSApproximationEnum) approximation=FSvelocityEnum;
569  approximations[i] = approximation;
570  }
571  for(int i=0;i<iomodel->numberofelements;i++) approximations[iomodel->numberofvertices+i] = FSvelocityEnum;
572  for(int i=0;i<iomodel->numberofvertices;i++) approximations[iomodel->numberofvertices+iomodel->numberofelements+i] = FSpressureEnum;
573  ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,MINIcondensedEnum,isamr,0,approximations);
574  xDelete<int>(approximations);
575 
576  for(int i=0;i<nodes->Size();i++){
577  Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
578  int sid = node->Sid();
579  if(sid>=iomodel->numberofvertices+iomodel->numberofelements){
580  /*Constrain pressure if not FS*/
581  int id = sid - (iomodel->numberofvertices+iomodel->numberofelements);
582  approximation=IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[id]));
583  if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum){
584  node->Deactivate();
585  }
586  }
587  }
588  }
589  else{
590  int* approximations = xNew<int>(iomodel->numberofvertices);
591  for(int i=0;i<iomodel->numberofvertices;i++) approximations[i] = IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]));
592  ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,P1Enum,isamr,0,approximations);
593  xDelete<int>(approximations);
594  }
595  iomodel->DeleteData(6,"md.mesh.vertexonbase","md.mesh.vertexonsurface","md.flowequation.borderSSA","md.flowequation.borderFS",
596  "md.flowequation.vertex_equation","md.stressbalance.referential");
597  }
598 }/*}}}*/

◆ DofsPerNode()

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

Implements Analysis.

Definition at line 599 of file StressbalanceAnalysis.cpp.

599  {/*{{{*/
600 
601  /*output*/
602  int *doftype = NULL;
603  int numdofs;
604 
605  switch(approximation){
606  case SSAApproximationEnum:
607  switch(domaintype){
608  case Domain3DEnum: numdofs=2; break;
609  case Domain2DhorizontalEnum: numdofs=2; break;
610  case Domain2DverticalEnum: numdofs=1; break;
611  default: _error_("mesh type not supported yet");
612  }
613  break;
614  case L1L2ApproximationEnum: numdofs =2; break;
615  case HOApproximationEnum:
616  switch(domaintype){
617  case Domain3DEnum: numdofs=2; break;
618  case Domain2DverticalEnum: numdofs=1; break;
619  default: _error_("mesh type not supported yet");
620  }
621  break;
622  case SIAApproximationEnum: numdofs =2; break;
623  case FSvelocityEnum:
624  switch(domaintype){
625  case Domain3DEnum: numdofs=3; break;
626  case Domain2DverticalEnum: numdofs=2; break;
627  default: _error_("mesh type not supported yet");
628  }
629  break;
630  case FSpressureEnum: numdofs=1; break;
631  case NoneApproximationEnum:
632  switch(domaintype){
633  case Domain3DEnum: numdofs=4; break;
634  case Domain2DverticalEnum: numdofs=3; break;
635  default: _error_("mesh type not supported yet");
636  }
637  break;
638  case SSAHOApproximationEnum:
639  numdofs=4;
640  doftype=xNew<int>(numdofs);
641  doftype[0]=SSAApproximationEnum;
642  doftype[1]=SSAApproximationEnum;
643  doftype[2]=HOApproximationEnum;
644  doftype[3]=HOApproximationEnum;
645  break;
646  case HOFSApproximationEnum:
647  numdofs=5;
648  doftype=xNew<int>(numdofs);
649  doftype[0]=HOApproximationEnum;
650  doftype[1]=HOApproximationEnum;
651  doftype[2]=FSvelocityEnum;
652  doftype[3]=FSvelocityEnum;
653  doftype[4]=FSvelocityEnum;
654  break;
655  case SSAFSApproximationEnum:
656  numdofs=5;
657  doftype=xNew<int>(numdofs);
658  doftype[0]=SSAApproximationEnum;
659  doftype[1]=SSAApproximationEnum;
660  doftype[2]=FSvelocityEnum;
661  doftype[3]=FSvelocityEnum;
662  doftype[4]=FSvelocityEnum;
663  break;
664  default:
665  _error_("Approximation " << EnumToStringx(approximation) << " not implemented yet");
666  }
667 
668  /*Assign output pointer and return*/
669  *pdoftype = doftype;
670  return numdofs;
671 }/*}}}*/

◆ UpdateElements()

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

Implements Analysis.

Definition at line 672 of file StressbalanceAnalysis.cpp.

672  {/*{{{*/
673 
674  /*Intermediaries*/
675  int materials_type,finiteelement,fe_FS;
676  int approximation,frictionlaw;
677  int FrictionCoupling;
678  int* finiteelement_list=NULL;
679  bool isSSA,isL1L2,isHO,isFS,iscoupling;
680  bool control_analysis;
681  bool dakota_analysis;
682  bool ismovingfront;
683 
684  /*Fetch constants needed: */
685  iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
686  iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
687  iomodel->FindConstant(&isHO,"md.flowequation.isHO");
688  iomodel->FindConstant(&isFS,"md.flowequation.isFS");
689  iomodel->FindConstant(&control_analysis,"md.inversion.iscontrol");
690  iomodel->FindConstant(&dakota_analysis,"md.qmu.isdakota");
691  iomodel->FindConstant(&materials_type,"md.materials.type");
692  iomodel->FindConstant(&ismovingfront,"md.transient.ismovingfront");
693  iomodel->FindConstant(&frictionlaw,"md.friction.law");
694 
695  /*return if no processing required*/
696  if(!isSSA & !isL1L2 & !isHO & !isFS) return;
697 
698  /*Fetch data needed and allocate vectors: */
699  iomodel->FetchData(1,"md.flowequation.element_equation");
700  finiteelement_list=xNewZeroInit<int>(iomodel->numberofelements);
701 
702  /*Do we have coupling*/
703  if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
704  iscoupling = true;
705  else
706  iscoupling = false;
707 
708  /*Get finite element type*/
709  if(!iscoupling){
710  if(isSSA) iomodel->FindConstant(&finiteelement,"md.flowequation.fe_SSA");
711  else if(isL1L2) finiteelement = P1Enum;
712  else if(isHO) iomodel->FindConstant(&finiteelement,"md.flowequation.fe_HO");
713  else if(isFS) iomodel->FindConstant(&finiteelement,"md.flowequation.fe_FS");
714  for(int i=0;i<iomodel->numberofelements;i++){
715  finiteelement_list[i]=finiteelement;
716  }
717  }
718  else{
719  if(isFS){
720  for(int i=0;i<iomodel->numberofelements;i++){
721  approximation=IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i]));
722  if(approximation==FSApproximationEnum || approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
723  finiteelement_list[i]=MINIcondensedEnum;
724  }
725  else{
726  finiteelement_list[i]=P1Enum;
727  }
728  }
729  }
730  else{
731  finiteelement = P1Enum;
732  for(int i=0;i<iomodel->numberofelements;i++){
733  finiteelement_list[i]=finiteelement;
734  }
735  }
736  }
737 
738  /*Update elements: */
739  int counter=0;
740  for(int i=0;i<iomodel->numberofelements;i++){
741  if(iomodel->my_elements[i]){
742  Element* element=(Element*)elements->GetObjectByOffset(counter);
743  element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement_list[i]);
744 
745  /*Need to know the type of approximation for this element*/
746  if(iomodel->Data("md.flowequation.element_equation")){
747  inputs2->SetInput(ApproximationEnum,counter,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i])));
748  }
749 
750  counter++;
751  }
752  }
753 
754  /*Create inputs: */
755  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
756  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
757  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
758  iomodel->FetchDataToInput(inputs2,elements,"md.solidearth.sealevel",SealevelEnum,0);
759  iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
760  iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
761  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum,0.);
762  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum,0.);
763  iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcex",LoadingforceXEnum);
764  iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcey",LoadingforceYEnum);
765  #ifdef LATERALFRICTION
766  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonboundary",MeshVertexonboundaryEnum);
767  #endif
768 
769  if(iomodel->domaintype!=Domain2DhorizontalEnum){
770  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
771  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
772  }
773  if(iomodel->domaintype==Domain3DEnum){
774  iomodel->FetchDataToInput(inputs2,elements,"md.flowequation.borderFS",FlowequationBorderFSEnum);
775  iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcez",LoadingforceZEnum);
776  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum,0.);
777  }
778  if(isFS){
779  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum,0.);
780 
781  /*Add basal forcings to compute melt rate*/
782  int basalforcing_model;
783  iomodel->FindConstant(&basalforcing_model,"md.basalforcings.model");
784  switch(basalforcing_model){
785  case FloatingMeltRateEnum:
786  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
787  break;
788  case LinearFloatingMeltRateEnum:
789  break;
790  case MismipFloatingMeltRateEnum:
791  break;
792  case MantlePlumeGeothermalFluxEnum:
793  break;
794  case SpatialLinearFloatingMeltRateEnum:
795  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
796  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
797  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
798  break;
799  case BasalforcingsPicoEnum:
800  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
801  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.overturning_coeff",BasalforcingsPicoOverturningCoeffEnum);
802  break;
803  case BasalforcingsIsmip6Enum:
804  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
805  break;
806  case BeckmannGoosseFloatingMeltRateEnum:
807  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
808  iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
809  break;
810  default:
811  _error_("Basal forcing model "<<EnumToStringx(basalforcing_model)<<" not supported yet");
812  }
813  }
814  /*LATH parameters*/
815  iomodel->FindConstant(&fe_FS,"md.flowequation.fe_FS");
816  if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){
817  InputUpdateFromConstantx(inputs2,elements,0.,SigmaNNEnum);
818  }
819 
820  /*Friction law variables*/
821  switch(frictionlaw){
822  case 1:
823  iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
824  iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
825  iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
826  iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
827  if(FrictionCoupling==3){
828  iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
829  else if(FrictionCoupling==4){
830  iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
831  }
832  break;
833  case 2:
834  iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
835  iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
836  break;
837  case 3:
838  iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
839  iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
840  iomodel->FetchDataToInput(inputs2,elements,"md.friction.As",FrictionAsEnum);
841  iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
842  if(FrictionCoupling==3){
843  iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
844  else if(FrictionCoupling==4){
845  iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
846  }
847  break;
848  case 4:
849  iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
850  iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
851  iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
852  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
853  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
854  iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
855  break;
856  case 5:
857  iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
858  iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
859  iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
860  iomodel->FetchDataToInput(inputs2,elements,"md.friction.water_layer",FrictionWaterLayerEnum);
861  break;
862  case 6:
863  iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
864  iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
865  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
866  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
867  break;
868  case 7:
869  iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
870  iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
871  iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
872  iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
873  iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
874  if(FrictionCoupling==3){
875  iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
876  else if(FrictionCoupling==4){
877  iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
878 
879  }
880  break;
881  case 9:
882  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
883  iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
884  iomodel->FetchDataToInput(inputs2,elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
885  InputUpdateFromConstantx(inputs2,elements,1.,FrictionPEnum);
886  InputUpdateFromConstantx(inputs2,elements,1.,FrictionQEnum);
887  break;
888  case 10:
889  iomodel->FetchDataToInput(inputs2,elements,"md.friction.till_friction_angle",FrictionTillFrictionAngleEnum);
890  iomodel->FetchDataToInput(inputs2,elements,"md.friction.sediment_compressibility_coefficient",FrictionSedimentCompressibilityCoefficientEnum);
891  iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.watercolumn_max",HydrologyWatercolumnMaxEnum);
892  iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",WatercolumnEnum,0.);
893  break;
894  case 11:
895  iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
896  iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
897  iomodel->FetchDataToInput(inputs2,elements,"md.friction.Cmax",FrictionCmaxEnum);
898  break;
899  case 12:
900  iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
901  iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
902  iomodel->FetchDataToInput(inputs2,elements,"md.friction.f",FrictionfEnum);
903  break;
904  default:
905  _error_("friction law "<< frictionlaw <<" not supported");
906  }
907 
908 #ifdef _HAVE_ANDROID_
909  inputs2->DuplicateInput(FrictionCoefficientEnum,AndroidFrictionCoefficientEnum);
910 #endif
911 
912  /*Free data: */
913  iomodel->DeleteData(1,"md.flowequation.element_equation");
914  xDelete<int>(finiteelement_list);
915 }/*}}}*/

◆ UpdateParameters()

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

Implements Analysis.

Definition at line 916 of file StressbalanceAnalysis.cpp.

916  {/*{{{*/
917 
918  /*Intermediaries*/
919  int fe_FS;
920  int numoutputs;
921  char** requestedoutputs = NULL;
922  int materials_type;
923 
924  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isSIA",FlowequationIsSIAEnum));
925  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isSSA",FlowequationIsSSAEnum));
926  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isL1L2",FlowequationIsL1L2Enum));
927  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isHO",FlowequationIsHOEnum));
928  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isFS",FlowequationIsFSEnum));
929  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.fe_FS",FlowequationFeFSEnum));
930  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.restol",StressbalanceRestolEnum));
931  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.reltol",StressbalanceReltolEnum));
932  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.abstol",StressbalanceAbstolEnum));
933  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.isnewton",StressbalanceIsnewtonEnum));
934  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.maxiter",StressbalanceMaxiterEnum));
935  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.penalty_factor",StressbalancePenaltyFactorEnum));
936  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.rift_penalty_threshold",StressbalanceRiftPenaltyThresholdEnum));
937  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.FSreconditioning",StressbalanceFSreconditioningEnum));
938  parameters->AddObject(iomodel->CopyConstantObject("md.stressbalance.shelf_dampening",StressbalanceShelfDampeningEnum));
939  parameters->AddObject(iomodel->CopyConstantObject("md.friction.law",FrictionLawEnum));
940 
941  /*XTH LATH parameters*/
942  iomodel->FindConstant(&fe_FS,"md.flowequation.fe_FS");
943  if(fe_FS==XTaylorHoodEnum || fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){
944  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.augmented_lagrangian_r",AugmentedLagrangianREnum));
945  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.augmented_lagrangian_rlambda",AugmentedLagrangianRlambdaEnum));
946  parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.XTH_theta",AugmentedLagrangianThetaEnum));
947  }
948 
949  iomodel->FindConstant(&materials_type,"md.materials.type");
950  if(materials_type==MatdamageiceEnum){
951  parameters->AddObject(iomodel->CopyConstantObject("md.damage.law",DamageLawEnum));
952  parameters->AddObject(iomodel->CopyConstantObject("md.damage.kappa",DamageKappaEnum));
953  parameters->AddObject(iomodel->CopyConstantObject("md.damage.stress_threshold",DamageStressThresholdEnum));
954  }
955 
956  /*Requested outputs*/
957  iomodel->FindConstant(&requestedoutputs,&numoutputs,"md.stressbalance.requested_outputs");
958  parameters->AddObject(new IntParam(StressbalanceNumRequestedOutputsEnum,numoutputs));
959  if(numoutputs)parameters->AddObject(new StringArrayParam(StressbalanceRequestedOutputsEnum,requestedoutputs,numoutputs));
960  iomodel->DeleteData(&requestedoutputs,numoutputs,"md.stressbalance.requested_outputs");
961 
962  /*Deal with friction parameters*/
963  int frictionlaw;
964  iomodel->FindConstant(&frictionlaw,"md.friction.law");
965  switch(frictionlaw){
966  case 1:
967  parameters->AddObject(iomodel->CopyConstantObject("md.friction.coupling",FrictionCouplingEnum));
968  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
969  break;
970  case 2:
971  break;
972  case 3:
973  parameters->AddObject(iomodel->CopyConstantObject("md.friction.coupling",FrictionCouplingEnum));
974  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
975  break;
976  case 4:
977  parameters->AddObject(iomodel->CopyConstantObject("md.friction.gamma",FrictionGammaEnum));
978  parameters->AddObject(iomodel->CopyConstantObject("md.friction.coupling",FrictionCouplingEnum));
979  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
980  break;
981  case 5:
982  parameters->AddObject(iomodel->CopyConstantObject("md.friction.f",FrictionFEnum));
983  break;
984  case 6:
985  parameters->AddObject(iomodel->CopyConstantObject("md.friction.gamma",FrictionGammaEnum));
986  break;
987  case 7:
988  parameters->AddObject(iomodel->CopyConstantObject("md.friction.coupling",FrictionCouplingEnum));
989  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
990  break;
991  case 8:
992  break;
993  case 9:
994  parameters->AddObject(iomodel->CopyConstantObject("md.friction.gamma",FrictionGammaEnum));
995  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
996  break;
997  case 10:
998  parameters->AddObject(new IntParam(FrictionCouplingEnum,2)); /*comment this line to use effective pressure from Beuler and Pelt (2015)*/
999  parameters->AddObject(new DoubleParam(FrictionEffectivePressureLimitEnum,0.));
1000  parameters->AddObject(iomodel->CopyConstantObject("md.friction.pseudoplasticity_exponent",FrictionPseudoplasticityExponentEnum));
1001  parameters->AddObject(iomodel->CopyConstantObject("md.friction.threshold_speed",FrictionThresholdSpeedEnum));
1002  parameters->AddObject(iomodel->CopyConstantObject("md.friction.delta",FrictionDeltaEnum));
1003  parameters->AddObject(iomodel->CopyConstantObject("md.friction.void_ratio",FrictionVoidRatioEnum));
1004  break;
1005  case 11:
1006  parameters->AddObject(new IntParam(FrictionCouplingEnum,2));
1007  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
1008  break;
1009  case 12:
1010  parameters->AddObject(new IntParam(FrictionCouplingEnum,2));
1011  parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
1012  break;
1013  default: _error_("Friction law "<<frictionlaw<<" not implemented yet");
1014  }
1015 
1016 }/*}}}*/

◆ Core()

void StressbalanceAnalysis::Core ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 1019 of file StressbalanceAnalysis.cpp.

1019  {/*{{{*/
1020 
1021  /*Intermediaries*/
1022  bool isSSA,isL1L2,isHO,isFS;
1023  bool conserve_loads = true;
1024  int newton,domaintype,fe_FS;
1025 
1026  /* recover parameters:*/
1027  femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum);
1028  femmodel->parameters->FindParam(&isL1L2,FlowequationIsL1L2Enum);
1029  femmodel->parameters->FindParam(&isHO,FlowequationIsHOEnum);
1030  femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);
1031  femmodel->parameters->FindParam(&fe_FS,FlowequationFeFSEnum);
1032  femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
1033  femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
1034 
1035  if(isFS && !(isSSA || isHO || isL1L2)){
1036  if(VerboseSolution()) _printf0_(" computing velocities\n");
1037 
1038  femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
1039 
1040  bool is_schur_cg_solver = false;
1041  #ifdef _HAVE_PETSC_
1042  int solver_type;
1043  PetscOptionsDetermineSolverType(&solver_type);
1044 
1045  if(solver_type==FSSolverEnum) is_schur_cg_solver = true;
1046  #endif
1047 
1048 
1049  if(is_schur_cg_solver)
1050  solutionsequence_schurcg(femmodel);
1051  else if (fe_FS==XTaylorHoodEnum)
1052  solutionsequence_la_theta(femmodel);
1053  else if (fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum)
1054  solutionsequence_la(femmodel);
1055  else if(newton>0)
1056  solutionsequence_newton(femmodel);
1057  else
1058  solutionsequence_nonlinear(femmodel,conserve_loads);
1059  }
1060  else if(!isFS && (isSSA || isHO || isL1L2)){
1061  if(VerboseSolution()) _printf0_(" computing velocities\n");
1062 
1063  femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
1064  if(newton>0)
1065  solutionsequence_newton(femmodel);
1066  else
1067  solutionsequence_nonlinear(femmodel,conserve_loads);
1068 
1069  if(domaintype==Domain2DverticalEnum && isSSA){
1070  femmodel->parameters->SetParam(VxEnum,InputToExtrudeEnum);
1071  extrudefrombase_core(femmodel);
1072  femmodel->parameters->SetParam(VelEnum,InputToExtrudeEnum);
1073  extrudefrombase_core(femmodel);
1074  }
1075  }
1076  else if ((isSSA || isL1L2 || isHO) && isFS){
1077  if(VerboseSolution()) _printf0_(" computing coupling between lower order models and FS\n");
1078  solutionsequence_FScoupling_nonlinear(femmodel,conserve_loads);
1079  }
1080  else{
1081  _error_("not supported");
1082  }
1083 
1084 }/*}}}*/

◆ CreateDVector()

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

Implements Analysis.

Definition at line 1085 of file StressbalanceAnalysis.cpp.

1085  {/*{{{*/
1086 
1087  int approximation;
1088  element->GetInput2Value(&approximation,ApproximationEnum);
1089  switch(approximation){
1090  case FSApproximationEnum:
1091  return CreateDVectorFS(element);
1092  default:
1093  return NULL; //no need for doftypes outside of FS approximation
1094  }
1095  return NULL;
1096 
1097 }/*}}}*/

◆ CreateJacobianMatrix()

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

Implements Analysis.

Definition at line 1098 of file StressbalanceAnalysis.cpp.

1098  {/*{{{*/
1099 
1100  int approximation;
1101  element->GetInput2Value(&approximation,ApproximationEnum);
1102  switch(approximation){
1103  case SSAApproximationEnum:
1104  return CreateJacobianMatrixSSA(element);
1105  case HOApproximationEnum:
1106  return CreateJacobianMatrixHO(element);
1107  case FSApproximationEnum:
1108  return CreateJacobianMatrixFS(element);
1109  case NoneApproximationEnum:
1110  return NULL;
1111  default:
1112  _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
1113  }
1114 }/*}}}*/

◆ CreateKMatrix()

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

Implements Analysis.

Definition at line 1115 of file StressbalanceAnalysis.cpp.

1115  {/*{{{*/
1116  int approximation;
1117  element->GetInput2Value(&approximation,ApproximationEnum);
1118  switch(approximation){
1119  case SIAApproximationEnum:
1120  return NULL;
1121  case SSAApproximationEnum:
1122  return CreateKMatrixSSA(element);
1123  case L1L2ApproximationEnum:
1124  return CreateKMatrixL1L2(element);
1125  case HOApproximationEnum:
1126  return CreateKMatrixHO(element);
1127  case FSApproximationEnum:
1128  return CreateKMatrixFS(element);
1129  case SSAHOApproximationEnum:
1130  return CreateKMatrixSSAHO(element);
1131  case HOFSApproximationEnum:
1132  return CreateKMatrixHOFS(element);
1133  case SSAFSApproximationEnum:
1134  return CreateKMatrixSSAFS(element);
1135  case NoneApproximationEnum:
1136  return NULL;
1137  default:
1138  _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
1139  }
1140 }/*}}}*/

◆ CreatePVector()

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

Implements Analysis.

Definition at line 1141 of file StressbalanceAnalysis.cpp.

1141  {/*{{{*/
1142 
1143  int approximation;
1144  element->GetInput2Value(&approximation,ApproximationEnum);
1145  switch(approximation){
1146  case SIAApproximationEnum:
1147  return NULL;
1148  case SSAApproximationEnum:
1149  return CreatePVectorSSA(element);
1150  case L1L2ApproximationEnum:
1151  return CreatePVectorL1L2(element);
1152  case HOApproximationEnum:
1153  return CreatePVectorHO(element);
1154  case FSApproximationEnum:
1155  return CreatePVectorFS(element);
1156  case SSAHOApproximationEnum:
1157  return CreatePVectorSSAHO(element);
1158  case HOFSApproximationEnum:
1159  return CreatePVectorHOFS(element);
1160  case SSAFSApproximationEnum:
1161  return CreatePVectorSSAFS(element);
1162  case NoneApproximationEnum:
1163  return NULL;
1164  default:
1165  _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
1166  }
1167 }/*}}}*/

◆ GetSolutionFromInputs()

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

Implements Analysis.

Definition at line 1168 of file StressbalanceAnalysis.cpp.

1168  {/*{{{*/
1169 
1170  int approximation;
1171  element->GetInput2Value(&approximation,ApproximationEnum);
1172  switch(approximation){
1173  case FSApproximationEnum: case NoneApproximationEnum:
1174  GetSolutionFromInputsFS(solution,element);
1175  return;
1176  case SSAApproximationEnum: case HOApproximationEnum: case SIAApproximationEnum:
1177  GetSolutionFromInputsHoriz(solution,element);
1178  return;
1179  case L1L2ApproximationEnum:
1180  GetSolutionFromInputsHoriz(solution,element);
1181  return;
1182  case SSAHOApproximationEnum: case HOFSApproximationEnum: case SSAFSApproximationEnum:
1183  /*the elements around will create the solution*/
1184  return;
1185  default:
1186  _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
1187  }
1188 }/*}}}*/

◆ GetSolutionFromInputsHoriz()

void StressbalanceAnalysis::GetSolutionFromInputsHoriz ( Vector< IssmDouble > *  solution,
Element *  element 
)

Definition at line 1189 of file StressbalanceAnalysis.cpp.

1189  {/*{{{*/
1190 
1191  IssmDouble vx,vy;
1192  int domaintype,dim,approximation,dofpernode;
1193  int* doflist = NULL;
1194 
1195  /*Get some parameters*/
1196  element->FindParam(&domaintype,DomainTypeEnum);
1197  switch(domaintype){
1198  case Domain2DhorizontalEnum: dim = 2; dofpernode = 2; break;
1199  case Domain2DverticalEnum: dim = 2; dofpernode = 1; break;
1200  case Domain3DEnum: dim = 3; dofpernode = 2; break;
1201  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1202  }
1203 
1204  /*Fetch number of nodes and dof for this finite element*/
1205  int numnodes = element->GetNumberOfNodes();
1206  int numdof = numnodes*dofpernode;
1207  element->GetInput2Value(&approximation,ApproximationEnum);
1208 
1209  /*Fetch dof list and allocate solution vector*/
1210  element->GetDofList(&doflist,approximation,GsetEnum);
1211  IssmDouble* values = xNew<IssmDouble>(numdof);
1212 
1213  /*Get inputs*/
1214  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
1215  Input2* vy_input=NULL;
1216  if(domaintype!=Domain2DverticalEnum){vy_input=element->GetInput2(VyEnum); _assert_(vy_input);}
1217 
1218  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
1219  Gauss* gauss=element->NewGauss();
1220  for(int i=0;i<numnodes;i++){
1221  gauss->GaussNode(element->FiniteElement(),i);
1222 
1223  /*Recover vx and vy*/
1224  vx_input->GetInputValue(&vx,gauss);
1225  values[i*dofpernode+0]=vx;
1226  if(dofpernode==2){
1227  vy_input->GetInputValue(&vy,gauss);
1228  values[i*dofpernode+1]=vy;
1229  }
1230  }
1231 
1232  solution->SetValues(numdof,doflist,values,INS_VAL);
1233 
1234  /*Free ressources:*/
1235  delete gauss;
1236  xDelete<IssmDouble>(values);
1237  xDelete<int>(doflist);
1238 }/*}}}*/

◆ GradientJ()

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

Implements Analysis.

Definition at line 1239 of file StressbalanceAnalysis.cpp.

1239  {/*{{{*/
1240  _error_("Not implemented yet");
1241 }/*}}}*/

◆ InputUpdateFromSolution()

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

Implements Analysis.

Definition at line 1242 of file StressbalanceAnalysis.cpp.

1242  {/*{{{*/
1243 
1244  int approximation;
1245  element->GetInput2Value(&approximation,ApproximationEnum);
1246  switch(approximation){
1247  case FSApproximationEnum: case NoneApproximationEnum:
1248  InputUpdateFromSolutionFS(solution,element);
1249  return;
1250  case SIAApproximationEnum:
1251  return;
1252  case SSAApproximationEnum:
1253  InputUpdateFromSolutionSSA(solution,element);
1254  return;
1255  case HOApproximationEnum:
1256  InputUpdateFromSolutionHO(solution,element);
1257  return;
1258  case L1L2ApproximationEnum:
1259  InputUpdateFromSolutionL1L2(solution,element);
1260  return;
1261  case SSAHOApproximationEnum:
1262  InputUpdateFromSolutionSSAHO(solution,element);
1263  return;
1264  case HOFSApproximationEnum:
1265  InputUpdateFromSolutionHOFS(solution,element);
1266  return;
1267  case SSAFSApproximationEnum:
1268  InputUpdateFromSolutionSSAFS(solution,element);
1269  return;
1270  default:
1271  _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
1272  }
1273 }/*}}}*/

◆ UpdateConstraints()

void StressbalanceAnalysis::UpdateConstraints ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 1274 of file StressbalanceAnalysis.cpp.

1274  {/*{{{*/
1275  SetActiveNodesLSMx(femmodel);
1276 }/*}}}*/

◆ CreateJacobianMatrixSSA()

ElementMatrix * StressbalanceAnalysis::CreateJacobianMatrixSSA ( Element *  element)

Definition at line 1279 of file StressbalanceAnalysis.cpp.

1279  {/*{{{*/
1280 
1281  /*Intermediaries*/
1282  int domaintype;
1283  Element* basalelement;
1284 
1285  /*Get basal element*/
1286  element->FindParam(&domaintype,DomainTypeEnum);
1287  switch(domaintype){
1288  case Domain2DhorizontalEnum:
1289  basalelement = element;
1290  break;
1291  case Domain3DEnum:
1292  if(!element->IsOnBase()) return NULL;
1293  basalelement = element->SpawnBasalElement();
1294  break;
1295  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1296  }
1297 
1298  /*Intermediaries */
1299  IssmDouble Jdet,thickness;
1300  IssmDouble eps1dotdphii,eps1dotdphij;
1301  IssmDouble eps2dotdphii,eps2dotdphij;
1302  IssmDouble mu_prime;
1303  IssmDouble epsilon[3];/* epsilon=[exx,eyy,exy];*/
1304  IssmDouble eps1[2],eps2[2];
1305  IssmDouble *xyz_list = NULL;
1306 
1307  /*Fetch number of nodes and dof for this finite element*/
1308  int numnodes = basalelement->GetNumberOfNodes();
1309 
1310  /*Initialize Element matrix, vectors and Gaussian points*/
1311  ElementMatrix* Ke=this->CreateKMatrixSSA(element); //Initialize Jacobian with regular SSA (first part of the Gateau derivative)
1312  IssmDouble* dbasis = xNew<IssmDouble>(2*numnodes);
1313 
1314  /*Retrieve all inputs and parameters*/
1315  element->GetVerticesCoordinates(&xyz_list);
1316  Input2* thickness_input = basalelement->GetInput2(ThicknessEnum);_assert_(thickness_input);
1317  Input2* vx_input = basalelement->GetInput2(VxEnum); _assert_(vx_input);
1318  Input2* vy_input = basalelement->GetInput2(VyEnum); _assert_(vy_input);
1319 
1320  /* Start looping on the number of gaussian points: */
1321  Gauss* gauss = basalelement->NewGauss(2);
1322  for(int ig=gauss->begin();ig<gauss->end();ig++){
1323  gauss->GaussPoint(ig);
1324 
1325  basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
1326  basalelement->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
1327 
1328  thickness_input->GetInputValue(&thickness, gauss);
1329  basalelement->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
1330  basalelement->material->ViscositySSADerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
1331  eps1[0]=2*epsilon[0]+epsilon[1]; eps2[0]=epsilon[2];
1332  eps1[1]=epsilon[2]; eps2[1]=epsilon[0]+2*epsilon[1];
1333 
1334  for(int i=0;i<numnodes;i++){
1335  for(int j=0;j<numnodes;j++){
1336  eps1dotdphii=eps1[0]*dbasis[0*numnodes+i]+eps1[1]*dbasis[1*numnodes+i];
1337  eps1dotdphij=eps1[0]*dbasis[0*numnodes+j]+eps1[1]*dbasis[1*numnodes+j];
1338  eps2dotdphii=eps2[0]*dbasis[0*numnodes+i]+eps2[1]*dbasis[1*numnodes+i];
1339  eps2dotdphij=eps2[0]*dbasis[0*numnodes+j]+eps2[1]*dbasis[1*numnodes+j];
1340 
1341  Ke->values[2*numnodes*(2*i+0)+2*j+0]+=gauss->weight*Jdet*2.*mu_prime*thickness*eps1dotdphij*eps1dotdphii;
1342  Ke->values[2*numnodes*(2*i+0)+2*j+1]+=gauss->weight*Jdet*2.*mu_prime*thickness*eps2dotdphij*eps1dotdphii;
1343  Ke->values[2*numnodes*(2*i+1)+2*j+0]+=gauss->weight*Jdet*2.*mu_prime*thickness*eps1dotdphij*eps2dotdphii;
1344  Ke->values[2*numnodes*(2*i+1)+2*j+1]+=gauss->weight*Jdet*2.*mu_prime*thickness*eps2dotdphij*eps2dotdphii;
1345  }
1346  }
1347  }
1348 
1349  /*Transform Coordinate System*/
1350  basalelement->TransformStiffnessMatrixCoord(Ke,XYEnum);
1351 
1352  /*Clean up and return*/
1353  delete gauss;
1354  xDelete<IssmDouble>(xyz_list);
1355  xDelete<IssmDouble>(dbasis);
1356 
1357  /*clean-up and return*/
1358  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
1359  return Ke;
1360 
1361 }/*}}}*/

◆ CreateKMatrixSSA()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSA ( Element *  element)

Definition at line 1362 of file StressbalanceAnalysis.cpp.

1362  {/*{{{*/
1363 
1364  /* Check if ice in element */
1365  if(!element->IsIceInElement()) return NULL;
1366 
1367  /*Intermediaries*/
1368  int domaintype;
1369  Element* basalelement;
1370 
1371  /*Get basal element*/
1372  element->FindParam(&domaintype,DomainTypeEnum);
1373  switch(domaintype){
1374  case Domain2DhorizontalEnum:
1375  basalelement = element;
1376  break;
1377  case Domain3DEnum: case Domain2DverticalEnum:
1378  if(!element->IsOnBase()) return NULL;
1379  basalelement = element->SpawnBasalElement();
1380  break;
1381  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1382  }
1383 
1384  /*compute all stiffness matrices for this element*/
1385  ElementMatrix* Ke1=CreateKMatrixSSAViscous(basalelement);
1386  ElementMatrix* Ke2=CreateKMatrixSSAFriction(basalelement);
1387  #ifdef LATERALFRICTION
1388  ElementMatrix* Ke3=CreateKMatrixSSALateralFriction(basalelement);
1389  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3);
1390  delete Ke3;
1391  #else
1392  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
1393  #endif
1394 
1395  /*clean-up and return*/
1396  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
1397  delete Ke1;
1398  delete Ke2;
1399  return Ke;
1400 }/*}}}*/

◆ CreateKMatrixSSAFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSAFriction ( Element *  element)

Definition at line 1401 of file StressbalanceAnalysis.cpp.

1401  {/*{{{*/
1402 
1403  /*Return if element is inactive*/
1404  if(element->IsFloating() || !element->IsIceInElement()) return NULL;
1405 
1406  /*Intermediaries*/
1407  int dim,domaintype;
1408  bool mainlyfloating;
1409  int friction_style,point1;
1410  IssmDouble alpha2,Jdet,fraction1,fraction2;
1411  IssmDouble gllevelset,phi=1.;
1412  IssmDouble *xyz_list = NULL;
1413  Gauss* gauss = NULL;
1414 
1415  /*Get problem dimension*/
1416  element->FindParam(&domaintype,DomainTypeEnum);
1417  switch(domaintype){
1418  case Domain2DverticalEnum: dim = 1;break;
1419  case Domain2DhorizontalEnum: dim = 2;break;
1420  case Domain3DEnum: dim = 2;break;
1421  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1422  }
1423 
1424  /*Fetch number of nodes and dof for this finite element*/
1425  int numnodes = element->GetNumberOfNodes();
1426  int numdof = numnodes*dim;
1427 
1428  /*Initialize Element matrix and vectors*/
1429  ElementMatrix* Ke = element->NewElementMatrix(SSAApproximationEnum);
1430  IssmDouble* basis = xNew<IssmDouble>(numnodes);
1431 
1432  /*Retrieve all inputs and parameters*/
1433  element->GetVerticesCoordinates(&xyz_list);
1434  element->FindParam(&friction_style,GroundinglineFrictionInterpolationEnum);
1435  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
1436  Input2* gllevelset_input = NULL;
1437 
1438  /*build friction object, used later on: */
1439  Friction* friction=new Friction(element,dim);
1440 
1441  /*Recover portion of element that is grounded*/
1442  if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list);
1443  if(friction_style==SubelementFriction2Enum){
1444  gllevelset_input=element->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
1445  element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
1446  gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
1447  }
1448  else{
1449  gauss = element->NewGauss(2);
1450  }
1451 
1452  /* Start looping on the number of gaussian points: */
1453  for(int ig=gauss->begin();ig<gauss->end();ig++){
1454  gauss->GaussPoint(ig);
1455 
1456  friction->GetAlpha2(&alpha2,gauss);
1457  if(friction_style==SubelementFriction1Enum) alpha2=phi*alpha2;
1458  else if(friction_style==SubelementFriction2Enum){
1459  gllevelset_input->GetInputValue(&gllevelset, gauss);
1460  if(gllevelset<0.) alpha2=0.;
1461  }
1462  else if(friction_style==NoFrictionOnPartiallyFloatingEnum){
1463  if (phi<0.99999999) alpha2=0.;
1464  }
1465  else _error_("friction interpolation "<<EnumToStringx(friction_style)<<" not implemented yet");
1466 
1467  element->NodalFunctions(basis,gauss);
1468  element->JacobianDeterminant(&Jdet, xyz_list,gauss);
1469 
1470  if(dim==2){
1471  for(int i=0;i<numnodes;i++){
1472  for(int j=0;j<numnodes;j++){
1473  Ke->values[2*i*2*numnodes+2*j] += alpha2*gauss->weight*Jdet*basis[i]*basis[j];
1474  Ke->values[(2*i+1)*2*numnodes+2*j+1] += alpha2*gauss->weight*Jdet*basis[i]*basis[j];
1475  }
1476  }
1477  }
1478  else{
1479  for(int i=0;i<numnodes;i++){
1480  for(int j=0;j<numnodes;j++){
1481  Ke->values[i*numnodes+j] += alpha2*gauss->weight*Jdet*basis[i]*basis[j];
1482  }
1483  }
1484  }
1485  }
1486 
1487  /*Transform Coordinate System*/
1488  if(dim==2) element->TransformStiffnessMatrixCoord(Ke,XYEnum);
1489 
1490  /*Clean up and return*/
1491  delete gauss;
1492  delete friction;
1493  xDelete<IssmDouble>(xyz_list);
1494  xDelete<IssmDouble>(basis);
1495  return Ke;
1496 }/*}}}*/

◆ CreateKMatrixSSALateralFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSALateralFriction ( Element *  element)

Definition at line 1497 of file StressbalanceAnalysis.cpp.

1497  {/*{{{*/
1498 
1499  /*Return if element is inactive*/
1500  if(!element->IsIceInElement()) return NULL;
1501 
1502  /*If no boundary, return NULL*/
1503  if(!element->IsFaceOnBoundary()) return NULL;
1504 
1505  /*Intermediaries*/
1506  IssmDouble alpha2;
1507  IssmDouble Jdet;
1508  int domaintype;
1509  IssmDouble icefront;
1510  IssmDouble *xyz_list = NULL;
1511  IssmDouble *xyz_list_boundary = NULL;
1512 
1513  /*Get problem dimension*/
1514  element->FindParam(&domaintype,DomainTypeEnum);
1515  if(domaintype==Domain2DverticalEnum) return NULL; //not supported yet
1516 
1517  /*Fetch number of nodes and dof for this finite element*/
1518  int dim = 2;
1519  int numnodes = element->GetNumberOfNodes();
1520  int numdof = numnodes*dim;
1521 
1522  /*Initialize Element matrix and vectors*/
1523  ElementMatrix* Ke = element->NewElementMatrix(SSAApproximationEnum);
1524  IssmDouble* B = xNew<IssmDouble>(dim*numdof);
1525  IssmDouble* D = xNewZeroInit<IssmDouble>(dim*dim);
1526 
1527  /*Retrieve all inputs and parameters*/
1528  element->GetVerticesCoordinates(&xyz_list);
1529  element->GetLevelCoordinates(&xyz_list_boundary,xyz_list,MeshVertexonboundaryEnum,1.);
1530  Input2* icelevelset_input = element->GetInput2(MaskIceLevelsetEnum); _assert_(icelevelset_input);
1531 
1532  /* Start looping on the number of gaussian points: */
1533  Gauss* gauss=element->NewGauss(xyz_list,xyz_list_boundary,3);
1534  for(int ig=gauss->begin();ig<gauss->end();ig++){
1535  gauss->GaussPoint(ig);
1536 
1537  this->GetBSSAFriction(B,element,dim,xyz_list,gauss);
1538  element->JacobianDeterminantSurface(&Jdet,xyz_list_boundary,gauss);
1539  icelevelset_input->GetInputValue(&icefront, gauss);
1540  if(icefront==0.)
1541  alpha2=0.;
1542  else
1543  alpha2=2.e+12;
1544  for(int i=0;i<dim;i++) D[i*dim+i]=alpha2*gauss->weight*Jdet;
1545 
1546  TripleMultiply(B,dim,numdof,1,
1547  D,dim,dim,0,
1548  B,dim,numdof,0,
1549  &Ke->values[0],1);
1550  }
1551 
1552  /*Transform Coordinate System*/
1553  if(dim==2) element->TransformStiffnessMatrixCoord(Ke,XYEnum);
1554 
1555  /*Clean up and return*/
1556  delete gauss;
1557  xDelete<IssmDouble>(xyz_list);
1558  xDelete<IssmDouble>(xyz_list_boundary);
1559  xDelete<IssmDouble>(B);
1560  xDelete<IssmDouble>(D);
1561  return Ke;
1562 }/*}}}*/

◆ CreateKMatrixSSAViscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSAViscous ( Element *  element)

Definition at line 1563 of file StressbalanceAnalysis.cpp.

1563  {/*{{{*/
1564 
1565  /* Check if ice in element */
1566  if(!element->IsIceInElement()) return NULL;
1567 
1568  /*Intermediaries*/
1569  int dim,domaintype;
1570  IssmDouble viscosity,thickness,Jdet;
1571  IssmDouble *xyz_list = NULL;
1572 
1573  /*Get problem dimension*/
1574  element->FindParam(&domaintype,DomainTypeEnum);
1575  switch(domaintype){
1576  case Domain2DverticalEnum: dim = 1; break;
1577  case Domain2DhorizontalEnum: dim = 2; break;
1578  case Domain3DEnum: dim = 2; break;
1579  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1580  }
1581 
1582  /*Fetch number of nodes and dof for this finite element*/
1583  int numnodes = element->GetNumberOfNodes();
1584  int numdof = numnodes*dim;
1585 
1586  /*Initialize Element matrix and vectors*/
1587  ElementMatrix* Ke = element->NewElementMatrix(SSAApproximationEnum);
1588  IssmDouble* dbasis = xNew<IssmDouble>(2*numnodes);
1589 
1590  /*Retrieve all inputs and parameters*/
1591  element->GetVerticesCoordinates(&xyz_list);
1592  Input2* thickness_input=element->GetInput2(ThicknessEnum); _assert_(thickness_input);
1593  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
1594  Input2* vy_input = NULL;
1595  if(dim==2){
1596  vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
1597  }
1598 
1599  /* Start looping on the number of gaussian points: */
1600  Gauss* gauss = element->NewGauss(2);
1601  for(int ig=gauss->begin();ig<gauss->end();ig++){
1602  gauss->GaussPoint(ig);
1603 
1604  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
1605  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
1606 
1607  thickness_input->GetInputValue(&thickness, gauss);
1608  element->material->ViscositySSA(&viscosity,dim,xyz_list,gauss,vx_input,vy_input);
1609 
1610  if(dim==2){
1611  for(int i=0;i<numnodes;i++){
1612  for(int j=0;j<numnodes;j++){
1613  Ke->values[2*i*2*numnodes+2*j] += gauss->weight*Jdet*viscosity*thickness*(
1614  4.*dbasis[0*numnodes+j]*dbasis[0*numnodes+i] + dbasis[1*numnodes+j]*dbasis[1*numnodes+i]
1615  );
1616  Ke->values[2*i*2*numnodes+2*j+1] += gauss->weight*Jdet*viscosity*thickness*(
1617  2.*dbasis[1*numnodes+j]*dbasis[0*numnodes+i] + dbasis[0*numnodes+j]*dbasis[1*numnodes+i]
1618  );
1619  Ke->values[(2*i+1)*2*numnodes+2*j] += gauss->weight*Jdet*viscosity*thickness*(
1620  2.*dbasis[0*numnodes+j]*dbasis[1*numnodes+i] + dbasis[1*numnodes+j]*dbasis[0*numnodes+i]
1621  );
1622  Ke->values[(2*i+1)*2*numnodes+2*j+1] += gauss->weight*Jdet*viscosity*thickness*(
1623  dbasis[0*numnodes+j]*dbasis[0*numnodes+i] + 4.*dbasis[1*numnodes+j]*dbasis[1*numnodes+i]
1624  );
1625  }
1626  }
1627  }
1628  else{
1629  for(int i=0;i<numnodes;i++){
1630  for(int j=0;j<numnodes;j++){
1631  Ke->values[i*numnodes+j] += gauss->weight*Jdet*viscosity*thickness*(
1632  4.*dbasis[0*numnodes+j]*dbasis[0*numnodes+i]
1633  );
1634  }
1635  }
1636  }
1637  }
1638 
1639  /*Transform Coordinate System*/
1640  if(dim==2) element->TransformStiffnessMatrixCoord(Ke,XYEnum);
1641 
1642  /*Clean up and return*/
1643  delete gauss;
1644  xDelete<IssmDouble>(xyz_list);
1645  xDelete<IssmDouble>(dbasis);
1646  return Ke;
1647 }/*}}}*/

◆ CreatePVectorSSA()

ElementVector * StressbalanceAnalysis::CreatePVectorSSA ( Element *  element)

Definition at line 1648 of file StressbalanceAnalysis.cpp.

1648  {/*{{{*/
1649 
1650  /* Check if ice in element */
1651  if(!element->IsIceInElement()) return NULL;
1652 
1653  /*Intermediaries*/
1654  int domaintype;
1655  Element* basalelement;
1656 
1657  /*Get basal element*/
1658  element->FindParam(&domaintype,DomainTypeEnum);
1659  switch(domaintype){
1660  case Domain2DhorizontalEnum:
1661  basalelement = element;
1662  break;
1663  case Domain3DEnum: case Domain2DverticalEnum:
1664  if(!element->IsOnBase()) return NULL;
1665  basalelement = element->SpawnBasalElement();
1666  break;
1667  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1668  }
1669 
1670  /*compute all load vectors for this element*/
1671  ElementVector* pe1=CreatePVectorSSADrivingStress(basalelement);
1672  ElementVector* pe2=CreatePVectorSSAFront(basalelement);
1673  ElementVector* pe =new ElementVector(pe1,pe2);
1674 
1675  /*clean-up and return*/
1676  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
1677  delete pe1;
1678  delete pe2;
1679  return pe;
1680 }/*}}}*/

◆ CreatePVectorSSAFront()

ElementVector * StressbalanceAnalysis::CreatePVectorSSAFront ( Element *  element)

Definition at line 1740 of file StressbalanceAnalysis.cpp.

1740  {/*{{{*/
1741 
1742  /* Check if ice in element */
1743  if(!element->IsIceInElement()) return NULL;
1744 
1745  /*If no front, return NULL*/
1746  if(!element->IsIcefront()) return NULL;
1747 
1748  /*Intermediaries*/
1749  int dim,domaintype;
1750  IssmDouble Jdet,thickness,base,sealevel,water_pressure,ice_pressure;
1751  IssmDouble surface_under_water,base_under_water,pressure;
1752  IssmDouble *xyz_list = NULL;
1753  IssmDouble *xyz_list_front = NULL;
1754  IssmDouble normal[2];
1755 
1756  /*Get problem dimension*/
1757  element->FindParam(&domaintype,DomainTypeEnum);
1758  switch(domaintype){
1759  case Domain2DverticalEnum: dim = 1;break;
1760  case Domain2DhorizontalEnum: dim = 2;break;
1761  case Domain3DEnum: dim = 2;break;
1762  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1763  }
1764 
1765  /*Fetch number of nodes for this finite element*/
1766  int numnodes = element->GetNumberOfNodes();
1767 
1768  /*Initialize Element vector and other vectors*/
1769  ElementVector* pe = element->NewElementVector(SSAApproximationEnum);
1770  IssmDouble* basis = xNew<IssmDouble>(numnodes);
1771 
1772  /*Retrieve all inputs and parameters*/
1773  Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
1774  Input2* base_input = element->GetInput2(BaseEnum); _assert_(base_input);
1775  Input2* sealevel_input = element->GetInput2(SealevelEnum); _assert_(sealevel_input);
1776  IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
1777  IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum);
1778  IssmDouble gravity = element->FindParam(ConstantsGEnum);
1779  element->GetVerticesCoordinates(&xyz_list);
1780  element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
1781  element->NormalSection(&normal[0],xyz_list_front);
1782 
1783  /*Start looping on Gaussian points*/
1784  Gauss* gauss=element->NewGauss(xyz_list,xyz_list_front,3);
1785  for(int ig=gauss->begin();ig<gauss->end();ig++){
1786 
1787  gauss->GaussPoint(ig);
1788  thickness_input->GetInputValue(&thickness,gauss);
1789  sealevel_input->GetInputValue(&sealevel,gauss);
1790  base_input->GetInputValue(&base,gauss);
1791  element->JacobianDeterminantSurface(&Jdet,xyz_list_front,gauss);
1792  element->NodalFunctions(basis,gauss);
1793 
1794  surface_under_water = min(0.,thickness+base-sealevel); // 0 if the top of the glacier is above water level
1795  base_under_water = min(0.,base-sealevel); // 0 if the bottom of the glacier is above water level
1796  water_pressure = 1.0/2.0*gravity*rho_water*(surface_under_water*surface_under_water - base_under_water*base_under_water);
1797  ice_pressure = 1.0/2.0*gravity*rho_ice*thickness*thickness;
1798  pressure = ice_pressure + water_pressure;
1799 
1800  for(int i=0;i<numnodes;i++){
1801  pe->values[dim*i+0]+= pressure*Jdet*gauss->weight*normal[0]*basis[i];
1802  if(dim==2) pe->values[dim*i+1]+= pressure*Jdet*gauss->weight*normal[1]*basis[i];
1803  }
1804  }
1805 
1806  /*Transform coordinate system*/
1807  if(dim==2) element->TransformLoadVectorCoord(pe,XYEnum);
1808 
1809  /*Clean up and return*/
1810  xDelete<IssmDouble>(xyz_list);
1811  xDelete<IssmDouble>(xyz_list_front);
1812  xDelete<IssmDouble>(basis);
1813  delete gauss;
1814  return pe;
1815 }/*}}}*/

◆ CreatePVectorSSADrivingStress()

ElementVector * StressbalanceAnalysis::CreatePVectorSSADrivingStress ( Element *  element)

Definition at line 1681 of file StressbalanceAnalysis.cpp.

1681  {/*{{{*/
1682 
1683  /* Check if ice in element */
1684  if(!element->IsIceInElement()) return NULL;
1685 
1686  /*Intermediaries */
1687  int dim,domaintype;
1688  IssmDouble thickness,Jdet,slope[2];
1689  IssmDouble* xyz_list = NULL;
1690 
1691  /*Get problem dimension*/
1692  element->FindParam(&domaintype,DomainTypeEnum);
1693  switch(domaintype){
1694  case Domain2DverticalEnum: dim = 1;break;
1695  case Domain2DhorizontalEnum: dim = 2;break;
1696  case Domain3DEnum: dim = 2;break;
1697  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1698  }
1699 
1700  /*Fetch number of nodes and dof for this finite element*/
1701  int numnodes = element->GetNumberOfNodes();
1702 
1703  /*Initialize Element vector and vectors*/
1704  ElementVector* pe = element->NewElementVector(SSAApproximationEnum);
1705  IssmDouble* basis = xNew<IssmDouble>(numnodes);
1706 
1707  /*Retrieve all inputs and parameters*/
1708  element->GetVerticesCoordinates(&xyz_list);
1709  Input2* thickness_input=element->GetInput2(ThicknessEnum); _assert_(thickness_input);
1710  Input2* surface_input =element->GetInput2(SurfaceEnum); _assert_(surface_input);
1711  IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
1712 
1713  /* Start looping on the number of gaussian points: */
1714  Gauss* gauss=element->NewGauss(2);
1715  for(int ig=gauss->begin();ig<gauss->end();ig++){
1716 
1717  gauss->GaussPoint(ig);
1718 
1719  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
1720  element->NodalFunctions(basis, gauss);
1721 
1722  thickness_input->GetInputValue(&thickness,gauss); _assert_(thickness>0);
1723  surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
1724 
1725  for(int i=0;i<numnodes;i++){
1726  pe->values[i*dim+0]+=-rhog*thickness*slope[0]*Jdet*gauss->weight*basis[i];
1727  if(dim==2) pe->values[i*dim+1]+=-rhog*thickness*slope[1]*Jdet*gauss->weight*basis[i];
1728  }
1729  }
1730 
1731  /*Transform coordinate system*/
1732  if(dim==2) element->TransformLoadVectorCoord(pe,XYEnum);
1733 
1734  /*Clean up and return*/
1735  xDelete<IssmDouble>(xyz_list);
1736  xDelete<IssmDouble>(basis);
1737  delete gauss;
1738  return pe;
1739 }/*}}}*/

◆ GetBSSA()

void StressbalanceAnalysis::GetBSSA ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 1816 of file StressbalanceAnalysis.cpp.

1816  {/*{{{*/
1817  /*Compute B matrix. B=[B1 B2 B3] where Bi is of size 3*2.
1818  * For node i, Bi can be expressed in the actual coordinate system
1819  * by:
1820  * 2D 1D
1821  * Bi=[ dN/dx 0 ] Bi=[ dN/dx ]
1822  * [ 0 dN/dy ]
1823  * [ 1/2*dN/dy 1/2*dN/dx ]
1824  * where N is the finiteelement function for node i.
1825  *
1826  * We assume B has been allocated already, of size: 3x(2*numnodes)
1827  */
1828 
1829  /*Fetch number of nodes for this finite element*/
1830  int numnodes = element->GetNumberOfNodes();
1831 
1832  /*Get nodal functions derivatives*/
1833  IssmDouble* dbasis=xNew<IssmDouble>(dim*numnodes);
1834  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
1835 
1836  /*Build B: */
1837  if(dim==2){
1838  for(int i=0;i<numnodes;i++){
1839  B[2*numnodes*0+2*i+0] = dbasis[0*numnodes+i];
1840  B[2*numnodes*0+2*i+1] = 0.;
1841  B[2*numnodes*1+2*i+0] = 0.;
1842  B[2*numnodes*1+2*i+1] = dbasis[1*numnodes+i];
1843  B[2*numnodes*2+2*i+0] = .5*dbasis[1*numnodes+i];
1844  B[2*numnodes*2+2*i+1] = .5*dbasis[0*numnodes+i];
1845  }
1846  }
1847  else{
1848  for(int i=0;i<numnodes;i++){
1849  B[i] = dbasis[i];
1850  }
1851  }
1852 
1853  /*Clean-up*/
1854  xDelete<IssmDouble>(dbasis);
1855 }/*}}}*/

◆ GetBSSAFriction()

void StressbalanceAnalysis::GetBSSAFriction ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 1856 of file StressbalanceAnalysis.cpp.

1856  {/*{{{*/
1857  /*Compute B matrix. B=[B1 B2 B3] where Bi is square and of size 2.
1858  * For node i, Bi can be expressed in the actual coordinate system
1859  * by:
1860  * 2D 1D
1861  * Bi=[ N 0 ] Bi = N
1862  * [ 0 N ]
1863  * where N is the finiteelement function for node i.
1864  *
1865  * We assume B has been allocated already, of size: 2 x (numdof*numnodes)
1866  */
1867 
1868  /*Fetch number of nodes for this finite element*/
1869  int numnodes = element->GetNumberOfNodes();
1870 
1871  /*Get nodal functions derivatives*/
1872  IssmDouble* basis=xNew<IssmDouble>(numnodes);
1873  element->NodalFunctions(basis,gauss);
1874 
1875  /*Build L: */
1876  if(dim==2){
1877  for(int i=0;i<numnodes;i++){
1878  B[2*numnodes*0+2*i+0] = basis[i];
1879  B[2*numnodes*0+2*i+1] = 0.;
1880  B[2*numnodes*1+2*i+0] = 0.;
1881  B[2*numnodes*1+2*i+1] = basis[i];
1882  }
1883  }
1884  else{
1885  for(int i=0;i<numnodes;i++){
1886  B[i] = basis[i];
1887  }
1888  }
1889 
1890  /*Clean-up*/
1891  xDelete<IssmDouble>(basis);
1892 }/*}}}*/

◆ GetBSSAprime()

void StressbalanceAnalysis::GetBSSAprime ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 1893 of file StressbalanceAnalysis.cpp.

1893  {/*{{{*/
1894  /*Compute B' matrix. B'=[B1' B2' B3'] where Bi' is of size 3*2.
1895  * For node i, Bi' can be expressed in the actual coordinate system
1896  * by:
1897  * 2D 1D
1898  * Bi_prime=[ 2*dN/dx dN/dy ] Bi_prime=[ 2*dN/dx ]
1899  * [ dN/dx 2*dN/dy ]
1900  * [ dN/dy dN/dx ]
1901  * where hNis the finiteelement function for node i.
1902  *
1903  * We assume B' has been allocated already, of size: 3x(2*numnodes)
1904  */
1905 
1906  /*Fetch number of nodes for this finite element*/
1907  int numnodes = element->GetNumberOfNodes();
1908 
1909  /*Get nodal functions derivatives*/
1910  IssmDouble* dbasis=xNew<IssmDouble>(dim*numnodes);
1911  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
1912 
1913  /*Build B': */
1914  if(dim==2){
1915  for(int i=0;i<numnodes;i++){
1916  Bprime[2*numnodes*0+2*i+0] = 2.*dbasis[0*numnodes+i];
1917  Bprime[2*numnodes*0+2*i+1] = dbasis[1*numnodes+i];
1918  Bprime[2*numnodes*1+2*i+0] = dbasis[0*numnodes+i];
1919  Bprime[2*numnodes*1+2*i+1] = 2.*dbasis[1*numnodes+i];
1920  Bprime[2*numnodes*2+2*i+0] = dbasis[1*numnodes+i];
1921  Bprime[2*numnodes*2+2*i+1] = dbasis[0*numnodes+i];
1922  }
1923  }
1924  else{
1925  for(int i=0;i<numnodes;i++){
1926  Bprime[i] = 2.*dbasis[i];
1927  }
1928  }
1929 
1930  /*Clean-up*/
1931  xDelete<IssmDouble>(dbasis);
1932 }/*}}}*/

◆ InputUpdateFromSolutionSSA()

void StressbalanceAnalysis::InputUpdateFromSolutionSSA ( IssmDouble *  solution,
Element *  element 
)

Definition at line 1933 of file StressbalanceAnalysis.cpp.

1933  {/*{{{*/
1934 
1935  int i,dim,domaintype;
1936  IssmDouble rho_ice,g;
1937  int* doflist=NULL;
1938  IssmDouble* xyz_list=NULL;
1939  Element* basalelement=NULL;
1940 
1941  /*Deal with pressure first*/
1942  int numvertices = element->GetNumberOfVertices();
1943  IssmDouble* pressure = xNew<IssmDouble>(numvertices);
1944  IssmDouble* thickness = xNew<IssmDouble>(numvertices);
1945  IssmDouble* surface = xNew<IssmDouble>(numvertices);
1946 
1947  element->FindParam(&domaintype,DomainTypeEnum);
1948  rho_ice =element->FindParam(MaterialsRhoIceEnum);
1949  g =element->FindParam(ConstantsGEnum);
1950  switch(domaintype){
1951  case Domain2DhorizontalEnum:
1952  element->GetInputListOnVertices(thickness,ThicknessEnum);
1953  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*thickness[i];
1954  dim=2;
1955  break;
1956  case Domain3DEnum:
1957  element->GetVerticesCoordinates(&xyz_list);
1958  element->GetInputListOnVertices(surface,SurfaceEnum);
1959  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
1960  dim=2;
1961  break;
1962  case Domain2DverticalEnum:
1963  element->GetVerticesCoordinates(&xyz_list);
1964  element->GetInputListOnVertices(surface,SurfaceEnum);
1965  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+1]);
1966  dim=1;
1967  break;
1968  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1969  }
1970  element->AddInput2(PressureEnum,pressure,P1Enum);
1971  xDelete<IssmDouble>(pressure);
1972  xDelete<IssmDouble>(thickness);
1973  xDelete<IssmDouble>(surface);
1974 
1975  /*Get basal element*/
1976  switch(domaintype){
1977  case Domain2DhorizontalEnum:
1978  basalelement = element;
1979  break;
1980  case Domain3DEnum: case Domain2DverticalEnum:
1981  if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
1982  basalelement=element->SpawnBasalElement();
1983  break;
1984  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
1985  }
1986 
1987  /*Fetch number of nodes and dof for this finite element*/
1988  int numnodes = basalelement->GetNumberOfNodes();
1989  int numdof = numnodes*dim;
1990 
1991  /*Fetch dof list and allocate solution vectors*/
1992  basalelement->GetDofListLocal(&doflist,SSAApproximationEnum,GsetEnum);
1993  IssmDouble* values = xNew<IssmDouble>(numdof);
1994  IssmDouble* vx = xNew<IssmDouble>(numnodes);
1995  IssmDouble* vy = xNew<IssmDouble>(numnodes);
1996  IssmDouble* vz = xNew<IssmDouble>(numnodes);
1997  IssmDouble* vel = xNew<IssmDouble>(numnodes);
1998 
1999  /*Use the dof list to index into the solution vector: */
2000  for(i=0;i<numdof;i++) values[i]=solution[doflist[i]];
2001 
2002  /*Transform solution in Cartesian Space*/
2003  if(dim==2) basalelement->TransformSolutionCoord(&values[0],XYEnum);
2004 
2005  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
2006  for(i=0;i<numnodes;i++){
2007  vx[i]=values[i*dim+0];
2008  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
2009  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
2010 
2011  if(dim==2){
2012  vy[i]=values[i*dim+1];
2013  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
2014  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
2015  }
2016  }
2017 
2018  /*Get Vz and compute vel*/
2019  if(dim==2){
2020  basalelement->GetInputListOnNodes(&vz[0],VzEnum,0.);
2021  for(i=0;i<numnodes;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
2022  }
2023  else{
2024  basalelement->GetInputListOnNodes(&vy[0],VyEnum,0.);
2025  for(i=0;i<numnodes;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i]);
2026  }
2027 
2028  /*Add vx and vy as inputs to the tria element: */
2029  element->AddBasalInput2(VxEnum,vx,element->GetElementType());
2030  if(dim==2)element->AddBasalInput2(VyEnum,vy,element->GetElementType());
2031  element->AddBasalInput2(VelEnum,vel,element->GetElementType());
2032 
2033  /*Free ressources:*/
2034  xDelete<IssmDouble>(vel);
2035  xDelete<IssmDouble>(vz);
2036  xDelete<IssmDouble>(vy);
2037  xDelete<IssmDouble>(vx);
2038  xDelete<IssmDouble>(values);
2039  xDelete<IssmDouble>(xyz_list);
2040  xDelete<int>(doflist);
2041  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
2042 }/*}}}*/

◆ CreateKMatrixL1L2()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixL1L2 ( Element *  element)

Definition at line 2045 of file StressbalanceAnalysis.cpp.

2045  {/*{{{*/
2046 
2047  /* Check if ice in element */
2048  if(!element->IsIceInElement()) return NULL;
2049 
2050  /*compute all stiffness matrices for this element*/
2051  ElementMatrix* Ke1=CreateKMatrixL1L2Viscous(element);
2052  ElementMatrix* Ke2=CreateKMatrixL1L2Friction(element);
2053  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
2054 
2055  /*clean-up and return*/
2056  delete Ke1;
2057  delete Ke2;
2058  return Ke;
2059 }/*}}}*/

◆ CreateKMatrixL1L2Friction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixL1L2Friction ( Element *  element)

Definition at line 2060 of file StressbalanceAnalysis.cpp.

2060  {/*{{{*/
2061 
2062  if(!element->IsOnBase() || element->IsFloating()) return NULL;
2063  Element* basalelement = element->SpawnBasalElement();
2064  ElementMatrix* Ke = CreateKMatrixSSAFriction(basalelement);
2065 
2066  /*clean-up and return*/
2067  basalelement->DeleteMaterials(); delete basalelement;
2068  return Ke;
2069 }/*}}}*/

◆ CreateKMatrixL1L2Viscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixL1L2Viscous ( Element *  element)

Definition at line 2070 of file StressbalanceAnalysis.cpp.

2070  {/*{{{*/
2071 
2072  /*Intermediaries*/
2073  IssmDouble viscosity,Jdet;
2074  IssmDouble *xyz_list = NULL;
2075 
2076  /*Get element on base*/
2077  Element* basalelement = element->GetBasalElement()->SpawnBasalElement();
2078 
2079  /*Fetch number of nodes and dof for this finite element*/
2080  int numnodes = basalelement->GetNumberOfNodes();
2081  int numdof = numnodes*2;
2082 
2083  /*Initialize Element matrix and vectors*/
2084  ElementMatrix* Ke = basalelement->NewElementMatrix(L1L2ApproximationEnum);
2085  IssmDouble* B = xNew<IssmDouble>(3*numdof);
2086  IssmDouble* Bprime = xNew<IssmDouble>(3*numdof);
2087  IssmDouble* D = xNewZeroInit<IssmDouble>(3*3);
2088 
2089  /*Retrieve all inputs and parameters*/
2090  element->GetVerticesCoordinates(&xyz_list);
2091  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
2092  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
2093  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
2094 
2095  /* Start looping on the number of gaussian points: */
2096  Gauss* gauss = element->NewGauss(5);
2097  Gauss* gauss_base = basalelement->NewGauss();
2098  for(int ig=gauss->begin();ig<gauss->end();ig++){
2099 
2100  gauss->GaussPoint(ig);
2101  gauss->SynchronizeGaussBase(gauss_base);
2102 
2103  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2104  this->GetBSSA(B,basalelement,2,xyz_list,gauss_base);
2105  this->GetBSSAprime(Bprime,basalelement,2,xyz_list,gauss_base);
2106 
2107  element->material->ViscosityL1L2(&viscosity,xyz_list,gauss,vx_input,vy_input,surface_input);
2108 
2109  for(int i=0;i<3;i++) D[i*3+i]=2*viscosity*gauss->weight*Jdet;
2110 
2111  TripleMultiply(B,3,numdof,1,
2112  D,3,3,0,
2113  Bprime,3,numdof,0,
2114  &Ke->values[0],1);
2115  }
2116 
2117  /*Transform Coordinate System*/
2118  basalelement->TransformStiffnessMatrixCoord(Ke,XYEnum);
2119 
2120  /*Clean up and return*/
2121  delete gauss;
2122  delete gauss_base;
2123  basalelement->DeleteMaterials(); delete basalelement;
2124  xDelete<IssmDouble>(xyz_list);
2125  xDelete<IssmDouble>(D);
2126  xDelete<IssmDouble>(Bprime);
2127  xDelete<IssmDouble>(B);
2128  return Ke;
2129 }/*}}}*/

◆ CreatePVectorL1L2()

ElementVector * StressbalanceAnalysis::CreatePVectorL1L2 ( Element *  element)

Definition at line 2130 of file StressbalanceAnalysis.cpp.

2130  {/*{{{*/
2131 
2132  /* Check if ice in element */
2133  if(!element->IsIceInElement()) return NULL;
2134 
2135  /*Intermediaries*/
2136  int domaintype;
2137  Element* basalelement;
2138 
2139  /*Get basal element*/
2140  element->FindParam(&domaintype,DomainTypeEnum);
2141  switch(domaintype){
2142  case Domain2DhorizontalEnum:
2143  basalelement = element;
2144  break;
2145  case Domain3DEnum: case Domain2DverticalEnum:
2146  if(!element->IsOnBase()) return NULL;
2147  basalelement = element->SpawnBasalElement();
2148  break;
2149  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
2150  }
2151 
2152  /*compute all load vectors for this element*/
2153  ElementVector* pe1=CreatePVectorL1L2DrivingStress(basalelement);
2154  ElementVector* pe2=CreatePVectorL1L2Front(basalelement);
2155  ElementVector* pe =new ElementVector(pe1,pe2);
2156 
2157  /*clean-up and return*/
2158  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
2159  delete pe1;
2160  delete pe2;
2161  return pe;
2162 }/*}}}*/

◆ CreatePVectorL1L2Front()

ElementVector * StressbalanceAnalysis::CreatePVectorL1L2Front ( Element *  element)

Definition at line 2209 of file StressbalanceAnalysis.cpp.

2209  {/*{{{*/
2210 
2211  /*If no front, return NULL*/
2212  if(!element->IsIcefront()) return NULL;
2213 
2214  /*Intermediaries*/
2215  IssmDouble Jdet,thickness,bed,sealevel,water_pressure,ice_pressure;
2216  IssmDouble surface_under_water,base_under_water,pressure;
2217  IssmDouble *xyz_list = NULL;
2218  IssmDouble *xyz_list_front = NULL;
2219  IssmDouble normal[2];
2220 
2221  /*Fetch number of nodes for this finite element*/
2222  int numnodes = element->GetNumberOfNodes();
2223 
2224  /*Initialize Element vector and other vectors*/
2225  ElementVector* pe = element->NewElementVector(L1L2ApproximationEnum);
2226  IssmDouble* basis = xNew<IssmDouble>(numnodes);
2227 
2228  /*Retrieve all inputs and parameters*/
2229  Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
2230  Input2* base_input = element->GetInput2(BaseEnum); _assert_(base_input);
2231  Input2* sealevel_input = element->GetInput2(SealevelEnum); _assert_(sealevel_input);
2232  IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
2233  IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum);
2234  IssmDouble gravity = element->FindParam(ConstantsGEnum);
2235  element->GetVerticesCoordinates(&xyz_list);
2236  element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
2237  element->NormalSection(&normal[0],xyz_list_front);
2238 
2239  /*Start looping on Gaussian points*/
2240  Gauss* gauss=element->NewGauss(xyz_list,xyz_list_front,3);
2241  for(int ig=gauss->begin();ig<gauss->end();ig++){
2242 
2243  gauss->GaussPoint(ig);
2244  thickness_input->GetInputValue(&thickness,gauss);
2245  base_input->GetInputValue(&bed,gauss);
2246  sealevel_input->GetInputValue(&sealevel,gauss);
2247  element->JacobianDeterminantSurface(&Jdet,xyz_list_front,gauss);
2248  element->NodalFunctions(basis,gauss);
2249 
2250  surface_under_water = min(0.,thickness+bed-sealevel); // 0 if the top of the glacier is above water level
2251  base_under_water = min(0.,bed-sealevel); // 0 if the bottom of the glacier is above water level
2252  water_pressure = 1.0/2.0*gravity*rho_water*(surface_under_water*surface_under_water - base_under_water*base_under_water);
2253  ice_pressure = 1.0/2.0*gravity*rho_ice*thickness*thickness;
2254  pressure = ice_pressure + water_pressure;
2255 
2256  for (int i=0;i<numnodes;i++){
2257  pe->values[2*i+0]+= pressure*Jdet*gauss->weight*normal[0]*basis[i];
2258  pe->values[2*i+1]+= pressure*Jdet*gauss->weight*normal[1]*basis[i];
2259  }
2260  }
2261 
2262  /*Transform coordinate system*/
2263  element->TransformLoadVectorCoord(pe,XYEnum);
2264 
2265  /*Clean up and return*/
2266  xDelete<IssmDouble>(xyz_list);
2267  xDelete<IssmDouble>(xyz_list_front);
2268  xDelete<IssmDouble>(basis);
2269  delete gauss;
2270  return pe;
2271 }/*}}}*/

◆ CreatePVectorL1L2DrivingStress()

ElementVector * StressbalanceAnalysis::CreatePVectorL1L2DrivingStress ( Element *  element)

Definition at line 2163 of file StressbalanceAnalysis.cpp.

2163  {/*{{{*/
2164 
2165  /*Intermediaries */
2166  IssmDouble thickness,Jdet,slope[2];
2167  IssmDouble* xyz_list = NULL;
2168 
2169  /*Fetch number of nodes and dof for this finite element*/
2170  int numnodes = element->GetNumberOfNodes();
2171 
2172  /*Initialize Element vector and vectors*/
2173  ElementVector* pe = element->NewElementVector(L1L2ApproximationEnum);
2174  IssmDouble* basis = xNew<IssmDouble>(numnodes);
2175 
2176  /*Retrieve all inputs and parameters*/
2177  element->GetVerticesCoordinates(&xyz_list);
2178  Input2* thickness_input=element->GetInput2(ThicknessEnum); _assert_(thickness_input);
2179  Input2* surface_input =element->GetInput2(SurfaceEnum); _assert_(surface_input);
2180  IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
2181 
2182  /* Start looping on the number of gaussian points: */
2183  Gauss* gauss=element->NewGauss(2);
2184  for(int ig=gauss->begin();ig<gauss->end();ig++){
2185 
2186  gauss->GaussPoint(ig);
2187 
2188  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2189  element->NodalFunctions(basis, gauss);
2190 
2191  thickness_input->GetInputValue(&thickness,gauss);
2192  surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
2193 
2194  for(int i=0;i<numnodes;i++){
2195  pe->values[i*2+0]+=-rhog*thickness*slope[0]*Jdet*gauss->weight*basis[i];
2196  pe->values[i*2+1]+=-rhog*thickness*slope[1]*Jdet*gauss->weight*basis[i];
2197  }
2198  }
2199 
2200  /*Transform coordinate system*/
2201  element->TransformLoadVectorCoord(pe,XYEnum);
2202 
2203  /*Clean up and return*/
2204  xDelete<IssmDouble>(xyz_list);
2205  xDelete<IssmDouble>(basis);
2206  delete gauss;
2207  return pe;
2208 }/*}}}*/

◆ InputUpdateFromSolutionL1L2()

void StressbalanceAnalysis::InputUpdateFromSolutionL1L2 ( IssmDouble *  solution,
Element *  element 
)

Definition at line 2272 of file StressbalanceAnalysis.cpp.

2272  {/*{{{*/
2273 
2274  int i,dim,domaintype;
2275  IssmDouble rho_ice,g;
2276  int* doflist=NULL;
2277  IssmDouble* xyz_list=NULL;
2278  Element* basalelement=NULL;
2279 
2280  /*Deal with pressure first*/
2281  int numvertices = element->GetNumberOfVertices();
2282  IssmDouble* pressure = xNew<IssmDouble>(numvertices);
2283  IssmDouble* thickness = xNew<IssmDouble>(numvertices);
2284  IssmDouble* surface = xNew<IssmDouble>(numvertices);
2285 
2286  element->FindParam(&dim,DomainDimensionEnum);
2287  element->FindParam(&domaintype,DomainTypeEnum);
2288  rho_ice =element->FindParam(MaterialsRhoIceEnum);
2289  g =element->FindParam(ConstantsGEnum);
2290  if(dim==2){
2291  element->GetInputListOnVertices(thickness,ThicknessEnum);
2292  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*thickness[i];
2293  }
2294  else{
2295  element->GetVerticesCoordinates(&xyz_list);
2296  element->GetInputListOnVertices(surface,SurfaceEnum);
2297  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
2298  }
2299  element->AddInput2(PressureEnum,pressure,P1Enum);
2300  xDelete<IssmDouble>(pressure);
2301  xDelete<IssmDouble>(thickness);
2302  xDelete<IssmDouble>(surface);
2303 
2304  /*Get basal element*/
2305  switch(domaintype){
2306  case Domain2DhorizontalEnum:
2307  basalelement = element;
2308  break;
2309  case Domain3DEnum:
2310  if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
2311  basalelement=element->SpawnBasalElement();
2312  break;
2313  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
2314  }
2315 
2316  /*Fetch number of nodes and dof for this finite element*/
2317  int numnodes = basalelement->GetNumberOfNodes();
2318  int numdof = numnodes*2;
2319 
2320  /*Fetch dof list and allocate solution vectors*/
2321  basalelement->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
2322  IssmDouble* values = xNew<IssmDouble>(numdof);
2323  IssmDouble* vx = xNew<IssmDouble>(numnodes);
2324  IssmDouble* vy = xNew<IssmDouble>(numnodes);
2325  IssmDouble* vz = xNew<IssmDouble>(numnodes);
2326  IssmDouble* vel = xNew<IssmDouble>(numnodes);
2327 
2328  /*Use the dof list to index into the solution vector: */
2329  for(i=0;i<numdof;i++) values[i]=solution[doflist[i]];
2330 
2331  /*Transform solution in Cartesian Space*/
2332  basalelement->TransformSolutionCoord(&values[0],XYEnum);
2333  basalelement->FindParam(&domaintype,DomainTypeEnum);
2334 
2335  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
2336  for(i=0;i<numnodes;i++){
2337  vx[i]=values[i*2+0];
2338  vy[i]=values[i*2+1];
2339 
2340  /*Check solution*/
2341  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
2342  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
2343  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
2344  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
2345  }
2346 
2347  /*Get Vz and compute vel*/
2348  basalelement->GetInputListOnNodes(&vz[0],VzEnum,0.);
2349  for(i=0;i<numnodes;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
2350 
2351  /*Add vx and vy as inputs to the tria element: */
2352  element->AddBasalInput2(VxEnum,vx,element->GetElementType());
2353  element->AddBasalInput2(VyEnum,vy,element->GetElementType());
2354  element->AddBasalInput2(VelEnum,vel,element->GetElementType());
2355 
2356  /*Free ressources:*/
2357  xDelete<IssmDouble>(vel);
2358  xDelete<IssmDouble>(vz);
2359  xDelete<IssmDouble>(vy);
2360  xDelete<IssmDouble>(vx);
2361  xDelete<IssmDouble>(values);
2362  xDelete<IssmDouble>(xyz_list);
2363  xDelete<int>(doflist);
2364  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
2365 }/*}}}*/

◆ CreateJacobianMatrixHO()

ElementMatrix * StressbalanceAnalysis::CreateJacobianMatrixHO ( Element *  element)

Definition at line 2368 of file StressbalanceAnalysis.cpp.

2368  {/*{{{*/
2369 
2370  /*Intermediaries */
2371  IssmDouble Jdet;
2372  IssmDouble eps1dotdphii,eps1dotdphij;
2373  IssmDouble eps2dotdphii,eps2dotdphij;
2374  IssmDouble mu_prime;
2375  IssmDouble epsilon[5]; /* epsilon=[exx,eyy,exy,exz,eyz];*/
2376  IssmDouble eps1[3],eps2[3];
2377  IssmDouble *xyz_list = NULL;
2378 
2379  /*Fetch number of nodes and dof for this finite element*/
2380  int numnodes = element->GetNumberOfNodes();
2381 
2382  /*Initialize Element matrix, vectors and Gaussian points*/
2383  ElementMatrix* Ke=this->CreateKMatrixHO(element); //Initialize Jacobian with regular HO (first part of the Gateau derivative)
2384  IssmDouble* dbasis = xNew<IssmDouble>(3*numnodes);
2385 
2386  /*Retrieve all inputs and parameters*/
2387  element->GetVerticesCoordinates(&xyz_list);
2388  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
2389  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
2390 
2391  /* Start looping on the number of gaussian points: */
2392  Gauss* gauss = element->NewGauss(5);
2393  for(int ig=gauss->begin();ig<gauss->end();ig++){
2394  gauss->GaussPoint(ig);
2395 
2396  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2397  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
2398 
2399  element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
2400  element->material->ViscosityHODerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
2401  eps1[0]=2*epsilon[0]+epsilon[1]; eps2[0]=epsilon[2];
2402  eps1[1]=epsilon[2]; eps2[1]=epsilon[0]+2*epsilon[1];
2403  eps1[2]=epsilon[3]; eps2[2]=epsilon[4];
2404 
2405  for(int i=0;i<numnodes;i++){
2406  for(int j=0;j<numnodes;j++){
2407  eps1dotdphii=eps1[0]*dbasis[0*numnodes+i]+eps1[1]*dbasis[1*numnodes+i]+eps1[2]*dbasis[2*numnodes+i];
2408  eps1dotdphij=eps1[0]*dbasis[0*numnodes+j]+eps1[1]*dbasis[1*numnodes+j]+eps1[2]*dbasis[2*numnodes+j];
2409  eps2dotdphii=eps2[0]*dbasis[0*numnodes+i]+eps2[1]*dbasis[1*numnodes+i]+eps2[2]*dbasis[2*numnodes+i];
2410  eps2dotdphij=eps2[0]*dbasis[0*numnodes+j]+eps2[1]*dbasis[1*numnodes+j]+eps2[2]*dbasis[2*numnodes+j];
2411 
2412  Ke->values[2*numnodes*(2*i+0)+2*j+0]+=gauss->weight*Jdet*2.*mu_prime*eps1dotdphij*eps1dotdphii;
2413  Ke->values[2*numnodes*(2*i+0)+2*j+1]+=gauss->weight*Jdet*2.*mu_prime*eps2dotdphij*eps1dotdphii;
2414  Ke->values[2*numnodes*(2*i+1)+2*j+0]+=gauss->weight*Jdet*2.*mu_prime*eps1dotdphij*eps2dotdphii;
2415  Ke->values[2*numnodes*(2*i+1)+2*j+1]+=gauss->weight*Jdet*2.*mu_prime*eps2dotdphij*eps2dotdphii;
2416  }
2417  }
2418  }
2419 
2420  /*Transform Coordinate System*/
2421  element->TransformStiffnessMatrixCoord(Ke,XYEnum);
2422 
2423  /*Clean up and return*/
2424  delete gauss;
2425  xDelete<IssmDouble>(xyz_list);
2426  xDelete<IssmDouble>(dbasis);
2427  return Ke;
2428 }/*}}}*/

◆ CreateKMatrixHO()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixHO ( Element *  element)

Definition at line 2429 of file StressbalanceAnalysis.cpp.

2429  {/*{{{*/
2430 
2431  /* Check if ice in element */
2432  if(!element->IsIceInElement()) return NULL;
2433 
2434  /*compute all stiffness matrices for this element*/
2435  ElementMatrix* Ke1=CreateKMatrixHOViscous(element);
2436  ElementMatrix* Ke2=CreateKMatrixHOFriction(element);
2437  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
2438 
2439  /*clean-up and return*/
2440  delete Ke1;
2441  delete Ke2;
2442  return Ke;
2443 }/*}}}*/

◆ CreateKMatrixHOFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixHOFriction ( Element *  element)

Definition at line 2444 of file StressbalanceAnalysis.cpp.

2444  {/*{{{*/
2445 
2446  /* Check if ice in element */
2447  if(!element->IsIceInElement()) return NULL;
2448 
2449  if(element->IsFloating() || !element->IsOnBase()) return NULL;
2450 
2451  /*Intermediaries*/
2452  int dim;
2453  bool mainlyfloating;
2454  int friction_style,point1;
2455  IssmDouble alpha2,Jdet,fraction1,fraction2;
2456  IssmDouble gllevelset,phi=1.;
2457  IssmDouble *xyz_list_base = NULL;
2458  Gauss* gauss = NULL;
2459 
2460  /*Get problem dimension*/
2461  element->FindParam(&dim,DomainDimensionEnum);
2462 
2463  /*Fetch number of nodes and dof for this finite element*/
2464  int numnodes = element->GetNumberOfNodes();
2465  int numdof = numnodes*(dim-1);
2466 
2467  /*Initialize Element matrix and vectors*/
2468  ElementMatrix* Ke = element->NewElementMatrix(HOApproximationEnum);
2469  IssmDouble* basis = xNew<IssmDouble>(numnodes);
2470 
2471  /*Retrieve all inputs and parameters*/
2472  element->GetVerticesCoordinatesBase(&xyz_list_base);
2473  element->FindParam(&friction_style,GroundinglineFrictionInterpolationEnum);
2474  Input2* gllevelset_input = NULL;
2475 
2476  /*build friction object, used later on: */
2477  Friction* friction=new Friction(element,dim==3?2:1);
2478 
2479  /*Recover portion of element that is grounded*/
2480  if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list_base);
2481  if(friction_style==SubelementFriction2Enum){
2482  gllevelset_input=element->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
2483  element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
2484  gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
2485  }
2486  else{
2487  gauss=element->NewGaussBase(2);
2488  }
2489 
2490  /* Start looping on the number of gaussian points: */
2491  for(int ig=gauss->begin();ig<gauss->end();ig++){
2492  gauss->GaussPoint(ig);
2493 
2494  friction->GetAlpha2(&alpha2,gauss);
2495  if(friction_style==SubelementFriction1Enum) alpha2=phi*alpha2;
2496  else if(friction_style==SubelementFriction2Enum){
2497  gllevelset_input->GetInputValue(&gllevelset, gauss);
2498  if(gllevelset<0.) alpha2=0.;
2499  }
2500  else if(friction_style==NoFrictionOnPartiallyFloatingEnum){
2501  if (phi<0.99999999) alpha2=0.;
2502  }
2503  else _error_("friction interpolation "<<EnumToStringx(friction_style)<<" not implemented yet");
2504 
2505  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
2506  element->NodalFunctions(basis,gauss);
2507 
2508  if(dim==3){
2509  for(int i=0;i<numnodes;i++){
2510  for(int j=0;j<numnodes;j++){
2511  Ke->values[2*i*2*numnodes+2*j] += alpha2*gauss->weight*Jdet*basis[i]*basis[j];
2512  Ke->values[(2*i+1)*2*numnodes+2*j+1] += alpha2*gauss->weight*Jdet*basis[i]*basis[j];
2513  }
2514  }
2515  }
2516  else{
2517  for(int i=0;i<numnodes;i++){
2518  for(int j=0;j<numnodes;j++){
2519  Ke->values[i*numnodes+j] += alpha2*gauss->weight*Jdet*basis[i]*basis[j];
2520  }
2521  }
2522  }
2523  }
2524 
2525  /*Transform Coordinate System*/
2526  if(dim==3) element->TransformStiffnessMatrixCoord(Ke,XYEnum);
2527 
2528  /*Clean up and return*/
2529  delete gauss;
2530  delete friction;
2531  xDelete<IssmDouble>(xyz_list_base);
2532  xDelete<IssmDouble>(basis);
2533  return Ke;
2534 }/*}}}*/

◆ CreateKMatrixHOViscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixHOViscous ( Element *  element)

Definition at line 2535 of file StressbalanceAnalysis.cpp.

2535  {/*{{{*/
2536 
2537  /* Check if ice in element */
2538  if(!element->IsIceInElement()) return NULL;
2539 
2540  /*Intermediaries*/
2541  int dim,bsize;
2542  IssmDouble viscosity,Jdet;
2543  IssmDouble *xyz_list = NULL;
2544 
2545  /*Get problem dimension*/
2546  element->FindParam(&dim,DomainDimensionEnum);
2547 
2548  /*Fetch number of nodes and dof for this finite element*/
2549  int numnodes = element->GetNumberOfNodes();
2550  int numdof = numnodes*(dim-1);
2551 
2552  /*Initialize Element matrix and vectors*/
2553  ElementMatrix* Ke = element->NewElementMatrix(HOApproximationEnum);
2554  IssmDouble* dbasis = xNew<IssmDouble>(dim*numnodes);
2555 
2556  /*Retrieve all inputs and parameters*/
2557  element->GetVerticesCoordinates(&xyz_list);
2558  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
2559  Input2* vy_input = NULL;
2560  if(dim==3){
2561  vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
2562  }
2563 
2564  /* Start looping on the number of gaussian points: */
2565  Gauss* gauss = element->NewGauss(5);
2566  for(int ig=gauss->begin();ig<gauss->end();ig++){
2567  gauss->GaussPoint(ig);
2568 
2569  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2570  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
2571  element->material->ViscosityHO(&viscosity,dim,xyz_list,gauss,vx_input,vy_input);
2572 
2573  if(dim==3){
2574  for(int i=0;i<numnodes;i++){
2575  for(int j=0;j<numnodes;j++){
2576  Ke->values[2*i*2*numnodes+2*j] += gauss->weight*Jdet*viscosity*(
2577  4.*dbasis[0*numnodes+j]*dbasis[0*numnodes+i] + dbasis[1*numnodes+j]*dbasis[1*numnodes+i] + dbasis[2*numnodes+j]*dbasis[2*numnodes+i]
2578  );
2579  Ke->values[2*i*2*numnodes+2*j+1] += gauss->weight*Jdet*viscosity*(
2580  2.*dbasis[1*numnodes+j]*dbasis[0*numnodes+i] + dbasis[0*numnodes+j]*dbasis[1*numnodes+i]
2581  );
2582  Ke->values[(2*i+1)*2*numnodes+2*j] += gauss->weight*Jdet*viscosity*(
2583  2.*dbasis[0*numnodes+j]*dbasis[1*numnodes+i] + dbasis[1*numnodes+j]*dbasis[0*numnodes+i]
2584  );
2585  Ke->values[(2*i+1)*2*numnodes+2*j+1] += gauss->weight*Jdet*viscosity*(
2586  dbasis[0*numnodes+j]*dbasis[0*numnodes+i] + 4.*dbasis[1*numnodes+j]*dbasis[1*numnodes+i] + dbasis[2*numnodes+j]*dbasis[2*numnodes+i]
2587  );
2588  }
2589  }
2590  }
2591  else{
2592  for(int i=0;i<numnodes;i++){
2593  for(int j=0;j<numnodes;j++){
2594  Ke->values[i*numnodes+j] += gauss->weight*Jdet*viscosity*(
2595  4.*dbasis[0*numnodes+j]*dbasis[0*numnodes+i] + dbasis[1*numnodes+j]*dbasis[1*numnodes+i]
2596  );
2597  }
2598  }
2599  }
2600  }
2601 
2602  /*Transform Coordinate System*/
2603  if(dim==3) element->TransformStiffnessMatrixCoord(Ke,XYEnum);
2604 
2605  /*Clean up and return*/
2606  delete gauss;
2607  xDelete<IssmDouble>(xyz_list);
2608  xDelete<IssmDouble>(dbasis);
2609  return Ke;
2610 }/*}}}*/

◆ CreatePVectorHO()

ElementVector * StressbalanceAnalysis::CreatePVectorHO ( Element *  element)

Definition at line 2668 of file StressbalanceAnalysis.cpp.

2668  {/*{{{*/
2669 
2670  /* Check if ice in element */
2671  if(!element->IsIceInElement()) return NULL;
2672 
2673  /*compute all load vectors for this element*/
2674  ElementVector* pe1=CreatePVectorHODrivingStress(element);
2675  ElementVector* pe2=CreatePVectorHOFront(element);
2676  ElementVector* pe =new ElementVector(pe1,pe2);
2677 
2678  /*clean-up and return*/
2679  delete pe1;
2680  delete pe2;
2681  return pe;
2682 }/*}}}*/

◆ CreatePVectorHOFront()

ElementVector * StressbalanceAnalysis::CreatePVectorHOFront ( Element *  element)

Definition at line 2733 of file StressbalanceAnalysis.cpp.

2733  {/*{{{*/
2734 
2735  /* Check if ice in element */
2736  if(!element->IsIceInElement()) return NULL;
2737 
2738  /*If no front, return NULL*/
2739  if(!element->IsIcefront()) return NULL;
2740 
2741  /*Intermediaries*/
2742  int dim;
2743  IssmDouble Jdet,surface,sealevel,z,water_pressure,ice_pressure;
2744  IssmDouble surface_under_water,base_under_water,pressure;
2745  IssmDouble* xyz_list = NULL;
2746  IssmDouble* xyz_list_front = NULL;
2747  IssmDouble normal[3];
2748  Gauss* gauss = NULL;
2749 
2750  /*Get problem dimension*/
2751  element->FindParam(&dim,DomainDimensionEnum);
2752 
2753  /*Fetch number of nodes and dof for this finite element*/
2754  int numnodes = element->GetNumberOfNodes();
2755  int numvertices = element->GetNumberOfVertices();
2756 
2757  /*Initialize Element vector and other vectors*/
2758  ElementVector* pe = element->NewElementVector(HOApproximationEnum);
2759  IssmDouble* basis = xNew<IssmDouble>(numnodes);
2760 
2761  /*Retrieve all inputs and parameters*/
2762  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
2763  Input2* sealevel_input = element->GetInput2(SealevelEnum); _assert_(sealevel_input);
2764  IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
2765  IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum);
2766  IssmDouble gravity = element->FindParam(ConstantsGEnum);
2767  element->GetVerticesCoordinates(&xyz_list);
2768  element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
2769  element->NormalSection(&normal[0],xyz_list_front);
2770 
2771  /*Initialize gauss points*/
2772  IssmDouble zmax=xyz_list[0*3+(dim-1)]; for(int i=1;i<numvertices;i++) if(xyz_list[i*3+(dim-1)]>zmax) zmax=xyz_list[i*3+(dim-1)];
2773  IssmDouble zmin=xyz_list[0*3+(dim-1)]; for(int i=1;i<numvertices;i++) if(xyz_list[i*3+(dim-1)]<zmin) zmin=xyz_list[i*3+(dim-1)];
2774  if(zmax>0. && zmin<0.) gauss=element->NewGauss(xyz_list,xyz_list_front,3,10);//refined in vertical because of the sea level discontinuity
2775  else gauss=element->NewGauss(xyz_list,xyz_list_front,3,3);
2776 
2777  /* Start looping on the number of gaussian points: */
2778  for(int ig=gauss->begin();ig<gauss->end();ig++){
2779 
2780  gauss->GaussPoint(ig);
2781  surface_input->GetInputValue(&surface,gauss);
2782  sealevel_input->GetInputValue(&sealevel,gauss);
2783  if(dim==3) z=element->GetZcoord(xyz_list,gauss);
2784  else z=element->GetYcoord(xyz_list,gauss);
2785  element->NodalFunctions(basis,gauss);
2786  element->JacobianDeterminantSurface(&Jdet,xyz_list_front,gauss);
2787 
2788  water_pressure = rho_water*gravity*min(0.,z-sealevel);//0 if the gaussian point is above water level
2789  ice_pressure = rho_ice*gravity*(surface-z);
2790  pressure = ice_pressure + water_pressure;
2791 
2792  for (int i=0;i<numnodes;i++){
2793  pe->values[(dim-1)*i+0]+= pressure*Jdet*gauss->weight*normal[0]*basis[i];
2794  if(dim==3) pe->values[(dim-1)*i+1]+= pressure*Jdet*gauss->weight*normal[1]*basis[i];
2795  }
2796  }
2797 
2798  /*Transform coordinate system*/
2799  if(dim==3)element->TransformLoadVectorCoord(pe,XYEnum);
2800 
2801  /*Clean up and return*/
2802  xDelete<IssmDouble>(basis);
2803  xDelete<IssmDouble>(xyz_list);
2804  xDelete<IssmDouble>(xyz_list_front);
2805  delete gauss;
2806  return pe;
2807 }/*}}}*/

◆ CreatePVectorHODrivingStress()

ElementVector * StressbalanceAnalysis::CreatePVectorHODrivingStress ( Element *  element)

Definition at line 2684 of file StressbalanceAnalysis.cpp.

2684  {/*{{{*/
2685 
2686  /* Check if ice in element */
2687  if(!element->IsIceInElement()) return NULL;
2688 
2689  /*Intermediaries */
2690  int dim;
2691  IssmDouble Jdet,slope[3];
2692  IssmDouble* xyz_list = NULL;
2693 
2694  /*Get problem dimension*/
2695  element->FindParam(&dim,DomainDimensionEnum);
2696 
2697  /*Fetch number of nodes and dof for this finite element*/
2698  int numnodes = element->GetNumberOfNodes();
2699 
2700  /*Initialize Element vector and vectors*/
2701  ElementVector* pe=element->NewElementVector(HOApproximationEnum);
2702  IssmDouble* basis = xNew<IssmDouble>(numnodes);
2703 
2704  /*Retrieve all inputs and parameters*/
2705  element->GetVerticesCoordinates(&xyz_list);
2706  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
2707  IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
2708 
2709  /* Start looping on the number of gaussian points: */
2710  Gauss* gauss=element->NewGauss(3);
2711  for(int ig=gauss->begin();ig<gauss->end();ig++){
2712  gauss->GaussPoint(ig);
2713 
2714  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2715  element->NodalFunctions(basis, gauss);
2716  surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
2717 
2718  for(int i=0;i<numnodes;i++){
2719  pe->values[i*(dim-1)+0]+=-rhog*slope[0]*Jdet*gauss->weight*basis[i];
2720  if(dim==3) pe->values[i*(dim-1)+1]+=-rhog*slope[1]*Jdet*gauss->weight*basis[i];
2721  }
2722  }
2723 
2724  /*Transform coordinate system*/
2725  if(dim==3) element->TransformLoadVectorCoord(pe,XYEnum);
2726 
2727  /*Clean up and return*/
2728  xDelete<IssmDouble>(basis);
2729  xDelete<IssmDouble>(xyz_list);
2730  delete gauss;
2731  return pe;
2732 }/*}}}*/

◆ GetBHO()

void StressbalanceAnalysis::GetBHO ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 2808 of file StressbalanceAnalysis.cpp.

2808  {/*{{{*/
2809  /*Compute B matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 5*2.
2810  * For node i, Bi can be expressed in the actual coordinate system
2811  * by:
2812  * 3D 2D
2813  *
2814  * Bi=[ dh/dx 0 ] Bi=[ dh/dx]
2815  * [ 0 dh/dy ] [ dh/dy]
2816  * [ 1/2*dh/dy 1/2*dh/dx ]
2817  * [ 1/2*dh/dz 0 ]
2818  * [ 0 1/2*dh/dz ]
2819  * where h is the interpolation function for node i.
2820  *
2821  * We assume B has been allocated already, of size: 5x(2*numnodes)
2822  */
2823 
2824  /*Fetch number of nodes for this finite element*/
2825  int numnodes = element->GetNumberOfNodes();
2826 
2827  /*Get nodal functions derivatives*/
2828  IssmDouble* dbasis=xNew<IssmDouble>(dim*numnodes);
2829  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
2830 
2831  /*Build B: */
2832  if(dim==2){
2833  for(int i=0;i<numnodes;i++){
2834  B[numnodes*0+i] = dbasis[0*numnodes+i];
2835  B[numnodes*1+i] = .5*dbasis[1*numnodes+i];
2836  }
2837  }
2838  else{
2839  for(int i=0;i<numnodes;i++){
2840  B[2*numnodes*0+2*i+0] = dbasis[0*numnodes+i];
2841  B[2*numnodes*0+2*i+1] = 0.;
2842  B[2*numnodes*1+2*i+0] = 0.;
2843  B[2*numnodes*1+2*i+1] = dbasis[1*numnodes+i];
2844  B[2*numnodes*2+2*i+0] = .5*dbasis[1*numnodes+i];
2845  B[2*numnodes*2+2*i+1] = .5*dbasis[0*numnodes+i];
2846  B[2*numnodes*3+2*i+0] = .5*dbasis[2*numnodes+i];
2847  B[2*numnodes*3+2*i+1] = 0.;
2848  B[2*numnodes*4+2*i+0] = 0.;
2849  B[2*numnodes*4+2*i+1] = .5*dbasis[2*numnodes+i];
2850  }
2851  }
2852 
2853  /*Clean-up*/
2854  xDelete<IssmDouble>(dbasis);
2855 }/*}}}*/

◆ GetBHOFriction()

void StressbalanceAnalysis::GetBHOFriction ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 2856 of file StressbalanceAnalysis.cpp.

2856  {/*{{{*/
2857  /*Compute B matrix. B=[B1 B2 B3] where Bi is square and of size 2.
2858  * For node i, Bi can be expressed in the actual coordinate system
2859  * by:
2860  * 3D 2D
2861  * Bi=[ N 0 ] Bi=N
2862  * [ 0 N ]
2863  * where N is the finiteelement function for node i.
2864  *
2865  * We assume B has been allocated already, of size: 2 x (numdof*numnodes)
2866  */
2867 
2868  /*Fetch number of nodes for this finite element*/
2869  int numnodes = element->GetNumberOfNodes();
2870 
2871  /*Get nodal functions derivatives*/
2872  IssmDouble* basis=xNew<IssmDouble>(numnodes);
2873  element->NodalFunctions(basis,gauss);
2874 
2875  /*Build L: */
2876  if(dim==3){
2877  for(int i=0;i<numnodes;i++){
2878  B[2*numnodes*0+2*i+0] = basis[i];
2879  B[2*numnodes*0+2*i+1] = 0.;
2880  B[2*numnodes*1+2*i+0] = 0.;
2881  B[2*numnodes*1+2*i+1] = basis[i];
2882  }
2883  }
2884  else{
2885  for(int i=0;i<numnodes;i++){
2886  B[i] = basis[i];
2887  }
2888  }
2889 
2890  /*Clean-up*/
2891  xDelete<IssmDouble>(basis);
2892 }/*}}}*/

◆ GetBHOprime()

void StressbalanceAnalysis::GetBHOprime ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 2893 of file StressbalanceAnalysis.cpp.

2893  {/*{{{*/
2894  /*Compute B' matrix. B'=[B1' B2' B3'] where Bi' is of size 3*2.
2895  * For node i, Bi' can be expressed in the actual coordinate system
2896  * by:
2897  * 3D 2D
2898  * Bi_prime=[ 2*dN/dx dN/dy ] Bi_prime=[ 2*dN/dx ]
2899  * [ dN/dx 2*dN/dy ] [ dN/dy ]
2900  * [ dN/dy dN/dx ]
2901  * where hNis the finiteelement function for node i.
2902  *
2903  * We assume B' has been allocated already, of size: 3x(2*numnodes)
2904  */
2905 
2906  /*Fetch number of nodes for this finite element*/
2907  int numnodes = element->GetNumberOfNodes();
2908 
2909  /*Get nodal functions derivatives*/
2910  IssmDouble* dbasis=xNew<IssmDouble>(dim*numnodes);
2911  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
2912 
2913  /*Build B': */
2914  if(dim==3){
2915  for(int i=0;i<numnodes;i++){
2916  Bprime[2*numnodes*0+2*i+0] = 2.*dbasis[0*numnodes+i];
2917  Bprime[2*numnodes*0+2*i+1] = dbasis[1*numnodes+i];
2918  Bprime[2*numnodes*1+2*i+0] = dbasis[0*numnodes+i];
2919  Bprime[2*numnodes*1+2*i+1] = 2.*dbasis[1*numnodes+i];
2920  Bprime[2*numnodes*2+2*i+0] = dbasis[1*numnodes+i];
2921  Bprime[2*numnodes*2+2*i+1] = dbasis[0*numnodes+i];
2922  Bprime[2*numnodes*3+2*i+0] = dbasis[2*numnodes+i];
2923  Bprime[2*numnodes*3+2*i+1] = 0.;
2924  Bprime[2*numnodes*4+2*i+0] = 0.;
2925  Bprime[2*numnodes*4+2*i+1] = dbasis[2*numnodes+i];
2926  }
2927  }
2928  else{
2929  for(int i=0;i<numnodes;i++){
2930  Bprime[numnodes*0+i] = 2.*dbasis[0*numnodes+i];
2931  Bprime[numnodes*1+i] = dbasis[1*numnodes+i];
2932  }
2933  }
2934 
2935  /*Clean-up*/
2936  xDelete<IssmDouble>(dbasis);
2937 }/*}}}*/

◆ InputUpdateFromSolutionHO()

void StressbalanceAnalysis::InputUpdateFromSolutionHO ( IssmDouble *  solution,
Element *  element 
)

Definition at line 2938 of file StressbalanceAnalysis.cpp.

2938  {/*{{{*/
2939 
2940  int i,domaintype,dim;
2941  int* doflist=NULL;
2942  IssmDouble* xyz_list=NULL;
2943 
2944  /*Deal with pressure first*/
2945  int numvertices = element->GetNumberOfVertices();
2946  IssmDouble* pressure = xNew<IssmDouble>(numvertices);
2947  IssmDouble* surface = xNew<IssmDouble>(numvertices);
2948 
2949  element->FindParam(&domaintype,DomainTypeEnum);
2950  IssmDouble rho_ice =element->FindParam(MaterialsRhoIceEnum);
2951  IssmDouble g =element->FindParam(ConstantsGEnum);
2952  switch(domaintype){
2953  case Domain3DEnum:
2954  element->GetVerticesCoordinates(&xyz_list);
2955  element->GetInputListOnVertices(surface,SurfaceEnum);
2956  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
2957  dim=3;
2958  break;
2959  case Domain2DverticalEnum:
2960  element->GetVerticesCoordinates(&xyz_list);
2961  element->GetInputListOnVertices(surface,SurfaceEnum);
2962  for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+1]);
2963  dim=2;
2964  break;
2965  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
2966  }
2967  element->AddInput2(PressureEnum,pressure,P1Enum);
2968  xDelete<IssmDouble>(pressure);
2969  xDelete<IssmDouble>(surface);
2970 
2971  /*Fetch number of nodes and dof for this finite element*/
2972  int numnodes = element->GetNumberOfNodes();
2973  int numdof = numnodes*(dim-1);
2974 
2975  /*Fetch dof list and allocate solution vectors*/
2976  element->GetDofListLocal(&doflist,HOApproximationEnum,GsetEnum);
2977  IssmDouble* values = xNew<IssmDouble>(numdof);
2978  IssmDouble* vx = xNew<IssmDouble>(numnodes);
2979  IssmDouble* vy = xNew<IssmDouble>(numnodes);
2980  IssmDouble* vz = xNew<IssmDouble>(numnodes);
2981  IssmDouble* vel = xNew<IssmDouble>(numnodes);
2982 
2983  /*Use the dof list to index into the solution vector: */
2984  for(i=0;i<numdof;i++) values[i]=solution[doflist[i]];
2985 
2986  /*Transform solution in Cartesian Space*/
2987  if(dim==3) element->TransformSolutionCoord(&values[0],XYEnum);
2988 
2989  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
2990  for(i=0;i<numnodes;i++){
2991  vx[i]=values[i*(dim-1)+0];
2992  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
2993  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
2994  if(dim==3){
2995  vy[i]=values[i*(dim-1)+1];
2996  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
2997  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
2998  }
2999  }
3000 
3001  /*Get Vz and compute vel*/
3002  if(dim==3){
3003  element->GetInputListOnNodes(&vz[0],VzEnum,0.);
3004  for(i=0;i<numnodes;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
3005  }
3006  else{
3007  element->GetInputListOnNodes(&vy[0],VyEnum,0.);
3008  for(i=0;i<numnodes;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i]);
3009  }
3010 
3011  /*Add vx and vy as inputs to the element: */
3012  element->AddInput2(VxEnum,vx,element->GetElementType());
3013  if(dim==3)element->AddInput2(VyEnum,vy,element->GetElementType());
3014  element->AddInput2(VelEnum,vel,element->GetElementType());
3015 
3016  /*Free ressources:*/
3017  xDelete<IssmDouble>(vel);
3018  xDelete<IssmDouble>(vz);
3019  xDelete<IssmDouble>(vy);
3020  xDelete<IssmDouble>(vx);
3021  xDelete<IssmDouble>(values);
3022  xDelete<IssmDouble>(xyz_list);
3023  xDelete<int>(doflist);
3024 }/*}}}*/

◆ CreateDVectorFS()

ElementVector * StressbalanceAnalysis::CreateDVectorFS ( Element *  element)

Definition at line 3027 of file StressbalanceAnalysis.cpp.

3027  {/*{{{*/
3028 
3029  int dim;
3030 
3031  /*Get problem dimension*/
3032  element->FindParam(&dim,DomainDimensionEnum);
3033 
3034  /*Fetch number of nodes and dof for this finite element*/
3035  int vnumnodes = element->NumberofNodesVelocity();
3036  int pnumnodes = element->NumberofNodesPressure();
3037 
3038  /*Initialize output vector*/
3039  ElementVector* de = element->NewElementVector(FSvelocityEnum);
3040 
3041  for(int i=0;i<vnumnodes;i++){
3042  for(int j=0;j<dim;j++) de->values[i*dim+j]=VelocityEnum;
3043  }
3044  for(int i=0;i<pnumnodes;i++){
3045  de->values[vnumnodes*dim+i]=PressureEnum;
3046  }
3047 
3048  return de;
3049 
3050 }/*}}}*/

◆ CreateJacobianMatrixFS()

ElementMatrix * StressbalanceAnalysis::CreateJacobianMatrixFS ( Element *  element)

Definition at line 3051 of file StressbalanceAnalysis.cpp.

3051  {/*{{{*/
3052 
3053  /*Intermediaries */
3054  int i,j;
3055  IssmDouble Jdet;
3056  IssmDouble eps1dotdphii,eps1dotdphij;
3057  IssmDouble eps2dotdphii,eps2dotdphij;
3058  IssmDouble eps3dotdphii,eps3dotdphij;
3059  IssmDouble mu_prime;
3060  IssmDouble epsilon[6]; /* epsilon=[exx,eyy,ezz,exy,exz,eyz];*/
3061  IssmDouble eps1[3],eps2[3],eps3[3];
3062  IssmDouble *xyz_list = NULL;
3063 
3064  /*Fetch number of nodes and dof for this finite element*/
3065  int vnumnodes = element->NumberofNodesVelocity();
3066  int pnumnodes = element->NumberofNodesPressure();
3067  int numdof = vnumnodes*3 + pnumnodes*1;
3068 
3069  /*Prepare coordinate system list*/
3070  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
3071  for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
3072  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
3073 
3074  /*Initialize Element matrix, vectors and Gaussian points*/
3075  ElementMatrix* Ke=this->CreateKMatrixFS(element); //Initialize Jacobian with regular FS (first part of the Gateau derivative)
3076  IssmDouble* dbasis = xNew<IssmDouble>(3*vnumnodes);
3077 
3078  /*Retrieve all inputs and parameters*/
3079  element->GetVerticesCoordinates(&xyz_list);
3080  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
3081  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
3082  Input2* vz_input = element->GetInput2(VzEnum); _assert_(vz_input);
3083 
3084  /* Start looping on the number of gaussian points: */
3085  Gauss* gauss = element->NewGauss(5);
3086  for(int ig=gauss->begin();ig<gauss->end();ig++){
3087  gauss->GaussPoint(ig);
3088 
3089  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
3090  element->NodalFunctionsDerivativesVelocity(dbasis,xyz_list,gauss);
3091 
3092  //element->StrainRateFS(&epsilon[0],xyz_list,gauss,vx_input,vy_input,vz_input);
3093  //eps1[0]=epsilon[0]; eps2[0]=epsilon[3]; eps3[0]=epsilon[4];
3094  //eps1[1]=epsilon[3]; eps2[1]=epsilon[1]; eps3[1]=epsilon[5];
3095  //eps1[2]=epsilon[4]; eps2[2]=epsilon[5]; eps3[2]=epsilon[2];
3096  element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
3097  eps1[0]=epsilon[0]; eps2[0]=epsilon[2]; eps3[0]=epsilon[3];
3098  eps1[1]=epsilon[2]; eps2[1]=epsilon[1]; eps3[1]=epsilon[4];
3099  eps1[2]=epsilon[3]; eps2[2]=epsilon[4]; eps3[2]= -epsilon[0] -epsilon[1];
3100  element->material->ViscosityFSDerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
3101 
3102  for(i=0;i<vnumnodes;i++){
3103  for(j=0;j<vnumnodes;j++){
3104  eps1dotdphii=eps1[0]*dbasis[0*vnumnodes+i]+eps1[1]*dbasis[1*vnumnodes+i]+eps1[2]*dbasis[2*vnumnodes+i];
3105  eps1dotdphij=eps1[0]*dbasis[0*vnumnodes+j]+eps1[1]*dbasis[1*vnumnodes+j]+eps1[2]*dbasis[2*vnumnodes+j];
3106  eps2dotdphii=eps2[0]*dbasis[0*vnumnodes+i]+eps2[1]*dbasis[1*vnumnodes+i]+eps2[2]*dbasis[2*vnumnodes+i];
3107  eps2dotdphij=eps2[0]*dbasis[0*vnumnodes+j]+eps2[1]*dbasis[1*vnumnodes+j]+eps2[2]*dbasis[2*vnumnodes+j];
3108  eps3dotdphii=eps3[0]*dbasis[0*vnumnodes+i]+eps3[1]*dbasis[1*vnumnodes+i]+eps3[2]*dbasis[2*vnumnodes+i];
3109  eps3dotdphij=eps3[0]*dbasis[0*vnumnodes+j]+eps3[1]*dbasis[1*vnumnodes+j]+eps3[2]*dbasis[2*vnumnodes+j];
3110 
3111  Ke->values[numdof*(3*i+0)+3*j+0]+=gauss->weight*Jdet*2*mu_prime*eps1dotdphij*eps1dotdphii;
3112  Ke->values[numdof*(3*i+0)+3*j+1]+=gauss->weight*Jdet*2*mu_prime*eps2dotdphij*eps1dotdphii;
3113  Ke->values[numdof*(3*i+0)+3*j+2]+=gauss->weight*Jdet*2*mu_prime*eps3dotdphij*eps1dotdphii;
3114 
3115  Ke->values[numdof*(3*i+1)+3*j+0]+=gauss->weight*Jdet*2*mu_prime*eps1dotdphij*eps2dotdphii;
3116  Ke->values[numdof*(3*i+1)+3*j+1]+=gauss->weight*Jdet*2*mu_prime*eps2dotdphij*eps2dotdphii;
3117  Ke->values[numdof*(3*i+1)+3*j+2]+=gauss->weight*Jdet*2*mu_prime*eps3dotdphij*eps2dotdphii;
3118 
3119  Ke->values[numdof*(3*i+2)+3*j+0]+=gauss->weight*Jdet*2*mu_prime*eps1dotdphij*eps3dotdphii;
3120  Ke->values[numdof*(3*i+2)+3*j+1]+=gauss->weight*Jdet*2*mu_prime*eps2dotdphij*eps3dotdphii;
3121  Ke->values[numdof*(3*i+2)+3*j+2]+=gauss->weight*Jdet*2*mu_prime*eps3dotdphij*eps3dotdphii;
3122  }
3123  }
3124  }
3125 
3126  /*Transform Coordinate System*/
3127  element->TransformStiffnessMatrixCoord(Ke,cs_list);
3128 
3129  /*Clean up and return*/
3130  delete gauss;
3131  xDelete<IssmDouble>(xyz_list);
3132  xDelete<IssmDouble>(dbasis);
3133  xDelete<int>(cs_list);
3134  return Ke;
3135 }/*}}}*/

◆ CreateKMatrixFS()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixFS ( Element *  element)

Definition at line 3136 of file StressbalanceAnalysis.cpp.

3136  {/*{{{*/
3137 
3138  /* Check if ice in element */
3139  if(!element->IsIceInElement()) return NULL;
3140 
3141  /*Get type of algorithm*/
3142  int fe_FS;
3143  element->FindParam(&fe_FS,FlowequationFeFSEnum);
3144 
3145  /*compute all stiffness matrices for this element*/
3146  ElementMatrix* Ke1=NULL;
3147  if(fe_FS==XTaylorHoodEnum)
3148  Ke1=CreateKMatrixFSViscousXTH(element);
3149  else if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum)
3150  Ke1=CreateKMatrixFSViscousLA(element);
3151  else
3152  Ke1=CreateKMatrixFSViscous(element);
3153 
3154  ElementMatrix* Ke2=CreateKMatrixFSFriction(element);
3155  ElementMatrix* Ke3=CreateKMatrixFSShelf(element);
3156  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3);
3157 
3158  /*clean-up and return*/
3159  delete Ke1;
3160  delete Ke2;
3161  delete Ke3;
3162  return Ke;
3163 }/*}}}*/

◆ CreateKMatrixFSFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixFSFriction ( Element *  element)

Definition at line 3922 of file StressbalanceAnalysis.cpp.

3922  {/*{{{*/
3923 
3924  if(element->IsFloating() || !element->IsOnBase()) return NULL;
3925 
3926  /*If on water or not FS, skip stiffness: */
3927  int approximation;
3928  element->GetInput2Value(&approximation,ApproximationEnum);
3929  if(approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum && approximation!=HOFSApproximationEnum) return NULL;
3930 
3931  /*Intermediaries*/
3932  bool mainlyfloating;
3933  int dim,domaintype;
3934  int friction_style,point1;
3935  IssmDouble alpha2,Jdet,fraction1,fraction2;
3936  IssmDouble gllevelset,phi=1.;
3937  IssmDouble *xyz_list_base = NULL;
3938  Gauss* gauss = NULL;
3939 
3940  /*Get problem dimension*/
3941  element->FindParam(&dim,DomainDimensionEnum);
3942  element->FindParam(&domaintype,DomainTypeEnum);
3943 
3944  /*Fetch number of nodes and dof for this finite element*/
3945  int vnumnodes = element->NumberofNodesVelocity();
3946  int pnumnodes = element->NumberofNodesPressure();
3947  int numdof = vnumnodes*dim + pnumnodes;
3948 
3949  /*Initialize Element matrix and vectors*/
3950  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3951  IssmDouble* vbasis=xNew<IssmDouble>(vnumnodes);
3952 
3953  /*Retrieve all inputs and parameters*/
3954  element->GetVerticesCoordinatesBase(&xyz_list_base);
3955  element->FindParam(&friction_style,GroundinglineFrictionInterpolationEnum);
3956  Input2* gllevelset_input = NULL;
3957 
3958  /*build friction object, used later on: */
3959  Friction* friction=new Friction(element,dim==3?3:1);
3960 
3961  /*Recover portion of element that is grounded*/
3962  if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list_base);
3963  if(friction_style==SubelementFriction2Enum){
3964  if(domaintype==Domain2DverticalEnum) _error_("Subelement Friction 2 not implemented yet for Flowline");
3965  gllevelset_input=element->GetInput2(MaskOceanLevelsetEnum); _assert_(gllevelset_input);
3966  element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
3967  //gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
3968  gauss=element->NewGaussBase(3);
3969  }
3970  else{
3971  gauss=element->NewGaussBase(3);
3972  }
3973 
3974  /* Start looping on the number of gaussian points: */
3975  for(int ig=gauss->begin();ig<gauss->end();ig++){
3976  gauss->GaussPoint(ig);
3977 
3978  friction->GetAlpha2(&alpha2,gauss);
3979  if(friction_style==SubelementFriction1Enum) alpha2=phi*alpha2;
3980  else if(friction_style==SubelementFriction2Enum){
3981  gllevelset_input->GetInputValue(&gllevelset, gauss);
3982  if(gllevelset<0.) alpha2=0.;
3983  }
3984  else if(friction_style==NoFrictionOnPartiallyFloatingEnum){
3985  if (phi<0.99999999) alpha2=0.;
3986  }
3987  else _error_("friction interpolation "<<EnumToStringx(friction_style)<<" not implemented yet");
3988 
3989  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
3990  element->NodalFunctionsVelocity(vbasis,gauss);
3991 
3992  if(dim==3){
3993  /*Stress balance*/
3994  for(int i=0;i<vnumnodes;i++){
3995  for(int j=0;j<vnumnodes;j++){
3996  Ke->values[(3*i+0)*numdof+3*j+0] += alpha2*gauss->weight*Jdet*vbasis[i]*vbasis[j];
3997  Ke->values[(3*i+1)*numdof+3*j+1] += alpha2*gauss->weight*Jdet*vbasis[i]*vbasis[j];
3998  Ke->values[(3*i+2)*numdof+3*j+2] += alpha2*gauss->weight*Jdet*vbasis[i]*vbasis[j];
3999  }
4000  }
4001  }
4002  else{
4003  /*Stress balance*/
4004  for(int i=0;i<vnumnodes;i++){
4005  for(int j=0;j<vnumnodes;j++){
4006  Ke->values[(2*i+0)*numdof+2*j+0] += alpha2*gauss->weight*Jdet*vbasis[i]*vbasis[j];
4007  Ke->values[(2*i+1)*numdof+2*j+1] += alpha2*gauss->weight*Jdet*vbasis[i]*vbasis[j];
4008  }
4009  }
4010  }
4011  }
4012 
4013  /*DO NOT Transform Coordinate System: this stiffness matrix is already expressed in tangential coordinates*/
4014 
4015  /*Clean up and return*/
4016  delete gauss;
4017  delete friction;
4018  xDelete<IssmDouble>(xyz_list_base);
4019  xDelete<IssmDouble>(vbasis);
4020  return Ke;
4021 }/*}}}*/

◆ CreateKMatrixFSShelf()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixFSShelf ( Element *  element)

Definition at line 3164 of file StressbalanceAnalysis.cpp.

3164  {/*{{{*/
3165 
3166  if(!element->IsFloating() || !element->IsOnBase()) return NULL;
3167 
3168  /*If on not water or not FS, skip stiffness: */
3169  int approximation,shelf_dampening;
3170  element->GetInput2Value(&approximation,ApproximationEnum);
3171  if(approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum && approximation!=HOFSApproximationEnum) return NULL;
3172  element->FindParam(&shelf_dampening,StressbalanceShelfDampeningEnum);
3173  if(shelf_dampening==0) return NULL;
3174 
3175  /*Intermediaries*/
3176  bool mainlyfloating;
3177  int j,i,dim;
3178  IssmDouble Jdet,slope2,scalar,dt;
3179  IssmDouble slope[3];
3180  IssmDouble *xyz_list_base = NULL;
3181  IssmDouble *xyz_list = NULL;
3182  Gauss* gauss = NULL;
3183 
3184  /*Get problem dimension*/
3185  element->FindParam(&dim,DomainDimensionEnum);
3186 
3187  /*Fetch number of nodes and dof for this finite element*/
3188  int vnumnodes = element->NumberofNodesVelocity();
3189  int pnumnodes = element->NumberofNodesPressure();
3190  int numdof = vnumnodes*dim + pnumnodes;
3191 
3192  /*Initialize Element matrix and vectors*/
3193  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3194  IssmDouble* vbasis = xNew<IssmDouble>(vnumnodes);
3195 
3196  /*Retrieve all inputs and parameters*/
3197  element->GetVerticesCoordinatesBase(&xyz_list_base);
3198  element->GetVerticesCoordinates(&xyz_list);
3199  element->FindParam(&dt,TimesteppingTimeStepEnum);
3200  if(dt==0) dt=1.e+5;
3201  IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
3202  IssmDouble gravity = element->FindParam(ConstantsGEnum);
3203  Input2* base_input = element->GetInput2(BaseEnum); _assert_(base_input);
3204 
3205  /* Start looping on the number of gaussian points: */
3206  gauss=element->NewGaussBase(3);
3207  for(int ig=gauss->begin();ig<gauss->end();ig++){
3208  gauss->GaussPoint(ig);
3209 
3210  base_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
3211  element->NodalFunctionsVelocity(vbasis,gauss);
3212  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
3213  if(dim==2) slope2=slope[0]*slope[0];
3214  else if(dim==3) slope2=slope[0]*slope[0]+slope[1]*slope[1];
3215  scalar = rho_water*gravity*sqrt(1+slope2)*gauss->weight*Jdet*dt;
3216  for(i=0;i<vnumnodes;i++){
3217  for(j=0;j<vnumnodes;j++){
3218  Ke->values[numdof*((i+1)*dim-1)+(j+1)*dim-1] += scalar*vbasis[i]*vbasis[j];
3219  }
3220  }
3221  }
3222 
3223  /*DO NOT Transform Coordinate System: this stiffness matrix is already expressed in tangential coordinates*/
3224 
3225  /*Clean up and return*/
3226  delete gauss;
3227  xDelete<IssmDouble>(xyz_list_base);
3228  xDelete<IssmDouble>(xyz_list);
3229  xDelete<IssmDouble>(vbasis);
3230  return Ke;
3231 }/*}}}*/

◆ CreateKMatrixFSViscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixFSViscous ( Element *  element)

Definition at line 3232 of file StressbalanceAnalysis.cpp.

3232  {/*{{{*/
3233 
3234  /*Intermediaries*/
3235  int i,dim;
3236  IssmDouble viscosity,FSreconditioning,Jdet;
3237  IssmDouble *xyz_list = NULL;
3238 
3239  /*Get problem dimension*/
3240  element->FindParam(&dim,DomainDimensionEnum);
3241 
3242  /*Fetch number of nodes and dof for this finite element*/
3243  int vnumnodes = element->NumberofNodesVelocity();
3244  int pnumnodes = element->NumberofNodesPressure();
3245  int numdof = vnumnodes*dim + pnumnodes;
3246 
3247  /*Prepare coordinate system list*/
3248  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
3249  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
3250  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
3251  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
3252 
3253  /*Initialize Element matrix and vectors*/
3254  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3255  IssmDouble* vdbasis = xNew<IssmDouble>(dim*vnumnodes);
3256  IssmDouble* pbasis = xNew<IssmDouble>(pnumnodes);
3257 
3258  /*Retrieve all inputs and parameters*/
3259  element->GetVerticesCoordinates(&xyz_list);
3260  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
3261  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
3262  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
3263  Input2* vz_input = NULL;
3264  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
3265 
3266  /* Start looping on the number of gaussian points: */
3267  Gauss* gauss = element->NewGauss(5);
3268  for(int ig=gauss->begin();ig<gauss->end();ig++){
3269  gauss->GaussPoint(ig);
3270 
3271  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
3272  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
3273  element->NodalFunctionsPressure(pbasis,gauss);
3274  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
3275 
3276  if(dim==3){
3277  /*Stress balance*/
3278  for(int i=0;i<vnumnodes;i++){
3279  for(int j=0;j<vnumnodes;j++){
3280  Ke->values[(3*i+0)*numdof+3*j+0] += gauss->weight*Jdet*viscosity*(2.*vdbasis[0*vnumnodes+j]*vdbasis[0*vnumnodes+i] + vdbasis[1*vnumnodes+j]*vdbasis[1*vnumnodes+i] + vdbasis[2*vnumnodes+j]*vdbasis[2*vnumnodes+i]);
3281  Ke->values[(3*i+0)*numdof+3*j+1] += gauss->weight*Jdet*viscosity*(vdbasis[0*vnumnodes+j]*vdbasis[1*vnumnodes+i]);
3282  Ke->values[(3*i+0)*numdof+3*j+2] += gauss->weight*Jdet*viscosity*(vdbasis[0*vnumnodes+j]*vdbasis[2*vnumnodes+i]);
3283  Ke->values[(3*i+1)*numdof+3*j+0] += gauss->weight*Jdet*viscosity*(vdbasis[1*vnumnodes+j]*vdbasis[0*vnumnodes+i]);
3284  Ke->values[(3*i+1)*numdof+3*j+1] += gauss->weight*Jdet*viscosity*(vdbasis[0*vnumnodes+j]*vdbasis[0*vnumnodes+i] + 2.*vdbasis[1*vnumnodes+j]*vdbasis[1*vnumnodes+i] + vdbasis[2*vnumnodes+j]*vdbasis[2*vnumnodes+i]);
3285  Ke->values[(3*i+1)*numdof+3*j+2] += gauss->weight*Jdet*viscosity*(vdbasis[1*vnumnodes+j]*vdbasis[2*vnumnodes+i]);
3286  Ke->values[(3*i+2)*numdof+3*j+0] += gauss->weight*Jdet*viscosity*(vdbasis[2*vnumnodes+j]*vdbasis[0*vnumnodes+i]);
3287  Ke->values[(3*i+2)*numdof+3*j+1] += gauss->weight*Jdet*viscosity*(vdbasis[2*vnumnodes+j]*vdbasis[1*vnumnodes+i]);
3288  Ke->values[(3*i+2)*numdof+3*j+2] += gauss->weight*Jdet*viscosity*(vdbasis[0*vnumnodes+j]*vdbasis[0*vnumnodes+i] + vdbasis[1*vnumnodes+j]*vdbasis[1*vnumnodes+i] + 2.*vdbasis[2*vnumnodes+j]*vdbasis[2*vnumnodes+i]);
3289  }
3290  for(int k=0;k<pnumnodes;k++){
3291  Ke->values[(3*i+0)*numdof+3*vnumnodes+k] += gauss->weight*Jdet*FSreconditioning*(-pbasis[k]*vdbasis[0*vnumnodes+i]);
3292  Ke->values[(3*i+1)*numdof+3*vnumnodes+k] += gauss->weight*Jdet*FSreconditioning*(-pbasis[k]*vdbasis[1*vnumnodes+i]);
3293  Ke->values[(3*i+2)*numdof+3*vnumnodes+k] += gauss->weight*Jdet*FSreconditioning*(-pbasis[k]*vdbasis[2*vnumnodes+i]);
3294  }
3295  }
3296  /*Incompressibility*/
3297  for(int k=0;k<pnumnodes;k++){
3298  for(int j=0;j<vnumnodes;j++){
3299  Ke->values[(3*vnumnodes+k)*numdof+3*j+0] += gauss->weight*Jdet*(-FSreconditioning*vdbasis[0*vnumnodes+j]*pbasis[k]);
3300  Ke->values[(3*vnumnodes+k)*numdof+3*j+1] += gauss->weight*Jdet*(-FSreconditioning*vdbasis[1*vnumnodes+j]*pbasis[k]);
3301  Ke->values[(3*vnumnodes+k)*numdof+3*j+2] += gauss->weight*Jdet*(-FSreconditioning*vdbasis[2*vnumnodes+j]*pbasis[k]);
3302  }
3303  }
3304  }
3305  else{
3306  /*Stress balance*/
3307  for(int i=0;i<vnumnodes;i++){
3308  for(int j=0;j<vnumnodes;j++){
3309  Ke->values[(2*i+0)*numdof+2*j+0] += gauss->weight*Jdet*viscosity*(2.*vdbasis[0*vnumnodes+j]*vdbasis[0*vnumnodes+i] + vdbasis[1*vnumnodes+j]*vdbasis[1*vnumnodes+i]);
3310  Ke->values[(2*i+0)*numdof+2*j+1] += gauss->weight*Jdet*viscosity*(vdbasis[0*vnumnodes+j]*vdbasis[1*vnumnodes+i]);
3311  Ke->values[(2*i+1)*numdof+2*j+0] += gauss->weight*Jdet*viscosity*(vdbasis[1*vnumnodes+j]*vdbasis[0*vnumnodes+i]);
3312  Ke->values[(2*i+1)*numdof+2*j+1] += gauss->weight*Jdet*viscosity*(vdbasis[0*vnumnodes+j]*vdbasis[0*vnumnodes+i] + 2.*vdbasis[1*vnumnodes+j]*vdbasis[1*vnumnodes+i]);
3313  }
3314  for(int k=0;k<pnumnodes;k++){
3315  Ke->values[(2*i+0)*numdof+2*vnumnodes+k] += gauss->weight*Jdet*FSreconditioning*(-pbasis[k]*vdbasis[0*vnumnodes+i]);
3316  Ke->values[(2*i+1)*numdof+2*vnumnodes+k] += gauss->weight*Jdet*FSreconditioning*(-pbasis[k]*vdbasis[1*vnumnodes+i]);
3317  }
3318  }
3319  /*Incompressibility*/
3320  for(int k=0;k<pnumnodes;k++){
3321  for(int j=0;j<vnumnodes;j++){
3322  Ke->values[(2*vnumnodes+k)*numdof+2*j+0] += gauss->weight*Jdet*(-FSreconditioning*vdbasis[0*vnumnodes+j]*pbasis[k]);
3323  Ke->values[(2*vnumnodes+k)*numdof+2*j+1] += gauss->weight*Jdet*(-FSreconditioning*vdbasis[1*vnumnodes+j]*pbasis[k]);
3324  }
3325  }
3326  }
3327  }
3328 
3329  /*Transform Coordinate System*/
3330  element->TransformStiffnessMatrixCoord(Ke,cs_list);
3331 
3332  /*Clean up and return*/
3333  delete gauss;
3334  xDelete<IssmDouble>(xyz_list);
3335  xDelete<IssmDouble>(pbasis);
3336  xDelete<IssmDouble>(vdbasis);
3337  xDelete<int>(cs_list);
3338  return Ke;
3339 }/*}}}*/

◆ CreateKMatrixFSViscousLA()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixFSViscousLA ( Element *  element)

Definition at line 3446 of file StressbalanceAnalysis.cpp.

3446  {/*{{{*/
3447 
3448  /*Intermediaries*/
3449  int i,dim,epssize;
3450  IssmDouble r,rl,Jdet,viscosity,DU,DUl;
3451  IssmDouble normal[3];
3452  IssmDouble *xyz_list = NULL;
3453  IssmDouble *xyz_list_base = NULL;
3454 
3455  /*Get problem dimension*/
3456  element->FindParam(&dim,DomainDimensionEnum);
3457  element->FindParam(&r,AugmentedLagrangianREnum);
3458  if(dim==2) epssize = 3;
3459  else epssize = 6;
3460 
3461  /*Fetch number of nodes and dof for this finite element*/
3462  int vnumnodes = element->NumberofNodesVelocity();
3463  int pnumnodes = element->GetNumberOfNodes(P1Enum);
3464  int lnumnodes = element->GetNumberOfNodes(P2Enum);
3465  int numdof = vnumnodes*dim;
3466  int pnumdof = pnumnodes;
3467  int lnumdof = lnumnodes;
3468 
3469  /*Prepare coordinate system list*/
3470  int* cs_list = xNew<int>(vnumnodes);
3471  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
3472  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
3473 
3474  /*Initialize Element matrix and vectors*/
3475  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3476  IssmDouble* B = xNew<IssmDouble>(epssize*numdof);
3477  IssmDouble* Bprime = xNew<IssmDouble>(epssize*numdof);
3478  IssmDouble* BtBUzawa = xNewZeroInit<IssmDouble>(numdof*pnumdof);
3479  IssmDouble* BU = xNew<IssmDouble>(pnumdof);
3480  IssmDouble* BprimeU = xNew<IssmDouble>(numdof);
3481  IssmDouble* D = xNewZeroInit<IssmDouble>(epssize*epssize);
3482 
3483  /*Retrieve all inputs and parameters*/
3484  element->GetVerticesCoordinates(&xyz_list);
3485  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
3486  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
3487  Input2* vz_input = NULL;
3488  if(dim==3){vz_input = element->GetInput2(VzEnum); _assert_(vz_input);}
3489 
3490  /* Start looping on the number of gaussian points: */
3491  Gauss* gauss = element->NewGauss(5);
3492  for(int ig=gauss->begin();ig<gauss->end();ig++){
3493  gauss->GaussPoint(ig);
3494 
3495  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
3496  this->GetBFSvel(B,element,dim,xyz_list,gauss);
3497  this->GetBFSprimevel(Bprime,element,dim,xyz_list,gauss);
3498 
3499  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
3500  for(i=0;i<epssize;i++) D[i*epssize+i] = 2*viscosity*gauss->weight*Jdet;
3501 
3502  TripleMultiply(B,epssize,numdof,1,
3503  D,epssize,epssize,0,
3504  Bprime,epssize,numdof,0,
3505  &Ke->values[0],1);
3506 
3507  this->GetBFSUzawa(BU,element,dim,xyz_list,gauss);
3508  this->GetBFSprimeUzawa(BprimeU,element,dim,xyz_list,gauss);
3509 
3510  DU = gauss->weight*Jdet*sqrt(r);
3511 
3512  TripleMultiply(BU,1,pnumdof,1,
3513  &DU,1,1,0,
3514  BprimeU,1,numdof,0,
3515  BtBUzawa,1);
3516  }
3517 
3518  /*The pressure augmentation should not be transformed*/
3519  MatrixMultiply(BtBUzawa,pnumdof,numdof,1,
3520  BtBUzawa,pnumdof,numdof,0,
3521  &Ke->values[0],1);
3522 
3523  if(element->IsOnBase() && 0){
3524  element->FindParam(&rl,AugmentedLagrangianRlambdaEnum);
3525  element->GetVerticesCoordinatesBase(&xyz_list_base);
3526  element->NormalBase(&normal[0],xyz_list_base);
3527 
3528  IssmDouble* Dlambda = xNewZeroInit<IssmDouble>(dim*dim);
3529  IssmDouble* C = xNewZeroInit<IssmDouble>(dim*lnumdof);
3530  IssmDouble* Cprime = xNewZeroInit<IssmDouble>(dim*numdof);
3531  IssmDouble* CtCUzawa = xNewZeroInit<IssmDouble>(numdof*lnumdof);
3532 
3533  delete gauss;
3534  gauss = element->NewGaussBase(5);
3535  for(int ig=gauss->begin();ig<gauss->end();ig++){
3536  gauss->GaussPoint(ig);
3537 
3538  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
3539  this->GetCFS(C,element,dim,xyz_list,gauss);
3540  this->GetCFSprime(Cprime,element,dim,xyz_list,gauss);
3541  for(i=0;i<dim;i++) Dlambda[i*dim+i] = gauss->weight*Jdet*sqrt(normal[i]*normal[i])*sqrt(rl);
3542  TripleMultiply(C,dim,lnumdof,1,
3543  Dlambda,dim,dim,0,
3544  Cprime,dim,numdof,0,
3545  CtCUzawa,1);
3546  }
3547 
3548  /*The sigma naugmentation should not be transformed*/
3549  MatrixMultiply(CtCUzawa,lnumdof,numdof,1,
3550  CtCUzawa,lnumdof,numdof,0,
3551  &Ke->values[0],1);
3552 
3553  /*Delete base part*/
3554  xDelete<IssmDouble>(Dlambda);
3555  xDelete<IssmDouble>(C);
3556  xDelete<IssmDouble>(Cprime);
3557  xDelete<IssmDouble>(CtCUzawa);
3558  xDelete<IssmDouble>(xyz_list_base);
3559  }
3560 
3561  /*Transform Coordinate System*/
3562  element->TransformStiffnessMatrixCoord(Ke,cs_list);
3563 
3564  /*Clean up and return*/
3565  delete gauss;
3566  xDelete<IssmDouble>(xyz_list);
3567  xDelete<IssmDouble>(D);
3568  xDelete<IssmDouble>(Bprime);
3569  xDelete<IssmDouble>(B);
3570  xDelete<IssmDouble>(BprimeU);
3571  xDelete<IssmDouble>(BU);
3572  xDelete<IssmDouble>(BtBUzawa);
3573  xDelete<int>(cs_list);
3574  return Ke;
3575 }/*}}}*/

◆ CreateKMatrixFSViscousXTH()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixFSViscousXTH ( Element *  element)

Definition at line 3576 of file StressbalanceAnalysis.cpp.

3576  {/*{{{*/
3577 
3578  /*Intermediaries*/
3579  int i,dim,epssize;
3580  IssmDouble r,FSreconditioning,Jdet;
3581  IssmDouble *xyz_list = NULL;
3582 
3583  /*Get problem dimension*/
3584  element->FindParam(&dim,DomainDimensionEnum);
3585  element->FindParam(&r,AugmentedLagrangianREnum);
3586  if(dim==2) epssize = 3;
3587  else epssize = 6;
3588 
3589  /*Fetch number of nodes and dof for this finite element*/
3590  int vnumnodes = element->NumberofNodesVelocity();
3591  int pnumnodes = element->NumberofNodesPressure();
3592  int numdof = vnumnodes*dim + pnumnodes;
3593  int bsize = epssize + 2;
3594 
3595  /*Prepare coordinate system list*/
3596  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
3597  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
3598  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
3599  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
3600 
3601  /*Initialize Element matrix and vectors*/
3602  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3603  IssmDouble* B = xNew<IssmDouble>(bsize*numdof);
3604  IssmDouble* Bprime = xNew<IssmDouble>(bsize*numdof);
3605  IssmDouble* D = xNewZeroInit<IssmDouble>(bsize*bsize);
3606 
3607  /*Retrieve all inputs and parameters*/
3608  element->GetVerticesCoordinates(&xyz_list);
3609  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
3610  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
3611  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
3612  Input2* vz_input;
3613  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
3614 
3615  /* Start looping on the number of gaussian points: */
3616  Gauss* gauss = element->NewGauss(5);
3617  for(int ig=gauss->begin();ig<gauss->end();ig++){
3618  gauss->GaussPoint(ig);
3619 
3620  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
3621  this->GetBFS(B,element,dim,xyz_list,gauss);
3622  this->GetBFSprime(Bprime,element,dim,xyz_list,gauss);
3623 
3624  for(i=0;i<epssize;i++) D[i*bsize+i] = + r*gauss->weight*Jdet;
3625  for(i=epssize;i<bsize;i++) D[i*bsize+i] = - FSreconditioning*gauss->weight*Jdet;
3626 
3627  TripleMultiply(B,bsize,numdof,1,
3628  D,bsize,bsize,0,
3629  Bprime,bsize,numdof,0,
3630  &Ke->values[0],1);
3631  }
3632 
3633  /*Transform Coordinate System*/
3634  element->TransformStiffnessMatrixCoord(Ke,cs_list);
3635 
3636  /*Clean up and return*/
3637  delete gauss;
3638  xDelete<IssmDouble>(xyz_list);
3639  xDelete<IssmDouble>(D);
3640  xDelete<IssmDouble>(Bprime);
3641  xDelete<IssmDouble>(B);
3642  xDelete<int>(cs_list);
3643  return Ke;
3644 }/*}}}*/

◆ CreatePressureMassMatrix()

ElementMatrix * StressbalanceAnalysis::CreatePressureMassMatrix ( Element *  element)

Definition at line 3340 of file StressbalanceAnalysis.cpp.

3340  {/*{{{*/
3341 
3342  /*Intermediaries*/
3343  int i,dim;
3344  IssmDouble FSreconditioning,Jdet;
3345  IssmDouble *xyz_list = NULL;
3346 
3347  /*Get problem dimension*/
3348  element->FindParam(&dim,DomainDimensionEnum);
3349 
3350  /*Fetch number of nodes and dof for this finite element*/
3351  int vnumnodes = element->NumberofNodesVelocity();
3352  int pnumnodes = element->NumberofNodesPressure();
3353  int numdof = vnumnodes*dim + pnumnodes;
3354 
3355  /*Initialize Element matrix and vectors*/
3356  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3357  IssmDouble* pbasis = xNew<IssmDouble>(pnumnodes);
3358 
3359  /*Retrieve all inputs and parameters*/
3360  element->GetVerticesCoordinates(&xyz_list);
3361  //element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
3362 
3363  /* Start looping on the number of gaussian points: */
3364  Gauss* gauss = element->NewGauss(5);
3365  for(int ig=gauss->begin();ig<gauss->end();ig++){
3366  gauss->GaussPoint(ig);
3367 
3368  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
3369  element->NodalFunctionsPressure(pbasis,gauss);
3370 
3371  if(dim==3 || dim==2){
3372  /*Pressure mass matrix*/
3373  for(int k=0;k<pnumnodes;k++){
3374  for(int j=0;j<pnumnodes;j++){
3375  Ke->values[(dim*vnumnodes+k)*numdof+dim*vnumnodes+j] += gauss->weight*Jdet*(pbasis[j]*pbasis[k]);
3376  }
3377  }
3378  }else{
3379  _error_("STOP");
3380  }
3381  }
3382 
3383  /*Clean up and return*/
3384  delete gauss;
3385  xDelete<IssmDouble>(xyz_list);
3386  xDelete<IssmDouble>(pbasis);
3387  return Ke;
3388 }/*}}}*/

◆ CreateSchurPrecondMatrix()

ElementMatrix * StressbalanceAnalysis::CreateSchurPrecondMatrix ( Element *  element)

Definition at line 3389 of file StressbalanceAnalysis.cpp.

3389  {/*{{{*/
3390 
3391  /*Intermediaries*/
3392  int i,dim;
3393  IssmDouble viscosity,FSreconditioning,Jdet;
3394  IssmDouble *xyz_list = NULL;
3395 
3396  /*Get problem dimension*/
3397  element->FindParam(&dim,DomainDimensionEnum);
3398 
3399  /*Fetch number of nodes and dof for this finite element*/
3400  int vnumnodes = element->NumberofNodesVelocity();
3401  int pnumnodes = element->NumberofNodesPressure();
3402  int numdof = vnumnodes*dim + pnumnodes;
3403 
3404  /*Initialize Element matrix and vectors*/
3405  ElementMatrix* Ke = element->NewElementMatrix(FSvelocityEnum);
3406  IssmDouble* pbasis = xNew<IssmDouble>(pnumnodes);
3407 
3408  /*Retrieve all inputs and parameters*/
3409  element->GetVerticesCoordinates(&xyz_list);
3410  //element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
3411  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
3412  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
3413  Input2* vz_input = NULL;
3414  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
3415 
3416 
3417  /* Start looping on the number of gaussian points: */
3418  Gauss* gauss = element->NewGauss(5);
3419  for(int ig=gauss->begin();ig<gauss->end();ig++){
3420  gauss->GaussPoint(ig);
3421 
3422  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
3423  element->NodalFunctionsPressure(pbasis,gauss);
3424  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
3425 
3426 
3427  if(dim==3 || dim==2){
3428  /*Pressure mass matrix*/
3429  for(int k=0;k<pnumnodes;k++){
3430  for(int j=0;j<pnumnodes;j++){
3431  Ke->values[(dim*vnumnodes+k)*numdof+dim*vnumnodes+j] += gauss->weight*1./viscosity*Jdet*(pbasis[j]*pbasis[k]);
3432  }
3433  }
3434  }else{
3435  _error_("STOP");
3436  }
3437  }
3438 
3439  /*Clean up and return*/
3440  delete gauss;
3441  xDelete<IssmDouble>(xyz_list);
3442  xDelete<IssmDouble>(pbasis);
3443  return Ke;
3444 }/*}}}*/

◆ CreatePVectorFS()

ElementVector * StressbalanceAnalysis::CreatePVectorFS ( Element *  element)

Definition at line 4022 of file StressbalanceAnalysis.cpp.

4022  {/*{{{*/
4023 
4024  /* Check if ice in element */
4025  if(!element->IsIceInElement()) return NULL;
4026 
4027  ElementVector* pe = NULL;
4028  int fe_FS;
4029  element->FindParam(&fe_FS,FlowequationFeFSEnum);
4030 
4031  if(fe_FS==XTaylorHoodEnum){
4032  ElementVector* pe1=CreatePVectorFSViscous(element);
4033  ElementVector* pe2=CreatePVectorFSShelf(element);
4034  ElementVector* pe3=CreatePVectorFSFront(element);
4035  ElementVector* petemp =new ElementVector(pe1,pe2,pe3);
4036  ElementVector* pe4=CreatePVectorFSViscousXTH(element);
4037  pe = new ElementVector(petemp,pe4);
4038  delete pe1;
4039  delete pe2;
4040  delete pe3;
4041  delete petemp;
4042  delete pe4;
4043  }
4044  else if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){
4045  ElementVector* pe1=CreatePVectorFSViscous(element);
4046  ElementVector* pe2=CreatePVectorFSShelf(element);
4047  ElementVector* pe3=CreatePVectorFSFront(element);
4048  ElementVector* petemp =new ElementVector(pe1,pe2,pe3);
4049  ElementVector* pe4=CreatePVectorFSViscousLA(element);
4050  pe = new ElementVector(petemp,pe4);
4051  delete pe1;
4052  delete pe2;
4053  delete pe3;
4054  delete petemp;
4055  delete pe4;
4056  }
4057  else{
4058  ElementVector* pe1=CreatePVectorFSViscous(element);
4059  ElementVector* pe2=CreatePVectorFSShelf(element);
4060  ElementVector* pe3=CreatePVectorFSFront(element);
4061  pe =new ElementVector(pe1,pe2,pe3);
4062  delete pe1;
4063  delete pe2;
4064  delete pe3;
4065  }
4066 
4067  /*clean-up and return*/
4068  return pe;
4069 }/*}}}*/

◆ CreatePVectorFSFriction()

ElementVector* StressbalanceAnalysis::CreatePVectorFSFriction ( Element *  element)

◆ CreatePVectorFSFront()

ElementVector * StressbalanceAnalysis::CreatePVectorFSFront ( Element *  element)

Definition at line 4140 of file StressbalanceAnalysis.cpp.

4140  {/*{{{*/
4141 
4142  /*If no front, return NULL*/
4143  if(!element->IsIcefront()) return NULL;
4144 
4145  /*Intermediaries*/
4146  int i,dim;
4147  IssmDouble Jdet,pressure,surface,sealevel,z;
4148  IssmDouble normal[3];
4149  IssmDouble *xyz_list = NULL;
4150  IssmDouble *xyz_list_front = NULL;
4151  Gauss *gauss = NULL;
4152 
4153  /*Get problem dimension*/
4154  element->FindParam(&dim,DomainDimensionEnum);
4155 
4156  /*Fetch number of nodes and dof for this finite element*/
4157  int vnumnodes = element->NumberofNodesVelocity();
4158  int pnumnodes = element->NumberofNodesPressure();
4159  int numvertices = element->GetNumberOfVertices();
4160 
4161  /*Prepare coordinate system list*/
4162  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
4163  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
4164  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
4165  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
4166 
4167  /*Initialize vectors*/
4168  ElementVector* pe = element->NewElementVector(FSvelocityEnum);
4169  IssmDouble* vbasis = xNew<IssmDouble>(vnumnodes);
4170 
4171  /*Retrieve all inputs and parameters*/
4172  element->GetVerticesCoordinates(&xyz_list);
4173  element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
4174  element->NormalSection(&normal[0],xyz_list_front);
4175  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
4176  Input2* sealevel_input = element->GetInput2(SealevelEnum); _assert_(sealevel_input);
4177  IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
4178  IssmDouble gravity = element->FindParam(ConstantsGEnum);
4179 
4180  /*Initialize gauss points*/
4181  IssmDouble zmax=xyz_list[0*3+(dim-1)]; for(int i=1;i<numvertices;i++) if(xyz_list[i*3+(dim-1)]>zmax) zmax=xyz_list[i*3+(dim-1)];
4182  IssmDouble zmin=xyz_list[0*3+(dim-1)]; for(int i=1;i<numvertices;i++) if(xyz_list[i*3+(dim-1)]<zmin) zmin=xyz_list[i*3+(dim-1)];
4183  if(zmax>0. && zmin<0.) gauss=element->NewGauss(xyz_list,xyz_list_front,3,30);//refined in vertical because of the sea level discontinuity
4184  else gauss=element->NewGauss(xyz_list,xyz_list_front,3,3);
4185 
4186  /* Start looping on the number of gaussian points: */
4187  for(int ig=gauss->begin();ig<gauss->end();ig++){
4188  gauss->GaussPoint(ig);
4189 
4190  element->JacobianDeterminantSurface(&Jdet,xyz_list_front,gauss);
4191  element->NodalFunctionsVelocity(vbasis,gauss);
4192  surface_input->GetInputValue(&surface,gauss);
4193  sealevel_input->GetInputValue(&sealevel,gauss);
4194  if(dim==3) z=element->GetZcoord(xyz_list,gauss);
4195  else z=element->GetYcoord(xyz_list,gauss);
4196  pressure = rho_water*gravity*min(0.,z-sealevel);//0 if the gaussian point is above water level
4197 
4198  for (int i=0;i<vnumnodes;i++){
4199  pe->values[dim*i+0]+= pressure*Jdet*gauss->weight*normal[0]*vbasis[i];
4200  pe->values[dim*i+1]+= pressure*Jdet*gauss->weight*normal[1]*vbasis[i];
4201  if(dim==3) pe->values[dim*i+2]+= pressure*Jdet*gauss->weight*normal[2]*vbasis[i];
4202  }
4203  }
4204 
4205  /*Transform coordinate system*/
4206  element->TransformLoadVectorCoord(pe,cs_list);
4207 
4208  /*Clean up and return*/
4209  delete gauss;
4210  xDelete<int>(cs_list);
4211  xDelete<IssmDouble>(vbasis);
4212  xDelete<IssmDouble>(xyz_list);
4213  xDelete<IssmDouble>(xyz_list_front);
4214  return pe;
4215 }/*}}}*/

◆ CreatePVectorFSShelf()

ElementVector * StressbalanceAnalysis::CreatePVectorFSShelf ( Element *  element)

Definition at line 4216 of file StressbalanceAnalysis.cpp.

4216  {/*{{{*/
4217 
4218  int i,dim;
4219  IssmDouble Jdet,water_pressure,base;
4220  IssmDouble *xyz_list_base = NULL;
4221 
4222  /*Get basal element*/
4223  if(!element->IsOnBase() || !element->IsFloating()) return NULL;
4224 
4225  /*Get problem dimension*/
4226  element->FindParam(&dim,DomainDimensionEnum);
4227 
4228  /*Fetch number of nodes and dof for this finite element*/
4229  int vnumnodes = element->NumberofNodesVelocity();
4230  int pnumnodes = element->NumberofNodesPressure();
4231 
4232  /*Prepare coordinate system list*/
4233  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
4234  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
4235  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
4236  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
4237 
4238  /*Initialize vectors*/
4239  ElementVector* pe = element->NewElementVector(FSvelocityEnum);
4240  IssmDouble* vbasis = xNew<IssmDouble>(vnumnodes);
4241 
4242  /*Retrieve all inputs and parameters*/
4243  element->GetVerticesCoordinatesBase(&xyz_list_base);
4244  Input2* base_input=element->GetInput2(BaseEnum); _assert_(base_input);
4245  IssmDouble rho_water=element->FindParam(MaterialsRhoSeawaterEnum);
4246  IssmDouble gravity =element->FindParam(ConstantsGEnum);
4247 
4248  /* Start looping on the number of gaussian points: */
4249  Gauss* gauss=element->NewGaussBase(5);
4250  for(int ig=gauss->begin();ig<gauss->end();ig++){
4251  gauss->GaussPoint(ig);
4252 
4253  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
4254  element->NodalFunctionsVelocity(vbasis,gauss);
4255 
4256  base_input->GetInputValue(&base, gauss);
4257  water_pressure=gravity*rho_water*base;
4258 
4259  for(i=0;i<vnumnodes;i++){
4260  pe->values[i*dim+(dim-1)]+=-water_pressure*gauss->weight*Jdet*vbasis[i];
4261  }
4262  }
4263 
4264  /* shelf dampening*/
4265  int shelf_dampening;
4266  element->FindParam(&shelf_dampening,StressbalanceShelfDampeningEnum);
4267  if(shelf_dampening) {
4268  Input2* mb_input=element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(mb_input);
4269  IssmDouble dt,mb;
4270  element->FindParam(&dt,TimesteppingTimeStepEnum);
4271  for(int ig=gauss->begin();ig<gauss->end();ig++){
4272  gauss->GaussPoint(ig);
4273  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
4274  element->NodalFunctionsVelocity(vbasis,gauss);
4275  mb_input->GetInputValue(&mb, gauss);
4276  for(i=0;i<vnumnodes;i++){
4277  pe->values[i*dim+(dim-1)] += -dt*rho_water*gravity*mb*gauss->weight*Jdet*vbasis[i];
4278  }
4279  }
4280  }
4281 
4282  /*DO NOT Transform Coordinate System: this stiffness matrix is already expressed in tangential coordinates*/
4283 
4284  /*Clean up and return*/
4285  delete gauss;
4286  xDelete<int>(cs_list);
4287  xDelete<IssmDouble>(vbasis);
4288  xDelete<IssmDouble>(xyz_list_base);
4289  return pe;
4290 }/*}}}*/

◆ CreatePVectorFSStress()

ElementVector* StressbalanceAnalysis::CreatePVectorFSStress ( Element *  element)

◆ CreatePVectorFSViscous()

ElementVector * StressbalanceAnalysis::CreatePVectorFSViscous ( Element *  element)

Definition at line 4070 of file StressbalanceAnalysis.cpp.

4070  {/*{{{*/
4071 
4072  int i,dim;
4073  IssmDouble Jdet,forcex,forcey,forcez;
4074  IssmDouble *xyz_list = NULL;
4075 
4076  /*Get problem dimension*/
4077  element->FindParam(&dim,DomainDimensionEnum);
4078 
4079  /*Fetch number of nodes and dof for this finite element*/
4080  int vnumnodes = element->NumberofNodesVelocity();
4081  int pnumnodes = element->NumberofNodesPressure();
4082 
4083  /*Prepare coordinate system list*/
4084  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
4085  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
4086  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
4087  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
4088 
4089  /*Initialize vectors*/
4090  ElementVector* pe = element->NewElementVector(FSvelocityEnum);
4091  IssmDouble* vbasis = xNew<IssmDouble>(vnumnodes);
4092 
4093  /*Retrieve all inputs and parameters*/
4094  element->GetVerticesCoordinates(&xyz_list);
4095  IssmDouble rho_ice =element->FindParam(MaterialsRhoIceEnum);
4096  IssmDouble gravity =element->FindParam(ConstantsGEnum);
4097  Input2* loadingforcex_input=element->GetInput2(LoadingforceXEnum); _assert_(loadingforcex_input);
4098  Input2* loadingforcey_input=element->GetInput2(LoadingforceYEnum); _assert_(loadingforcey_input);
4099  Input2* loadingforcez_input=NULL;
4100  if(dim==3){
4101  loadingforcez_input=element->GetInput2(LoadingforceZEnum); _assert_(loadingforcez_input);
4102  }
4103 
4104  /* Start looping on the number of gaussian points: */
4105  Gauss* gauss=element->NewGauss(5);
4106  for(int ig=gauss->begin();ig<gauss->end();ig++){
4107  gauss->GaussPoint(ig);
4108 
4109  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
4110  element->NodalFunctionsVelocity(vbasis,gauss);
4111 
4112  loadingforcex_input->GetInputValue(&forcex,gauss);
4113  loadingforcey_input->GetInputValue(&forcey,gauss);
4114  if(dim==3) loadingforcez_input->GetInputValue(&forcez,gauss);
4115 
4116  for(i=0;i<vnumnodes;i++){
4117  pe->values[i*dim+0] += +rho_ice*forcex *Jdet*gauss->weight*vbasis[i];
4118  pe->values[i*dim+1] += +rho_ice*forcey *Jdet*gauss->weight*vbasis[i];
4119  if(dim==3){
4120  pe->values[i*dim+2] += +rho_ice*forcez*Jdet*gauss->weight*vbasis[i];
4121  pe->values[i*dim+2] += -rho_ice*gravity*Jdet*gauss->weight*vbasis[i];
4122  }
4123  else{
4124  pe->values[i*dim+1] += -rho_ice*gravity*Jdet*gauss->weight*vbasis[i];
4125  }
4126  }
4127  }
4128 
4129  /*Transform coordinate system*/
4130  element->TransformLoadVectorCoord(pe,cs_list);
4131 
4132  /*Clean up and return*/
4133  delete gauss;
4134  xDelete<int>(cs_list);
4135  xDelete<IssmDouble>(vbasis);
4136  xDelete<IssmDouble>(xyz_list);
4137  return pe;
4138 }/*}}}*/

◆ CreatePVectorFSViscousLA()

ElementVector * StressbalanceAnalysis::CreatePVectorFSViscousLA ( Element *  element)

Definition at line 4291 of file StressbalanceAnalysis.cpp.

4291  {/*{{{*/
4292 
4293  int i,dim;
4294  IssmDouble Jdet,pressure;
4295  IssmDouble bed_normal[3];
4296  IssmDouble *xyz_list = NULL;
4297  IssmDouble *xyz_list_base = NULL;
4298  Gauss* gauss = NULL;
4299 
4300  /*Get problem dimension*/
4301  element->FindParam(&dim,DomainDimensionEnum);
4302 
4303  /*Fetch number of nodes and dof for this finite element*/
4304  int numnodes = element->GetNumberOfNodes();
4305 
4306  /*Prepare coordinate system list*/
4307  int* cs_list = xNew<int>(numnodes);
4308  if(dim==2) for(i=0;i<numnodes;i++) cs_list[i] = XYEnum;
4309  else for(i=0;i<numnodes;i++) cs_list[i] = XYZEnum;
4310 
4311  /*Initialize vectors*/
4312  ElementVector* pe = element->NewElementVector(FSvelocityEnum);
4313  IssmDouble* dbasis = xNew<IssmDouble>(3*numnodes);
4314 
4315  /*Retrieve all inputs and parameters*/
4316  element->GetVerticesCoordinates(&xyz_list);
4317 
4318  /*Get pressure and sigmann*/
4319  Input2* pressure_input=element->GetInput2(PressureEnum); _assert_(pressure_input);
4320  Input2* sigmann_input =element->GetInput2(SigmaNNEnum); _assert_(sigmann_input);
4321 
4322  gauss=element->NewGauss(5);
4323  for(int ig=gauss->begin();ig<gauss->end();ig++){
4324  gauss->GaussPoint(ig);
4325  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
4326 
4327  pressure_input->GetInputValue(&pressure, gauss);
4328  element->NodalFunctionsDerivativesVelocity(dbasis,xyz_list,gauss);
4329 
4330  for(i=0;i<numnodes;i++){
4331  pe->values[i*dim+0] += pressure*gauss->weight*Jdet*dbasis[0*numnodes+i];
4332  pe->values[i*dim+1] += pressure*gauss->weight*Jdet*dbasis[1*numnodes+i];
4333  if(dim==3) pe->values[i*dim+2]+= pressure*gauss->weight*Jdet*dbasis[2*numnodes+i];
4334  }
4335  }
4336 
4337  if(element->IsOnBase() && 0){
4338  IssmDouble sigmann;
4339  IssmDouble* vbasis = xNew<IssmDouble>(numnodes);
4340 
4341  element->GetVerticesCoordinatesBase(&xyz_list_base);
4342  element->NormalBase(&bed_normal[0],xyz_list_base);
4343 
4344  delete gauss;
4345  gauss=element->NewGaussBase(5);
4346  for(int ig=gauss->begin();ig<gauss->end();ig++){
4347  gauss->GaussPoint(ig);
4348 
4349  element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
4350  element->NodalFunctionsVelocity(vbasis,gauss);
4351  sigmann_input->GetInputValue(&sigmann, gauss);
4352 
4353  for(i=0;i<numnodes;i++){
4354  pe->values[i*dim+0] += + sigmann*bed_normal[0]*gauss->weight*Jdet*vbasis[i];
4355  pe->values[i*dim+1] += + sigmann*bed_normal[1]*gauss->weight*Jdet*vbasis[i];
4356  if(dim==3) pe->values[i*dim+2] += + sigmann*bed_normal[2]*gauss->weight*Jdet*vbasis[i];
4357  }
4358  }
4359  xDelete<IssmDouble>(xyz_list_base);
4360  xDelete<IssmDouble>(vbasis);
4361  }
4362 
4363  /*Transform coordinate system*/
4364  element->TransformLoadVectorCoord(pe,cs_list);
4365 
4366  /*Clean up and return*/
4367  delete gauss;
4368  xDelete<int>(cs_list);
4369  xDelete<IssmDouble>(xyz_list);
4370  xDelete<IssmDouble>(dbasis);
4371  return pe;
4372 }/*}}}*/

◆ CreatePVectorFSViscousXTH()

ElementVector * StressbalanceAnalysis::CreatePVectorFSViscousXTH ( Element *  element)

Definition at line 4373 of file StressbalanceAnalysis.cpp.

4373  {/*{{{*/
4374 
4375  int i,tausize,dim;
4376  IssmDouble Jdet,r;
4377  IssmDouble epsxx,epsyy,epszz,epsxy,epsxz,epsyz;
4378  IssmDouble sigmapxx,sigmapyy,sigmapzz,sigmapxy,sigmapxz,sigmapyz;
4379  IssmDouble *xyz_list = NULL;
4380  Gauss* gauss = NULL;
4381 
4382  /*Get problem dimension*/
4383  element->FindParam(&dim,DomainDimensionEnum);
4384  if(dim==2) tausize = 3;
4385  else tausize = 6;
4386 
4387  /*Fetch number of nodes and dof for this finite element*/
4388  int vnumnodes = element->NumberofNodesVelocity();
4389  int pnumnodes = element->NumberofNodesPressure();
4390  int tnumnodes = element->GetNumberOfVertices(); //Tensors, P1 DG
4391 
4392  /*Prepare coordinate system list*/
4393  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
4394  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
4395  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
4396  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
4397 
4398  /*Initialize vectors*/
4399  ElementVector* pe = element->NewElementVector(FSvelocityEnum);
4400  IssmDouble* Dstar = xNewZeroInit<IssmDouble>((dim*vnumnodes)*(tausize*tnumnodes));
4401  IssmDouble* tau = xNew<IssmDouble>(tausize*tnumnodes);
4402  IssmDouble* d = xNew<IssmDouble>(tausize*tnumnodes);
4403  IssmDouble* vdbasis = xNew<IssmDouble>(dim*vnumnodes);
4404  IssmDouble* tbasis = xNew<IssmDouble>(tnumnodes);
4405  IssmDouble* D = xNewZeroInit<IssmDouble>(tausize*tnumnodes*tausize*tnumnodes);
4406 
4407  /*Retrieve all inputs and parameters*/
4408  element->FindParam(&r,AugmentedLagrangianREnum);
4409  element->GetVerticesCoordinates(&xyz_list);
4410 
4411  /*Get d and tau*/
4412  Input2* epsxx_input=element->GetInput2(StrainRatexxEnum); _assert_(epsxx_input);
4413  Input2* epsyy_input=element->GetInput2(StrainRateyyEnum); _assert_(epsyy_input);
4414  Input2* epsxy_input=element->GetInput2(StrainRatexyEnum); _assert_(epsxy_input);
4415  Input2* epszz_input=NULL; Input2* epsxz_input=NULL; Input2* epsyz_input=NULL;
4416  Input2* sigmapxx_input=element->GetInput2(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
4417  Input2* sigmapyy_input=element->GetInput2(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
4418  Input2* sigmapxy_input=element->GetInput2(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
4419  Input2* sigmapzz_input=NULL; Input2* sigmapxz_input=NULL; Input2* sigmapyz_input=NULL;
4420  if(dim==3){
4421  epszz_input=element->GetInput2(StrainRatezzEnum); _assert_(epszz_input);
4422  epsxz_input=element->GetInput2(StrainRatexzEnum); _assert_(epsxz_input);
4423  epsyz_input=element->GetInput2(StrainRateyzEnum); _assert_(epsyz_input);
4424  sigmapzz_input=element->GetInput2(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
4425  sigmapxz_input=element->GetInput2(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
4426  sigmapyz_input=element->GetInput2(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
4427  }
4428 
4429  gauss = element->NewGauss();
4430  for(int i=0;i<tnumnodes;i++){
4431  gauss->GaussNode(P1DGEnum,i);
4432 
4433  epsxx_input->GetInputValue(&epsxx,gauss); sigmapxx_input->GetInputValue(&sigmapxx,gauss);
4434  epsyy_input->GetInputValue(&epsyy,gauss); sigmapyy_input->GetInputValue(&sigmapyy,gauss);
4435  epsxy_input->GetInputValue(&epsxy,gauss); sigmapxy_input->GetInputValue(&sigmapxy,gauss);
4436  if(dim==2){
4437  d[i*tausize+0]=epsxx; tau[i*tausize+0]=sigmapxx;
4438  d[i*tausize+1]=epsyy; tau[i*tausize+1]=sigmapyy;
4439  d[i*tausize+2]=epsxy; tau[i*tausize+2]=sigmapxy;
4440  }
4441  else{
4442  epszz_input->GetInputValue(&epszz,gauss); sigmapzz_input->GetInputValue(&sigmapzz,gauss);
4443  epsxz_input->GetInputValue(&epsxz,gauss); sigmapxz_input->GetInputValue(&sigmapxz,gauss);
4444  epsyz_input->GetInputValue(&epsyz,gauss); sigmapyz_input->GetInputValue(&sigmapyz,gauss);
4445  d[i*tausize+0]=epsxx; tau[i*tausize+0]=sigmapxx;
4446  d[i*tausize+1]=epsyy; tau[i*tausize+1]=sigmapyy;
4447  d[i*tausize+2]=epszz; tau[i*tausize+2]=sigmapzz;
4448  d[i*tausize+3]=epsxy; tau[i*tausize+3]=sigmapxy;
4449  d[i*tausize+4]=epsxz; tau[i*tausize+4]=sigmapxz;
4450  d[i*tausize+5]=epsyz; tau[i*tausize+5]=sigmapyz;
4451  }
4452  }
4453 
4454  /* Start looping on the number of gaussian points: */
4455  delete gauss;
4456  gauss=element->NewGauss(5);
4457  for(int ig=gauss->begin();ig<gauss->end();ig++){
4458  gauss->GaussPoint(ig);
4459  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
4460 
4461  /*Create Dstar*/
4462  /*In dim = 2
4463  *
4464  * <----------------- tausize ---------------> x tnumnodes
4465  * | gamma_ij^x 0 gamma_ij^y | ^
4466  * Dij = | | dim
4467  * | 0 gamma_ij^y gamma_ij^x | v
4468  * x
4469  * vnumnodes
4470  *
4471  *In dim = 3
4472  *
4473  * | gamma_ij^x 0 0 gamma_ij^y gamma_ij^z 0 |
4474  * | |
4475  * Dij = | 0 gamma_ij^y 0 gamma_ij^x 0 gamma_ij^z |
4476  * | |
4477  * | 0 0 gamma_ij^z 0 gamma_ij^x gamma_ij^y |
4478  *
4479  * gamma_ij^x = zeta_j dphi_i/dx
4480  *
4481  * where:
4482  * - zeta_j is the nodal function for the j^th node of the tensor (P1DG)
4483  * - phi_i is the nodal function for the i^th node of the velocity (P2)*/
4484  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
4485  element->NodalFunctionsTensor(tbasis,gauss);
4486  if(dim==2){
4487  for(int i=0;i<vnumnodes;i++){
4488  for(int j=0;j<tnumnodes;j++){
4489  Dstar[(i*dim+0)*tausize*tnumnodes + j*tausize+0] += gauss->weight*Jdet*tbasis[j]*vdbasis[0*vnumnodes+i];
4490  Dstar[(i*dim+0)*tausize*tnumnodes + j*tausize+2] += gauss->weight*Jdet*tbasis[j]*vdbasis[1*vnumnodes+i];
4491 
4492  Dstar[(i*dim+1)*tausize*tnumnodes + j*tausize+1] += gauss->weight*Jdet*tbasis[j]*vdbasis[1*vnumnodes+i];
4493  Dstar[(i*dim+1)*tausize*tnumnodes + j*tausize+2] += gauss->weight*Jdet*tbasis[j]*vdbasis[0*vnumnodes+i];
4494  }
4495  }
4496  }
4497  else{
4498  for(int i=0;i<vnumnodes;i++){
4499  for(int j=0;j<tnumnodes;j++){
4500  Dstar[(i*dim+0)*tausize*tnumnodes + j*tausize+0] += gauss->weight*Jdet*tbasis[j]*vdbasis[0*vnumnodes+i];
4501  Dstar[(i*dim+0)*tausize*tnumnodes + j*tausize+3] += gauss->weight*Jdet*tbasis[j]*vdbasis[1*vnumnodes+i];
4502  Dstar[(i*dim+0)*tausize*tnumnodes + j*tausize+4] += gauss->weight*Jdet*tbasis[j]*vdbasis[2*vnumnodes+i];
4503 
4504  Dstar[(i*dim+1)*tausize*tnumnodes + j*tausize+1] += gauss->weight*Jdet*tbasis[j]*vdbasis[1*vnumnodes+i];
4505  Dstar[(i*dim+1)*tausize*tnumnodes + j*tausize+3] += gauss->weight*Jdet*tbasis[j]*vdbasis[0*vnumnodes+i];
4506  Dstar[(i*dim+1)*tausize*tnumnodes + j*tausize+5] += gauss->weight*Jdet*tbasis[j]*vdbasis[2*vnumnodes+i];
4507 
4508  Dstar[(i*dim+2)*tausize*tnumnodes + j*tausize+2] += gauss->weight*Jdet*tbasis[j]*vdbasis[2*vnumnodes+i];
4509  Dstar[(i*dim+2)*tausize*tnumnodes + j*tausize+4] += gauss->weight*Jdet*tbasis[j]*vdbasis[0*vnumnodes+i];
4510  Dstar[(i*dim+2)*tausize*tnumnodes + j*tausize+5] += gauss->weight*Jdet*tbasis[j]*vdbasis[1*vnumnodes+i];
4511  }
4512  }
4513  }
4514  }
4515 
4516  /*contribution -Dstar tau*/
4517  for(i=0;i<tausize*tnumnodes;i++) D[i*(tausize*tnumnodes)+i] = -1.;
4518  TripleMultiply(Dstar,dim*vnumnodes,tausize*tnumnodes,0,
4519  D,tausize*tnumnodes,tausize*tnumnodes,0,
4520  tau,tausize*tnumnodes,1,0,
4521  &pe->values[0],1);
4522 
4523  /*contribution + r Dstar d*/
4524  for(i=0;i<tausize*tnumnodes;i++) D[i*(tausize*tnumnodes)+i] = +r;
4525  TripleMultiply(Dstar,dim*vnumnodes,tausize*tnumnodes,0,
4526  D,tausize*tnumnodes,tausize*tnumnodes,0,
4527  d,tausize*tnumnodes,1,0,
4528  &pe->values[0],1);
4529 
4530  /*Transform coordinate system*/
4531  element->TransformLoadVectorCoord(pe,cs_list);
4532 
4533  /*Clean up and return*/
4534  delete gauss;
4535  xDelete<int>(cs_list);
4536  xDelete<IssmDouble>(xyz_list);
4537  xDelete<IssmDouble>(Dstar);
4538  xDelete<IssmDouble>(d);
4539  xDelete<IssmDouble>(D);
4540  xDelete<IssmDouble>(tau);
4541  xDelete<IssmDouble>(vdbasis);
4542  xDelete<IssmDouble>(tbasis);
4543  return pe;
4544 }/*}}}*/

◆ GetBFS()

void StressbalanceAnalysis::GetBFS ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4545 of file StressbalanceAnalysis.cpp.

4545  {/*{{{*/
4546  /*Compute B matrix. B=[Bv1 Bv2 ... Bp1 Bp2 ...] where Bvi is of size 3*3.
4547  * For node i, Bvi can be expressed in the actual coordinate system
4548  * by: Bvi=[ dphi/dx 0 ]
4549  * [ 0 dphi/dy ]
4550  * [ 1/2*dphi/dy 1/2*dphi/dx]
4551  * [ 0 0 ]
4552  * [ dphi/dx dphi/dy ]
4553  *
4554  * Bpi=[ 0 ]
4555  * [ 0 ]
4556  * [ 0 ]
4557  * [ phi_p ]
4558  * [ 0 ]
4559  *
4560  * In 3d:
4561  * Bvi=[ dh/dx 0 0 ]
4562  * [ 0 dh/dy 0 ]
4563  * [ 0 0 dh/dz ]
4564  * [ 1/2*dh/dy 1/2*dh/dx 0 ]
4565  * [ 1/2*dh/dz 0 1/2*dh/dx ]
4566  * [ 0 1/2*dh/dz 1/2*dh/dy ]
4567  * [ 0 0 0 ]
4568  * [ dh/dx dh/dy dh/dz ]
4569  *
4570  * Bpi=[ 0 ]
4571  * [ 0 ]
4572  * [ 0 ]
4573  * [ 0 ]
4574  * [ 0 ]
4575  * [ 0 ]
4576  * [ h ]
4577  * [ 0 ]
4578  * where phi is the finiteelement function for node i.
4579  * Same thing for Bb except the last column that does not exist.
4580  */
4581 
4582  /*Fetch number of nodes for this finite element*/
4583  int pnumnodes = element->NumberofNodesPressure();
4584  int vnumnodes = element->NumberofNodesVelocity();
4585 
4586  /*Get nodal functions derivatives*/
4587  IssmDouble* vdbasis=xNew<IssmDouble>(dim*vnumnodes);
4588  IssmDouble* pbasis =xNew<IssmDouble>(pnumnodes);
4589  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
4590  element->NodalFunctionsPressure(pbasis,gauss);
4591 
4592  /*Build B: */
4593  if(dim==2){
4594  for(int i=0;i<vnumnodes;i++){
4595  B[(dim*vnumnodes+pnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4596  B[(dim*vnumnodes+pnumnodes)*0+dim*i+1] = 0.;
4597  B[(dim*vnumnodes+pnumnodes)*1+dim*i+0] = 0.;
4598  B[(dim*vnumnodes+pnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4599  B[(dim*vnumnodes+pnumnodes)*2+dim*i+0] = .5*vdbasis[1*vnumnodes+i];
4600  B[(dim*vnumnodes+pnumnodes)*2+dim*i+1] = .5*vdbasis[0*vnumnodes+i];
4601  B[(dim*vnumnodes+pnumnodes)*3+dim*i+0] = 0.;
4602  B[(dim*vnumnodes+pnumnodes)*3+dim*i+1] = 0.;
4603  B[(dim*vnumnodes+pnumnodes)*4+dim*i+0] = vdbasis[0*vnumnodes+i];
4604  B[(dim*vnumnodes+pnumnodes)*4+dim*i+1] = vdbasis[1*vnumnodes+i];
4605  }
4606  for(int i=0;i<pnumnodes;i++){
4607  B[(dim*vnumnodes+pnumnodes)*0+(dim*vnumnodes)+i] = 0.;
4608  B[(dim*vnumnodes+pnumnodes)*1+(dim*vnumnodes)+i] = 0.;
4609  B[(dim*vnumnodes+pnumnodes)*2+(dim*vnumnodes)+i] = 0.;
4610  B[(dim*vnumnodes+pnumnodes)*3+(dim*vnumnodes)+i] = pbasis[i];
4611  B[(dim*vnumnodes+pnumnodes)*4+(dim*vnumnodes)+i] = 0.;
4612  }
4613  }
4614  else{
4615  for(int i=0;i<vnumnodes;i++){
4616  B[(dim*vnumnodes+pnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4617  B[(dim*vnumnodes+pnumnodes)*0+dim*i+1] = 0.;
4618  B[(dim*vnumnodes+pnumnodes)*0+dim*i+2] = 0.;
4619  B[(dim*vnumnodes+pnumnodes)*1+dim*i+0] = 0.;
4620  B[(dim*vnumnodes+pnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4621  B[(dim*vnumnodes+pnumnodes)*1+dim*i+2] = 0.;
4622  B[(dim*vnumnodes+pnumnodes)*2+dim*i+0] = 0.;
4623  B[(dim*vnumnodes+pnumnodes)*2+dim*i+1] = 0.;
4624  B[(dim*vnumnodes+pnumnodes)*2+dim*i+2] = vdbasis[2*vnumnodes+i];
4625  B[(dim*vnumnodes+pnumnodes)*3+dim*i+0] = .5*vdbasis[1*vnumnodes+i];
4626  B[(dim*vnumnodes+pnumnodes)*3+dim*i+1] = .5*vdbasis[0*vnumnodes+i];
4627  B[(dim*vnumnodes+pnumnodes)*3+dim*i+2] = 0.;
4628  B[(dim*vnumnodes+pnumnodes)*4+dim*i+0] = .5*vdbasis[2*vnumnodes+i];
4629  B[(dim*vnumnodes+pnumnodes)*4+dim*i+1] = 0.;
4630  B[(dim*vnumnodes+pnumnodes)*4+dim*i+2] = .5*vdbasis[0*vnumnodes+i];
4631  B[(dim*vnumnodes+pnumnodes)*5+dim*i+0] = 0.;
4632  B[(dim*vnumnodes+pnumnodes)*5+dim*i+1] = .5*vdbasis[2*vnumnodes+i];
4633  B[(dim*vnumnodes+pnumnodes)*5+dim*i+2] = .5*vdbasis[1*vnumnodes+i];
4634  B[(dim*vnumnodes+pnumnodes)*6+dim*i+0] = 0.;
4635  B[(dim*vnumnodes+pnumnodes)*6+dim*i+1] = 0.;
4636  B[(dim*vnumnodes+pnumnodes)*6+dim*i+2] = 0.;
4637  B[(dim*vnumnodes+pnumnodes)*7+dim*i+0] = vdbasis[0*vnumnodes+i];
4638  B[(dim*vnumnodes+pnumnodes)*7+dim*i+1] = vdbasis[1*vnumnodes+i];
4639  B[(dim*vnumnodes+pnumnodes)*7+dim*i+2] = vdbasis[2*vnumnodes+i];
4640  }
4641  for(int i=0;i<pnumnodes;i++){
4642  B[(dim*vnumnodes+pnumnodes)*0+(dim*vnumnodes)+i] = 0.;
4643  B[(dim*vnumnodes+pnumnodes)*1+(dim*vnumnodes)+i] = 0.;
4644  B[(dim*vnumnodes+pnumnodes)*2+(dim*vnumnodes)+i] = 0.;
4645  B[(dim*vnumnodes+pnumnodes)*3+(dim*vnumnodes)+i] = 0.;
4646  B[(dim*vnumnodes+pnumnodes)*4+(dim*vnumnodes)+i] = 0.;
4647  B[(dim*vnumnodes+pnumnodes)*5+(dim*vnumnodes)+i] = 0.;
4648  B[(dim*vnumnodes+pnumnodes)*6+(dim*vnumnodes)+i] = pbasis[i];
4649  B[(dim*vnumnodes+pnumnodes)*7+(dim*vnumnodes)+i] = 0.;
4650  }
4651  }
4652 
4653  /*Clean up*/
4654  xDelete<IssmDouble>(vdbasis);
4655  xDelete<IssmDouble>(pbasis);
4656 }/*}}}*/

◆ GetBFSFriction()

void StressbalanceAnalysis::GetBFSFriction ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4657 of file StressbalanceAnalysis.cpp.

4657  {/*{{{*/
4658  /* Compute L matrix. L=[L1 L2 L3] where Li is square and of size numdof.
4659  * For node i, Li can be expressed in the actual coordinate system
4660  * by in 3d
4661  * Li=[ h 0 0 0 ]
4662  * [ 0 h 0 0 ]
4663  * in 2d:
4664  * Li=[ h 0 0 ]
4665  * where h is the interpolation function for node i.
4666  */
4667 
4668  /*Fetch number of nodes for this finite element*/
4669  int pnumnodes = element->NumberofNodesPressure();
4670  int vnumnodes = element->NumberofNodesVelocity();
4671  int pnumdof = pnumnodes;
4672  int vnumdof = vnumnodes*dim;
4673 
4674  /*Get nodal functions derivatives*/
4675  IssmDouble* vbasis=xNew<IssmDouble>(vnumnodes);
4676  element->NodalFunctionsVelocity(vbasis,gauss);
4677 
4678  /*Build B: */
4679  if(dim==3){
4680  for(int i=0;i<vnumnodes;i++){
4681  B[(vnumdof+pnumdof)*0+3*i+0] = vbasis[i];
4682  B[(vnumdof+pnumdof)*0+3*i+1] = 0.;
4683  B[(vnumdof+pnumdof)*0+3*i+2] = 0.;
4684 
4685  B[(vnumdof+pnumdof)*1+3*i+0] = 0.;
4686  B[(vnumdof+pnumdof)*1+3*i+1] = vbasis[i];
4687  B[(vnumdof+pnumdof)*1+3*i+2] = 0.;
4688 
4689  B[(vnumdof+pnumdof)*2+3*i+0] = 0.;
4690  B[(vnumdof+pnumdof)*2+3*i+1] = 0.;
4691  B[(vnumdof+pnumdof)*2+3*i+2] = vbasis[i];
4692  }
4693  for(int i=0;i<pnumnodes;i++){
4694  B[(vnumdof+pnumdof)*0+i+vnumdof+0] = 0.;
4695  B[(vnumdof+pnumdof)*1+i+vnumdof+0] = 0.;
4696  B[(vnumdof+pnumdof)*2+i+vnumdof+0] = 0.;
4697  }
4698  }
4699  else{
4700  for(int i=0;i<vnumnodes;i++){
4701  B[(vnumdof+pnumdof)*0+2*i+0] = vbasis[i];
4702  B[(vnumdof+pnumdof)*0+2*i+1] = 0.;
4703 
4704  B[(vnumdof+pnumdof)*1+2*i+0] = 0.;
4705  B[(vnumdof+pnumdof)*1+2*i+1] = vbasis[i];
4706  }
4707 
4708  for(int i=0;i<pnumnodes;i++){
4709  B[(vnumdof+pnumdof)*0+i+vnumdof+0] = 0.;
4710  B[(vnumdof+pnumdof)*1+i+vnumdof+0] = 0.;
4711  }
4712  }
4713 
4714  /*Clean-up*/
4715  xDelete<IssmDouble>(vbasis);
4716 }/*}}}*/

◆ GetBFSprime()

void StressbalanceAnalysis::GetBFSprime ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4717 of file StressbalanceAnalysis.cpp.

4717  {/*{{{*/
4718  /* Compute B' matrix. B'=[B1' B2' B3' B4' B5' B6' Bb'] where Bi' is of size 3*2.
4719  * For node i, Bi' can be expressed in the actual coordinate system
4720  * by:
4721  * Bvi' = [ dphi/dx 0 ]
4722  * [ 0 dphi/dy ]
4723  * [ dphi/dy dphi/dx ]
4724  * [ dphi/dx dphi/dy ]
4725  * [ 0 0 ]
4726  *
4727  * by: Bpi=[ 0 ]
4728  * [ 0 ]
4729  * [ 0 ]
4730  * [ 0 ]
4731  * [ phi ]
4732  *
4733  * In 3d
4734  * Bvi=[ dh/dx 0 0 ]
4735  * [ 0 dh/dy 0 ]
4736  * [ 0 0 dh/dz ]
4737  * [ dh/dy dh/dx 0 ]
4738  * [ dh/dz 0 dh/dx ]
4739  * [ 0 dh/dz dh/dy ]
4740  * [ dh/dx dh/dy dh/dz ]
4741  * [ 0 0 0 ]
4742  *
4743  * Bpi=[ 0 ]
4744  * [ 0 ]
4745  * [ 0 ]
4746  * [ 0 ]
4747  * [ 0 ]
4748  * [ 0 ]
4749  * [ 0 ]
4750  * [ h ]
4751  * where phi is the finiteelement function for node i.
4752  * In 3d:
4753  */
4754 
4755  /*Fetch number of nodes for this finite element*/
4756  int pnumnodes = element->NumberofNodesPressure();
4757  int vnumnodes = element->NumberofNodesVelocity();
4758 
4759  /*Get nodal functions derivatives*/
4760  IssmDouble* vdbasis=xNew<IssmDouble>(dim*vnumnodes);
4761  IssmDouble* pbasis =xNew<IssmDouble>(pnumnodes);
4762  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
4763  element->NodalFunctionsPressure(pbasis,gauss);
4764 
4765  /*Build B_prime: */
4766  if(dim==2){
4767  for(int i=0;i<vnumnodes;i++){
4768  Bprime[(dim*vnumnodes+pnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4769  Bprime[(dim*vnumnodes+pnumnodes)*0+dim*i+1] = 0.;
4770  Bprime[(dim*vnumnodes+pnumnodes)*1+dim*i+0] = 0.;
4771  Bprime[(dim*vnumnodes+pnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4772  Bprime[(dim*vnumnodes+pnumnodes)*2+dim*i+0] = vdbasis[1*vnumnodes+i];
4773  Bprime[(dim*vnumnodes+pnumnodes)*2+dim*i+1] = vdbasis[0*vnumnodes+i];
4774  Bprime[(dim*vnumnodes+pnumnodes)*3+dim*i+0] = vdbasis[0*vnumnodes+i];
4775  Bprime[(dim*vnumnodes+pnumnodes)*3+dim*i+1] = vdbasis[1*vnumnodes+i];
4776  Bprime[(dim*vnumnodes+pnumnodes)*4+dim*i+0] = 0.;
4777  Bprime[(dim*vnumnodes+pnumnodes)*4+dim*i+1] = 0.;
4778  }
4779  for(int i=0;i<pnumnodes;i++){
4780  Bprime[(dim*vnumnodes+pnumnodes)*0+(dim*vnumnodes)+i] = 0.;
4781  Bprime[(dim*vnumnodes+pnumnodes)*1+(dim*vnumnodes)+i] = 0.;
4782  Bprime[(dim*vnumnodes+pnumnodes)*2+(dim*vnumnodes)+i] = 0.;
4783  Bprime[(dim*vnumnodes+pnumnodes)*3+(dim*vnumnodes)+i] = 0.;
4784  Bprime[(dim*vnumnodes+pnumnodes)*4+(dim*vnumnodes)+i] = pbasis[i];
4785  }
4786  }
4787  else{
4788  for(int i=0;i<vnumnodes;i++){
4789  Bprime[(dim*vnumnodes+pnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4790  Bprime[(dim*vnumnodes+pnumnodes)*0+dim*i+1] = 0.;
4791  Bprime[(dim*vnumnodes+pnumnodes)*0+dim*i+2] = 0.;
4792  Bprime[(dim*vnumnodes+pnumnodes)*1+dim*i+0] = 0.;
4793  Bprime[(dim*vnumnodes+pnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4794  Bprime[(dim*vnumnodes+pnumnodes)*1+dim*i+2] = 0.;
4795  Bprime[(dim*vnumnodes+pnumnodes)*2+dim*i+0] = 0.;
4796  Bprime[(dim*vnumnodes+pnumnodes)*2+dim*i+1] = 0.;
4797  Bprime[(dim*vnumnodes+pnumnodes)*2+dim*i+2] = vdbasis[2*vnumnodes+i];
4798  Bprime[(dim*vnumnodes+pnumnodes)*3+dim*i+0] = vdbasis[1*vnumnodes+i];
4799  Bprime[(dim*vnumnodes+pnumnodes)*3+dim*i+1] = vdbasis[0*vnumnodes+i];
4800  Bprime[(dim*vnumnodes+pnumnodes)*3+dim*i+2] = 0.;
4801  Bprime[(dim*vnumnodes+pnumnodes)*4+dim*i+0] = vdbasis[2*vnumnodes+i];
4802  Bprime[(dim*vnumnodes+pnumnodes)*4+dim*i+1] = 0.;
4803  Bprime[(dim*vnumnodes+pnumnodes)*4+dim*i+2] = vdbasis[0*vnumnodes+i];
4804  Bprime[(dim*vnumnodes+pnumnodes)*5+dim*i+0] = 0.;
4805  Bprime[(dim*vnumnodes+pnumnodes)*5+dim*i+1] = vdbasis[2*vnumnodes+i];
4806  Bprime[(dim*vnumnodes+pnumnodes)*5+dim*i+2] = vdbasis[1*vnumnodes+i];
4807  Bprime[(dim*vnumnodes+pnumnodes)*6+dim*i+0] = vdbasis[0*vnumnodes+i];
4808  Bprime[(dim*vnumnodes+pnumnodes)*6+dim*i+1] = vdbasis[1*vnumnodes+i];
4809  Bprime[(dim*vnumnodes+pnumnodes)*6+dim*i+2] = vdbasis[2*vnumnodes+i];
4810  Bprime[(dim*vnumnodes+pnumnodes)*7+dim*i+0] = 0.;
4811  Bprime[(dim*vnumnodes+pnumnodes)*7+dim*i+1] = 0.;
4812  Bprime[(dim*vnumnodes+pnumnodes)*7+dim*i+2] = 0.;
4813  }
4814  for(int i=0;i<pnumnodes;i++){
4815  Bprime[(dim*vnumnodes+pnumnodes)*0+(dim*vnumnodes)+i] = 0.;
4816  Bprime[(dim*vnumnodes+pnumnodes)*1+(dim*vnumnodes)+i] = 0.;
4817  Bprime[(dim*vnumnodes+pnumnodes)*2+(dim*vnumnodes)+i] = 0.;
4818  Bprime[(dim*vnumnodes+pnumnodes)*3+(dim*vnumnodes)+i] = 0.;
4819  Bprime[(dim*vnumnodes+pnumnodes)*4+(dim*vnumnodes)+i] = 0.;
4820  Bprime[(dim*vnumnodes+pnumnodes)*5+(dim*vnumnodes)+i] = 0.;
4821  Bprime[(dim*vnumnodes+pnumnodes)*6+(dim*vnumnodes)+i] = 0.;
4822  Bprime[(dim*vnumnodes+pnumnodes)*7+(dim*vnumnodes)+i] = pbasis[i];
4823  }
4824  }
4825 
4826  /*Clean up*/
4827  xDelete<IssmDouble>(vdbasis);
4828  xDelete<IssmDouble>(pbasis);
4829 }/*}}}*/

◆ GetBFSprimeUzawa()

void StressbalanceAnalysis::GetBFSprimeUzawa ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4830 of file StressbalanceAnalysis.cpp.

4830  {/*{{{*/
4831  /* Compute B' matrix. B'=[B1' B2' B3' B4' B5' B6'] where Bi' is of size 3*2.
4832  * For node i, Bi' can be expressed in the actual coordinate system
4833  * by:
4834  * Bvi' = [ dphi/dx dphi/dy ]
4835  *
4836  * In 3d
4837  * Bvi=[ dh/dx dh/dy dh/dz ]
4838  * where phi is the finiteelement function for node i.
4839  */
4840 
4841  /*Fetch number of nodes for this finite element*/
4842  int vnumnodes = element->NumberofNodesVelocity();
4843 
4844  /*Get nodal functions derivatives*/
4845  IssmDouble* vdbasis=xNew<IssmDouble>(dim*vnumnodes);
4846  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
4847 
4848  /*Build B_prime: */
4849  if(dim==2){
4850  for(int i=0;i<vnumnodes;i++){
4851  Bprime[dim*i+0] = vdbasis[0*vnumnodes+i];
4852  Bprime[dim*i+1] = vdbasis[1*vnumnodes+i];
4853  }
4854  }
4855  else{
4856  for(int i=0;i<vnumnodes;i++){
4857  Bprime[dim*i+0] = vdbasis[0*vnumnodes+i];
4858  Bprime[dim*i+1] = vdbasis[1*vnumnodes+i];
4859  Bprime[dim*i+2] = vdbasis[2*vnumnodes+i];
4860  }
4861  }
4862 
4863  /*Clean up*/
4864  xDelete<IssmDouble>(vdbasis);
4865 }/*}}}*/

◆ GetBFSprimevel()

void StressbalanceAnalysis::GetBFSprimevel ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4866 of file StressbalanceAnalysis.cpp.

4866  {/*{{{*/
4867  /* Compute B' matrix. B'=[B1' B2' B3' B4' B5' B6' Bb'] where Bi' is of size 3*2.
4868  * For node i, Bi' can be expressed in the actual coordinate system
4869  * by:
4870  * Bvi' = [ dphi/dx 0 ]
4871  * [ 0 dphi/dy ]
4872  * [ dphi/dy dphi/dx ]
4873  *
4874  * In 3d
4875  * Bvi=[ dh/dx 0 0 ]
4876  * [ 0 dh/dy 0 ]
4877  * [ 0 0 dh/dz ]
4878  * [ dh/dy dh/dx 0 ]
4879  * [ dh/dz 0 dh/dx ]
4880  * [ 0 dh/dz dh/dy ]
4881  * where phi is the finiteelement function for node i.
4882  * In 3d:
4883  */
4884 
4885  /*Fetch number of nodes for this finite element*/
4886  int vnumnodes = element->NumberofNodesVelocity();
4887 
4888  /*Get nodal functions derivatives*/
4889  IssmDouble* vdbasis=xNew<IssmDouble>(dim*vnumnodes);
4890  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
4891 
4892  /*Build B_prime: */
4893  if(dim==2){
4894  for(int i=0;i<vnumnodes;i++){
4895  Bprime[(dim*vnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4896  Bprime[(dim*vnumnodes)*0+dim*i+1] = 0.;
4897  Bprime[(dim*vnumnodes)*1+dim*i+0] = 0.;
4898  Bprime[(dim*vnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4899  Bprime[(dim*vnumnodes)*2+dim*i+0] = vdbasis[1*vnumnodes+i];
4900  Bprime[(dim*vnumnodes)*2+dim*i+1] = vdbasis[0*vnumnodes+i];
4901  }
4902  }
4903  else{
4904  for(int i=0;i<vnumnodes;i++){
4905  Bprime[(dim*vnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4906  Bprime[(dim*vnumnodes)*0+dim*i+1] = 0.;
4907  Bprime[(dim*vnumnodes)*0+dim*i+2] = 0.;
4908  Bprime[(dim*vnumnodes)*1+dim*i+0] = 0.;
4909  Bprime[(dim*vnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4910  Bprime[(dim*vnumnodes)*1+dim*i+2] = 0.;
4911  Bprime[(dim*vnumnodes)*2+dim*i+0] = 0.;
4912  Bprime[(dim*vnumnodes)*2+dim*i+1] = 0.;
4913  Bprime[(dim*vnumnodes)*2+dim*i+2] = vdbasis[2*vnumnodes+i];
4914  Bprime[(dim*vnumnodes)*3+dim*i+0] = vdbasis[1*vnumnodes+i];
4915  Bprime[(dim*vnumnodes)*3+dim*i+1] = vdbasis[0*vnumnodes+i];
4916  Bprime[(dim*vnumnodes)*3+dim*i+2] = 0.;
4917  Bprime[(dim*vnumnodes)*4+dim*i+0] = vdbasis[2*vnumnodes+i];
4918  Bprime[(dim*vnumnodes)*4+dim*i+1] = 0.;
4919  Bprime[(dim*vnumnodes)*4+dim*i+2] = vdbasis[0*vnumnodes+i];
4920  Bprime[(dim*vnumnodes)*5+dim*i+0] = 0.;
4921  Bprime[(dim*vnumnodes)*5+dim*i+1] = vdbasis[2*vnumnodes+i];
4922  Bprime[(dim*vnumnodes)*5+dim*i+2] = vdbasis[1*vnumnodes+i];
4923  }
4924  }
4925 
4926  /*Clean up*/
4927  xDelete<IssmDouble>(vdbasis);
4928 }/*}}}*/

◆ GetBFSUzawa()

void StressbalanceAnalysis::GetBFSUzawa ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4929 of file StressbalanceAnalysis.cpp.

4929  {/*{{{*/
4930  /*Compute B matrix. B=[Bp1 Bp2 ...] where Bpi=phi_pi.
4931  */
4932 
4933  /*Fetch number of nodes for this finite element*/
4934  int pnumnodes;
4935  if(dim==2) pnumnodes=3;
4936  else pnumnodes=6;
4937  //int pnumnodes = element->NumberofNodes(P1Enum);
4938 
4939  /*Get nodal functions derivatives*/
4940  IssmDouble* basis =xNew<IssmDouble>(pnumnodes);
4941  element->NodalFunctionsP1(basis,gauss);
4942 
4943  /*Build B: */
4944  for(int i=0;i<pnumnodes;i++){
4945  B[i] = basis[i];
4946  }
4947 
4948  /*Clean up*/
4949  xDelete<IssmDouble>(basis);
4950 }/*}}}*/

◆ GetBFSvel()

void StressbalanceAnalysis::GetBFSvel ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 4951 of file StressbalanceAnalysis.cpp.

4951  {/*{{{*/
4952  /*Compute B matrix. B=[Bv1 Bv2 ... Bp1 Bp2 ...] where Bvi is of size 3*3.
4953  * For node i, Bvi can be expressed in the actual coordinate system
4954  * by: Bvi=[ dphi/dx 0 ]
4955  * [ 0 dphi/dy ]
4956  * [ 1/2*dphi/dy 1/2*dphi/dx]
4957  *
4958  *
4959  * In 3d:
4960  * Bvi=[ dh/dx 0 0 ]
4961  * [ 0 dh/dy 0 ]
4962  * [ 0 0 dh/dz ]
4963  * [ 1/2*dh/dy 1/2*dh/dx 0 ]
4964  * [ 1/2*dh/dz 0 1/2*dh/dx ]
4965  * [ 0 1/2*dh/dz 1/2*dh/dy ]
4966  *
4967  * where phi is the finiteelement function for node i.
4968  * Same thing for Bb except the last column that does not exist.
4969  */
4970 
4971  /*Fetch number of nodes for this finite element*/
4972  int vnumnodes = element->NumberofNodesVelocity();
4973 
4974  /*Get nodal functions derivatives*/
4975  IssmDouble* vdbasis=xNew<IssmDouble>(dim*vnumnodes);
4976  element->NodalFunctionsDerivativesVelocity(vdbasis,xyz_list,gauss);
4977 
4978  /*Build B: */
4979  if(dim==2){
4980  for(int i=0;i<vnumnodes;i++){
4981  B[(dim*vnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4982  B[(dim*vnumnodes)*0+dim*i+1] = 0.;
4983  B[(dim*vnumnodes)*1+dim*i+0] = 0.;
4984  B[(dim*vnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4985  B[(dim*vnumnodes)*2+dim*i+0] = .5*vdbasis[1*vnumnodes+i];
4986  B[(dim*vnumnodes)*2+dim*i+1] = .5*vdbasis[0*vnumnodes+i];
4987  }
4988  }
4989  else{
4990  for(int i=0;i<vnumnodes;i++){
4991  B[(dim*vnumnodes)*0+dim*i+0] = vdbasis[0*vnumnodes+i];
4992  B[(dim*vnumnodes)*0+dim*i+1] = 0.;
4993  B[(dim*vnumnodes)*0+dim*i+2] = 0.;
4994  B[(dim*vnumnodes)*1+dim*i+0] = 0.;
4995  B[(dim*vnumnodes)*1+dim*i+1] = vdbasis[1*vnumnodes+i];
4996  B[(dim*vnumnodes)*1+dim*i+2] = 0.;
4997  B[(dim*vnumnodes)*2+dim*i+0] = 0.;
4998  B[(dim*vnumnodes)*2+dim*i+1] = 0.;
4999  B[(dim*vnumnodes)*2+dim*i+2] = vdbasis[2*vnumnodes+i];
5000  B[(dim*vnumnodes)*3+dim*i+0] = .5*vdbasis[1*vnumnodes+i];
5001  B[(dim*vnumnodes)*3+dim*i+1] = .5*vdbasis[0*vnumnodes+i];
5002  B[(dim*vnumnodes)*3+dim*i+2] = 0.;
5003  B[(dim*vnumnodes)*4+dim*i+0] = .5*vdbasis[2*vnumnodes+i];
5004  B[(dim*vnumnodes)*4+dim*i+1] = 0.;
5005  B[(dim*vnumnodes)*4+dim*i+2] = .5*vdbasis[0*vnumnodes+i];
5006  B[(dim*vnumnodes)*5+dim*i+0] = 0.;
5007  B[(dim*vnumnodes)*5+dim*i+1] = .5*vdbasis[2*vnumnodes+i];
5008  B[(dim*vnumnodes)*5+dim*i+2] = .5*vdbasis[1*vnumnodes+i];
5009  }
5010  }
5011 
5012  /*Clean up*/
5013  xDelete<IssmDouble>(vdbasis);
5014 }/*}}}*/

◆ GetCFS()

void StressbalanceAnalysis::GetCFS ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 5015 of file StressbalanceAnalysis.cpp.

5015  {/*{{{*/
5016  /*Compute C matrix. C=[Cp1 Cp2 ...] where:
5017  * Cpi=[phi phi].
5018  */
5019 
5020  /*Fetch number of nodes for this finite element*/
5021  int lnumnodes = element->GetNumberOfNodes(P2Enum);
5022 
5023  /*Get nodal functions derivatives*/
5024  IssmDouble* basis =xNew<IssmDouble>(lnumnodes);
5025  element->NodalFunctionsP2(basis,gauss);
5026 
5027  /*Build B: */
5028  for(int i=0;i<lnumnodes;i++){
5029  C[lnumnodes*0+i] = basis[i];
5030  C[lnumnodes*1+i] = basis[i];
5031  }
5032 
5033  /*Clean up*/
5034  xDelete<IssmDouble>(basis);
5035 }/*}}}*/

◆ GetCFSprime()

void StressbalanceAnalysis::GetCFSprime ( IssmDouble *  B,
Element *  element,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 5036 of file StressbalanceAnalysis.cpp.

5036  {/*{{{*/
5037  /* Compute C' matrix. C'=[C1' C2' ...]
5038  * Ci' = [ phi 0 ]
5039  * [ 0 phi ]
5040  *
5041  * In 3d
5042  * Ci' = [ phi 0 0 ]
5043  * [ 0 phi 0 ]
5044  * [ 0 0 phi ]
5045  * where phi is the finiteelement function for node i.
5046  */
5047 
5048  /*Fetch number of nodes for this finite element*/
5049  int vnumnodes = element->NumberofNodesVelocity();
5050  int vnumdof = vnumnodes*dim;
5051 
5052  IssmDouble* vbasis=xNew<IssmDouble>(vnumnodes);
5053  element->NodalFunctionsVelocity(vbasis,gauss);
5054 
5055  /*Build B: */
5056  if(dim==3){
5057  for(int i=0;i<vnumnodes;i++){
5058  Cprime[vnumdof*0+3*i+0] = vbasis[i];
5059  Cprime[vnumdof*0+3*i+1] = 0.;
5060  Cprime[vnumdof*0+3*i+2] = 0.;
5061 
5062  Cprime[vnumdof*1+3*i+0] = 0.;
5063  Cprime[vnumdof*1+3*i+1] = vbasis[i];
5064  Cprime[vnumdof*1+3*i+2] = 0.;
5065 
5066  Cprime[vnumdof*2+3*i+0] = 0.;
5067  Cprime[vnumdof*2+3*i+1] = 0.;
5068  Cprime[vnumdof*2+3*i+2] = vbasis[i];
5069  }
5070  }
5071  else{
5072  for(int i=0;i<vnumnodes;i++){
5073  Cprime[vnumdof*0+2*i+0] = vbasis[i];
5074  Cprime[vnumdof*0+2*i+1] = 0.;
5075 
5076  Cprime[vnumdof*1+2*i+0] = 0.;
5077  Cprime[vnumdof*1+2*i+1] = vbasis[i];
5078  }
5079  }
5080 
5081  /*Clean-up*/
5082  xDelete<IssmDouble>(vbasis);
5083 }/*}}}*/

◆ GetSolutionFromInputsFS()

void StressbalanceAnalysis::GetSolutionFromInputsFS ( Vector< IssmDouble > *  solution,
Element *  element 
)

Definition at line 5084 of file StressbalanceAnalysis.cpp.

5084  {/*{{{*/
5085 
5086  int* vdoflist=NULL;
5087  int* pdoflist=NULL;
5088  Input2* vz_input=NULL;
5089  int dim;
5090  IssmDouble vx,vy,vz,p;
5091  IssmDouble FSreconditioning;
5092 
5093  /*Get some parameters*/
5094  element->FindParam(&dim,DomainDimensionEnum);
5095  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
5096 
5097  /*Fetch number of nodes and dof for this finite element*/
5098  int vnumnodes = element->NumberofNodesVelocity();
5099  int pnumnodes = element->NumberofNodesPressure();
5100  int vnumdof = vnumnodes*dim;
5101  int pnumdof = pnumnodes*1;
5102 
5103  /*Initialize values*/
5104  IssmDouble* vvalues = xNew<IssmDouble>(vnumdof);
5105  IssmDouble* pvalues = xNew<IssmDouble>(pnumdof);
5106 
5107  /*Get dof list: */
5108  element->GetDofListVelocity(&vdoflist,GsetEnum);
5109  element->GetDofListPressure(&pdoflist,GsetEnum);
5110  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
5111  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
5112  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
5113  Input2* p_input =element->GetInput2(PressureEnum); _assert_(p_input);
5114 
5115  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
5116 
5117  /*Ok, we have the velocities in inputs, fill in solution */
5118  Gauss* gauss = element->NewGauss();
5119  for(int i=0;i<vnumnodes;i++){
5120  gauss->GaussNode(element->VelocityInterpolation(),i);
5121  vx_input->GetInputValue(&vx,gauss);
5122  vy_input->GetInputValue(&vy,gauss);
5123  vvalues[i*dim+0]=vx;
5124  vvalues[i*dim+1]=vy;
5125  if(dim==3){
5126  vz_input->GetInputValue(&vz,gauss);
5127  vvalues[i*dim+2]=vz;
5128  }
5129  }
5130  for(int i=0;i<pnumnodes;i++){
5131  gauss->GaussNode(element->PressureInterpolation(),i);
5132  p_input->GetInputValue(&p ,gauss);
5133  pvalues[i]=p/FSreconditioning;
5134  }
5135 
5136  /*Do NOT account for bubble using GetInputValue! This is wrong*/
5137  if(element->VelocityInterpolation()==P1bubblecondensedEnum ||
5138  element->VelocityInterpolation()==P1bubbleEnum){
5139  vvalues[(vnumnodes-1)*dim+0]=0.;
5140  vvalues[(vnumnodes-1)*dim+1]=0.;
5141  if(dim==3) vvalues[(vnumnodes-1)*dim+2]=0.;
5142  }
5143 
5144  /*Add value to global vector*/
5145  solution->SetValues(vnumdof,vdoflist,vvalues,INS_VAL);
5146  if(pnumdof>0) solution->SetValues(pnumdof,pdoflist,pvalues,INS_VAL);
5147 
5148  /*Free ressources:*/
5149  delete gauss;
5150  xDelete<int>(pdoflist);
5151  xDelete<int>(vdoflist);
5152  xDelete<IssmDouble>(pvalues);
5153  xDelete<IssmDouble>(vvalues);
5154 }/*}}}*/

◆ InitializeXTH()

void StressbalanceAnalysis::InitializeXTH ( Elements *  elements,
Parameters *  parameters 
)

Definition at line 5155 of file StressbalanceAnalysis.cpp.

5155  {/*{{{*/
5156 
5157  /*Intermediaries*/
5158  int dim;
5159  IssmDouble dvx[3],dvy[3],dvz[3];
5160  IssmDouble viscosity;
5161  IssmDouble *xyz_list = NULL;
5162 
5163  /*Get problem dimension*/
5164  parameters->FindParam(&dim,DomainDimensionEnum);
5165 
5166  for(int i=0;i<elements->Size();i++){
5167  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5168 
5169  /*Get inputs and parameters*/
5170  element->GetVerticesCoordinates(&xyz_list);
5171  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
5172  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
5173  Input2* vz_input;
5174  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
5175 
5176  /*Allocate new inputs*/
5177  int tnumnodes = element->GetNumberOfVertices(); //Tensors, P1 DG
5178  IssmDouble* epsxx = xNew<IssmDouble>(tnumnodes); IssmDouble* sigmapxx = xNew<IssmDouble>(tnumnodes);
5179  IssmDouble* epsyy = xNew<IssmDouble>(tnumnodes); IssmDouble* sigmapyy = xNew<IssmDouble>(tnumnodes);
5180  IssmDouble* epsxy = xNew<IssmDouble>(tnumnodes); IssmDouble* sigmapxy = xNew<IssmDouble>(tnumnodes);
5181  IssmDouble* epszz = NULL; IssmDouble* sigmapzz = NULL;
5182  IssmDouble* epsxz = NULL; IssmDouble* sigmapxz = NULL;
5183  IssmDouble* epsyz = NULL; IssmDouble* sigmapyz = NULL;
5184  if(dim==3){
5185  epszz = xNew<IssmDouble>(tnumnodes); sigmapzz = xNew<IssmDouble>(tnumnodes);
5186  epsxz = xNew<IssmDouble>(tnumnodes); sigmapxz = xNew<IssmDouble>(tnumnodes);
5187  epsyz = xNew<IssmDouble>(tnumnodes); sigmapyz = xNew<IssmDouble>(tnumnodes);
5188  }
5189 
5190  /*Get d and tau*/
5191  Gauss* gauss = element->NewGauss();
5192  for(int i=0;i<tnumnodes;i++){
5193  gauss->GaussNode(P1DGEnum,i);
5194 
5195  vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
5196  vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
5197  if(dim==3){
5198  vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
5199  }
5200 
5201  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
5202  epsxx[i] = dvx[0]; sigmapxx[i] = 2.*viscosity*epsxx[i];
5203  epsyy[i] = dvy[1]; sigmapyy[i] = 2.*viscosity*epsyy[i];
5204  epsxy[i] = 0.5*(dvx[1] + dvy[0]); sigmapxy[i] = 2.*viscosity*epsxy[i];
5205  if(dim==3){
5206  epszz[i] = dvz[2]; sigmapzz[i] = 2.*viscosity*epszz[i];
5207  epsxz[i] = 0.5*(dvx[2] + dvz[0]); sigmapxz[i] = 2.*viscosity*epsxz[i];
5208  epsyz[i] = 0.5*(dvy[2] + dvz[1]); sigmapyz[i] = 2.*viscosity*epsyz[i];
5209  }
5210  }
5211 
5212  /*Add inputs*/
5213  element->AddInput2(StrainRatexxEnum,epsxx,P1DGEnum); element->AddInput2(DeviatoricStressxxEnum,sigmapxx,P1DGEnum);
5214  element->AddInput2(StrainRateyyEnum,epsyy,P1DGEnum); element->AddInput2(DeviatoricStressyyEnum,sigmapyy,P1DGEnum);
5215  element->AddInput2(StrainRatexyEnum,epsxy,P1DGEnum); element->AddInput2(DeviatoricStressxyEnum,sigmapxy,P1DGEnum);
5216  if(dim==3){
5217  element->AddInput2(StrainRatezzEnum,epszz,P1DGEnum); element->AddInput2(DeviatoricStresszzEnum,sigmapzz,P1DGEnum);
5218  element->AddInput2(StrainRatexzEnum,epsxz,P1DGEnum); element->AddInput2(DeviatoricStressxzEnum,sigmapxz,P1DGEnum);
5219  element->AddInput2(StrainRateyzEnum,epsyz,P1DGEnum); element->AddInput2(DeviatoricStressyzEnum,sigmapyz,P1DGEnum);
5220  }
5221 
5222  /*Clean up*/
5223  delete gauss;
5224  xDelete<IssmDouble>(xyz_list);
5225  xDelete<IssmDouble>(epsxx); xDelete<IssmDouble>(sigmapxx);
5226  xDelete<IssmDouble>(epsyy); xDelete<IssmDouble>(sigmapyy);
5227  xDelete<IssmDouble>(epszz); xDelete<IssmDouble>(sigmapzz);
5228  xDelete<IssmDouble>(epsxy); xDelete<IssmDouble>(sigmapxy);
5229  xDelete<IssmDouble>(epsxz); xDelete<IssmDouble>(sigmapxz);
5230  xDelete<IssmDouble>(epsyz); xDelete<IssmDouble>(sigmapyz);
5231  }
5232 
5233 }/*}}}*/

◆ InputUpdateFromSolutionFS()

void StressbalanceAnalysis::InputUpdateFromSolutionFS ( IssmDouble *  solution,
Element *  element 
)

Definition at line 5234 of file StressbalanceAnalysis.cpp.

5234  {/*{{{*/
5235 
5236  int i,dim;
5237  int* vdoflist=NULL;
5238  int* pdoflist=NULL;
5239  IssmDouble FSreconditioning;
5240 
5241  element->FindParam(&dim,DomainDimensionEnum);
5242  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
5243 
5244  /*Fetch number of nodes and dof for this finite element*/
5245  int vnumnodes = element->NumberofNodesVelocity();
5246  int pnumnodes = element->NumberofNodesPressure();
5247  int vnumdof = vnumnodes*dim;
5248  int pnumdof = pnumnodes*1;
5249 
5250  /*Initialize values*/
5251  IssmDouble* values = xNew<IssmDouble>(vnumdof+pnumdof);
5252  IssmDouble* vx = xNew<IssmDouble>(vnumnodes);
5253  IssmDouble* vy = xNew<IssmDouble>(vnumnodes);
5254  IssmDouble* vz = xNew<IssmDouble>(vnumnodes);
5255  IssmDouble* vel = xNew<IssmDouble>(vnumnodes);
5256  IssmDouble* pressure = xNew<IssmDouble>(pnumnodes);
5257 
5258  /*Prepare coordinate system list*/
5259  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
5260  if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
5261  else for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
5262  for(i=0;i<pnumnodes;i++) cs_list[vnumnodes+i] = PressureEnum;
5263 
5264  /*Get dof list: */
5265  element->GetDofListLocalVelocity(&vdoflist,GsetEnum);
5266  element->GetDofListLocalPressure(&pdoflist,GsetEnum);
5267 
5268  /*Use the dof list to index into the solution vector: */
5269  for(i=0;i<vnumdof;i++) values[i] =solution[vdoflist[i]];
5270  for(i=0;i<pnumdof;i++) values[vnumdof+i]=solution[pdoflist[i]];
5271 
5272  /*Transform solution in Cartesian Space*/
5273  element->TransformSolutionCoord(values,cs_list);
5274 
5275  /*Ok, we have vx and vy in values, fill in all arrays: */
5276  for(i=0;i<vnumnodes;i++){
5277  vx[i] = values[i*dim+0];
5278  vy[i] = values[i*dim+1];
5279  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
5280  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
5281  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
5282  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
5283 
5284  if(dim==3){
5285  vz[i] = values[i*dim+2];
5286  if(xIsNan<IssmDouble>(vz[i])) _error_("NaN found in solution vector");
5287  if(xIsInf<IssmDouble>(vz[i])) _error_("Inf found in solution vector");
5288  }
5289  }
5290  for(i=0;i<pnumnodes;i++){
5291  pressure[i] = values[vnumdof+i];
5292  if(xIsNan<IssmDouble>(pressure[i])) _error_("NaN found in solution vector");
5293  if(xIsInf<IssmDouble>(pressure[i])) _error_("Inf found in solution vector");
5294  }
5295 
5296  /*Recondition pressure and compute vel: */
5297  for(i=0;i<pnumnodes;i++) pressure[i] = pressure[i]*FSreconditioning;
5298  if(dim==3) for(i=0;i<vnumnodes;i++) vel[i] = sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
5299  else for(i=0;i<vnumnodes;i++) vel[i] = sqrt(vx[i]*vx[i] + vy[i]*vy[i]);
5300 
5301  /*Add vx and vy as inputs to the tria element: */
5302  int v_interp = element->VelocityInterpolation();
5303  if(v_interp==P1bubbleEnum) v_interp=P1Enum;
5304  if(v_interp == P1bubblecondensedEnum) v_interp = P1Enum;
5305  element->AddInput2(VxEnum, vx, v_interp);
5306  element->AddInput2(VyEnum, vy, v_interp);
5307  element->AddInput2(VelEnum,vel,v_interp);
5308  if(pnumdof>0) element->AddInput2(PressureEnum,pressure,element->PressureInterpolation());
5309  if(dim==3) element->AddInput2(VzEnum,vz,v_interp);
5310 
5311  /*Free ressources:*/
5312  xDelete<IssmDouble>(pressure);
5313  xDelete<IssmDouble>(vel);
5314  xDelete<IssmDouble>(vz);
5315  xDelete<IssmDouble>(vy);
5316  xDelete<IssmDouble>(vx);
5317  xDelete<IssmDouble>(values);
5318  xDelete<int>(vdoflist);
5319  xDelete<int>(pdoflist);
5320  xDelete<int>(cs_list);
5321 }/*}}}*/

◆ InputUpdateFromSolutionFSXTH_d()

void StressbalanceAnalysis::InputUpdateFromSolutionFSXTH_d ( Elements *  elements,
Parameters *  parameters 
)

Definition at line 5322 of file StressbalanceAnalysis.cpp.

5322  {/*{{{*/
5323 
5324  /*Intermediaries*/
5325  int dim,tausize;
5326  IssmDouble epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar;
5327  IssmDouble epsxx_old,epsyy_old,epszz_old,epsxy_old,epsxz_old,epsyz_old;
5328  IssmDouble sigmapxx,sigmapyy,sigmapzz,sigmapxy,sigmapxz,sigmapyz;
5329  IssmDouble dvx[3],dvy[3],dvz[3],B,n;
5330  IssmDouble *xyz_list = NULL;
5331  IssmDouble Jdet,r;
5332 
5333  parameters->FindParam(&r,AugmentedLagrangianREnum);
5334  parameters->FindParam(&dim,DomainDimensionEnum);
5335  if(dim==2) tausize = 3;
5336  else tausize = 6;
5337 
5338  for(int i=0;i<elements->Size();i++){
5339  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5340 
5341  /*Get inputs and parameters*/
5342  element->GetVerticesCoordinates(&xyz_list);
5343  Input2* B_input=element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
5344  Input2* n_input=element->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
5345  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
5346  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
5347  Input2* vz_input;
5348  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
5349 
5350  /*Fetch number of nodes and dof for this finite element*/
5351  int tnumnodes = element->GetNumberOfVertices(); //Tensors, P1 DG
5352 
5353  /*Initialize vectors*/
5354  IssmDouble* tbasis = xNew<IssmDouble>(tnumnodes);
5355  IssmDouble* Ke = xNewZeroInit<IssmDouble>(tnumnodes*tnumnodes);
5356  IssmDouble* pe_xx = xNewZeroInit<IssmDouble>(tnumnodes);
5357  IssmDouble* pe_yy = xNewZeroInit<IssmDouble>(tnumnodes);
5358  IssmDouble* pe_xy = xNewZeroInit<IssmDouble>(tnumnodes);
5359  IssmDouble* pe_zz = NULL; IssmDouble* pe_xz = NULL; IssmDouble* pe_yz = NULL;
5360  if(dim==3){
5361  pe_zz = xNewZeroInit<IssmDouble>(tnumnodes);
5362  pe_xz = xNewZeroInit<IssmDouble>(tnumnodes);
5363  pe_yz = xNewZeroInit<IssmDouble>(tnumnodes);
5364  }
5365 
5366  /*Get previous d*/
5367  Input2* epsxx_input=element->GetInput2(StrainRatexxEnum); _assert_(epsxx_input);
5368  Input2* epsyy_input=element->GetInput2(StrainRateyyEnum); _assert_(epsyy_input);
5369  Input2* epsxy_input=element->GetInput2(StrainRatexyEnum); _assert_(epsxy_input);
5370  Input2* epszz_input=NULL; Input2* epsxz_input=NULL; Input2* epsyz_input=NULL;
5371  if(dim==3){
5372  epszz_input=element->GetInput2(StrainRatezzEnum); _assert_(epszz_input);
5373  epsxz_input=element->GetInput2(StrainRatexzEnum); _assert_(epsxz_input);
5374  epsyz_input=element->GetInput2(StrainRateyzEnum); _assert_(epsyz_input);
5375  }
5376 
5377  /*Get tau*/
5378  Input2* sigmapxx_input=element->GetInput2(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
5379  Input2* sigmapyy_input=element->GetInput2(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
5380  Input2* sigmapxy_input=element->GetInput2(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
5381  Input2* sigmapzz_input=NULL; Input2* sigmapxz_input=NULL; Input2* sigmapyz_input=NULL;
5382  if(dim==3){
5383  sigmapzz_input=element->GetInput2(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
5384  sigmapxz_input=element->GetInput2(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
5385  sigmapyz_input=element->GetInput2(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
5386  }
5387 
5388  Gauss* gauss=element->NewGauss(5);
5389  for(int ig=gauss->begin();ig<gauss->end();ig++){
5390  gauss->GaussPoint(ig);
5391  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
5392  element->NodalFunctionsTensor(tbasis,gauss);
5393 
5394  /*Get tau from inputs*/
5395  sigmapxx_input->GetInputValue(&sigmapxx,gauss);
5396  sigmapyy_input->GetInputValue(&sigmapyy,gauss);
5397  sigmapxy_input->GetInputValue(&sigmapxy,gauss);
5398  if(dim==3){
5399  sigmapzz_input->GetInputValue(&sigmapzz,gauss);
5400  sigmapxz_input->GetInputValue(&sigmapxz,gauss);
5401  sigmapyz_input->GetInputValue(&sigmapyz,gauss);
5402  }
5403 
5404  /*Get previous d*/
5405  epsxx_input->GetInputValue(&epsxx_old,gauss);
5406  epsyy_input->GetInputValue(&epsyy_old,gauss);
5407  epsxy_input->GetInputValue(&epsxy_old,gauss);
5408  if(dim==3){
5409  epszz_input->GetInputValue(&epszz_old,gauss);
5410  epsxz_input->GetInputValue(&epsxz_old,gauss);
5411  epsyz_input->GetInputValue(&epsyz_old,gauss);
5412  }
5413 
5414  /*Calculate d from previous results*/
5415  vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
5416  vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
5417  if(dim==3){
5418  vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
5419  }
5420  epsxx = dvx[0];
5421  epsyy = dvy[1];
5422  epsxy = 0.5*(dvx[1] + dvy[0]);
5423  if(dim==3){
5424  epszz = dvz[2];
5425  epsxz = 0.5*(dvx[2] + dvz[0]);
5426  epsyz = 0.5*(dvy[2] + dvz[1]);
5427  }
5428 
5429  /*Solve 2 eta_0 |d|^s-1 + r |d| = |rD(u) + tau|*/
5430  IssmDouble coef1,coef2,coef3;
5431  B_input->GetInputValue(&B,gauss);
5432  n_input->GetInputValue(&n,gauss);
5433  coef1 = B*pow(1./sqrt(2.),(1.-n)/n); //2 eta_0 = 2 * B/(2* (1/sqrt(2) )^(n-1)/n )
5434  coef2 = r;
5435  if(dim==2){
5436  coef3 = sqrt(
5437  (r*epsxx + sigmapxx)*(r*epsxx + sigmapxx)
5438  + (r*epsyy + sigmapyy)*(r*epsyy + sigmapyy)
5439  + 2*(r*epsxy + sigmapxy)*(r*epsxy + sigmapxy)
5440  );
5441  }
5442  else{
5443  coef3 = sqrt(
5444  (r*epsxx + sigmapxx)*(r*epsxx + sigmapxx)
5445  + (r*epsyy + sigmapyy)*(r*epsyy + sigmapyy)
5446  + (r*epszz + sigmapzz)*(r*epszz + sigmapzz)
5447  + 2*(r*epsxy + sigmapxy)*(r*epsxy + sigmapxy)
5448  + 2*(r*epsxz + sigmapxz)*(r*epsxz + sigmapxz)
5449  + 2*(r*epsyz + sigmapyz)*(r*epsyz + sigmapyz)
5450  );
5451  }
5452  IssmDouble dnorm;
5453  if(dim==2){
5454  dnorm = sqrt( epsxx_old*epsxx_old + epsyy_old*epsyy_old + 2.*epsxy_old*epsxy_old );
5455  }
5456  else{
5457  dnorm = sqrt( epsxx_old*epsxx_old + epsyy_old*epsyy_old + epszz_old*epszz_old
5458  +2.*(epsxy_old*epsxy_old + epsxz_old*epsxz_old + epsyz_old*epsyz_old));
5459  }
5460  /*Initial guess cannot be 0 otherwise log(0) - inf*/
5461  if(dnorm==0.) dnorm=1.;
5462  NewtonSolveDnorm(&dnorm,coef1,coef2,coef3,n,dnorm);
5463  _assert_(dnorm>=0.);
5464  _assert_(!xIsNan<IssmDouble>(dnorm));
5465 
5466  /*Create Ke*/
5467  D_scalar=(coef1*pow(dnorm,(1.-n)/n)+r)*gauss->weight*Jdet;
5468  TripleMultiply(tbasis,tnumnodes,1,0,
5469  &D_scalar,1,1,0,
5470  tbasis,1,tnumnodes,0,
5471  Ke,1);
5472 
5473  /*Create Right hand sides*/
5474  for(int ii=0;ii<tnumnodes;ii++) pe_xx[ii] += (r*epsxx+sigmapxx)*tbasis[ii]*gauss->weight*Jdet;
5475  for(int ii=0;ii<tnumnodes;ii++) pe_yy[ii] += (r*epsyy+sigmapyy)*tbasis[ii]*gauss->weight*Jdet;
5476  for(int ii=0;ii<tnumnodes;ii++) pe_xy[ii] += (r*epsxy+sigmapxy)*tbasis[ii]*gauss->weight*Jdet;
5477  if(dim==3){
5478  for(int ii=0;ii<tnumnodes;ii++) pe_zz[ii] += (r*epszz+sigmapzz)*tbasis[ii]*gauss->weight*Jdet;
5479  for(int ii=0;ii<tnumnodes;ii++) pe_xz[ii] += (r*epsxz+sigmapxz)*tbasis[ii]*gauss->weight*Jdet;
5480  for(int ii=0;ii<tnumnodes;ii++) pe_yz[ii] += (r*epsyz+sigmapyz)*tbasis[ii]*gauss->weight*Jdet;
5481  }
5482  }
5483 
5484  /*Solve the systems*/
5485  IssmDouble* d_xx = xNew<IssmDouble>(tnumnodes);
5486  IssmDouble* d_yy = xNew<IssmDouble>(tnumnodes);
5487  IssmDouble* d_xy = xNew<IssmDouble>(tnumnodes);
5488  IssmDouble* d_zz = NULL;
5489  IssmDouble* d_xz = NULL;
5490  IssmDouble* d_yz = NULL;
5491  if(dim==2){
5492  _assert_(tnumnodes==3);
5493  Matrix3x3Solve(&d_xx[0],Ke,pe_xx);
5494  Matrix3x3Solve(&d_yy[0],Ke,pe_yy);
5495  Matrix3x3Solve(&d_xy[0],Ke,pe_xy);
5496  for(int i=0;i<3;i++) _assert_(!xIsNan<IssmDouble>(d_xx[i]));
5497  for(int i=0;i<3;i++) _assert_(!xIsNan<IssmDouble>(d_yy[i]));
5498  for(int i=0;i<3;i++) _assert_(!xIsNan<IssmDouble>(d_xx[i]));
5499  element->AddInput2(StrainRatexxEnum,d_xx,P1DGEnum);
5500  element->AddInput2(StrainRateyyEnum,d_yy,P1DGEnum);
5501  element->AddInput2(StrainRatexyEnum,d_xy,P1DGEnum);
5502  }
5503  else{
5504  _assert_(tnumnodes==4);
5505  d_zz = xNew<IssmDouble>(tnumnodes);
5506  d_xz = xNew<IssmDouble>(tnumnodes);
5507  d_yz = xNew<IssmDouble>(tnumnodes);
5508  Matrix4x4Solve(&d_xx[0],Ke,pe_xx);
5509  Matrix4x4Solve(&d_yy[0],Ke,pe_yy);
5510  Matrix4x4Solve(&d_xy[0],Ke,pe_xy);
5511  Matrix4x4Solve(&d_zz[0],Ke,pe_zz);
5512  Matrix4x4Solve(&d_xz[0],Ke,pe_xz);
5513  Matrix4x4Solve(&d_yz[0],Ke,pe_yz);
5514  element->AddInput2(StrainRatexxEnum,d_xx,P1DGEnum);
5515  element->AddInput2(StrainRateyyEnum,d_yy,P1DGEnum);
5516  element->AddInput2(StrainRatexyEnum,d_xy,P1DGEnum);
5517  element->AddInput2(StrainRatezzEnum,d_zz,P1DGEnum);
5518  element->AddInput2(StrainRatexzEnum,d_xz,P1DGEnum);
5519  element->AddInput2(StrainRateyzEnum,d_yz,P1DGEnum);
5520  }
5521 
5522  /*Clean up*/
5523  delete gauss;
5524  xDelete<IssmDouble>(xyz_list);
5525  xDelete<IssmDouble>(tbasis);
5526  xDelete<IssmDouble>(Ke);
5527  xDelete<IssmDouble>(pe_xx); xDelete<IssmDouble>(d_xx);
5528  xDelete<IssmDouble>(pe_yy); xDelete<IssmDouble>(d_yy);
5529  xDelete<IssmDouble>(pe_zz); xDelete<IssmDouble>(d_zz);
5530  xDelete<IssmDouble>(pe_xy); xDelete<IssmDouble>(d_xy);
5531  xDelete<IssmDouble>(pe_xz); xDelete<IssmDouble>(d_xz);
5532  xDelete<IssmDouble>(pe_yz); xDelete<IssmDouble>(d_yz);
5533  }
5534 }/*}}}*/

◆ InputUpdateFromSolutionFSXTH_tau()

void StressbalanceAnalysis::InputUpdateFromSolutionFSXTH_tau ( Elements *  elements,
Parameters *  parameters 
)

Definition at line 5535 of file StressbalanceAnalysis.cpp.

5535  {/*{{{*/
5536 
5537  /*Intermediaries*/
5538  int dim,tausize;
5539  IssmDouble epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar;
5540  IssmDouble d_xx,d_yy,d_zz,d_xy,d_xz,d_yz;
5541  IssmDouble sigmapxx,sigmapyy,sigmapzz,sigmapxy,sigmapxz,sigmapyz;
5542  IssmDouble dvx[3],dvy[3],dvz[3];
5543  IssmDouble *xyz_list = NULL;
5544  IssmDouble Jdet,r;
5545 
5546  parameters->FindParam(&r,AugmentedLagrangianREnum);
5547  parameters->FindParam(&dim,DomainDimensionEnum);
5548  if(dim==2) tausize = 3;
5549  else tausize = 6;
5550 
5551  for(int i=0;i<elements->Size();i++){
5552  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5553 
5554  /*Get inputs and parameters*/
5555  element->GetVerticesCoordinates(&xyz_list);
5556  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
5557  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
5558  Input2* vz_input=NULL;
5559  if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
5560 
5561  /*Get previous tau*/
5562  Input2* sigmapxx_input=element->GetInput2(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
5563  Input2* sigmapyy_input=element->GetInput2(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
5564  Input2* sigmapxy_input=element->GetInput2(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
5565  Input2* sigmapzz_input=NULL; Input2* sigmapxz_input=NULL; Input2* sigmapyz_input=NULL;
5566  if(dim==3){
5567  sigmapzz_input=element->GetInput2(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
5568  sigmapxz_input=element->GetInput2(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
5569  sigmapyz_input=element->GetInput2(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
5570  }
5571 
5572  /*Get NEW d*/
5573  Input2* epsxx_input=element->GetInput2(StrainRatexxEnum); _assert_(epsxx_input);
5574  Input2* epsyy_input=element->GetInput2(StrainRateyyEnum); _assert_(epsyy_input);
5575  Input2* epsxy_input=element->GetInput2(StrainRatexyEnum); _assert_(epsxy_input);
5576  Input2* epszz_input=NULL; Input2* epsxz_input=NULL; Input2* epsyz_input=NULL;
5577  if(dim==3){
5578  epszz_input=element->GetInput2(StrainRatezzEnum); _assert_(epszz_input);
5579  epsxz_input=element->GetInput2(StrainRatexzEnum); _assert_(epsxz_input);
5580  epsyz_input=element->GetInput2(StrainRateyzEnum); _assert_(epsyz_input);
5581  }
5582 
5583  /*Fetch number of nodes and dof for this finite element*/
5584  int tnumnodes = element->GetNumberOfVertices(); //Tensors, P1 DG
5585 
5586  /*Update tau accordingly*/
5587  IssmDouble* tau_xx = xNew<IssmDouble>(tnumnodes);
5588  IssmDouble* tau_yy = xNew<IssmDouble>(tnumnodes);
5589  IssmDouble* tau_xy = xNew<IssmDouble>(tnumnodes);
5590  IssmDouble* tau_zz = NULL;
5591  IssmDouble* tau_xz = NULL;
5592  IssmDouble* tau_yz = NULL;
5593  if(dim==3){
5594  tau_zz = xNew<IssmDouble>(tnumnodes);
5595  tau_xz = xNew<IssmDouble>(tnumnodes);
5596  tau_yz = xNew<IssmDouble>(tnumnodes);
5597  }
5598  Gauss* gauss = element->NewGauss();
5599  for(int ig=0;ig<tnumnodes;ig++){
5600  gauss->GaussNode(P1DGEnum,ig);
5601 
5602  /*Get D(u)*/
5603  vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
5604  vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
5605  if(dim==3){
5606  vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
5607  }
5608  epsxx = dvx[0];
5609  epsyy = dvy[1];
5610  epsxy = 0.5*(dvx[1] + dvy[0]);
5611  if(dim==3){
5612  epszz = dvz[2];
5613  epsxz = 0.5*(dvx[2] + dvz[0]);
5614  epsyz = 0.5*(dvy[2] + dvz[1]);
5615  }
5616 
5617  /*Get tau^(n-1) from inputs*/
5618  sigmapxx_input->GetInputValue(&sigmapxx,gauss);
5619  sigmapyy_input->GetInputValue(&sigmapyy,gauss);
5620  sigmapxy_input->GetInputValue(&sigmapxy,gauss);
5621  if(dim==3){
5622  sigmapzz_input->GetInputValue(&sigmapzz,gauss);
5623  sigmapxz_input->GetInputValue(&sigmapxz,gauss);
5624  sigmapyz_input->GetInputValue(&sigmapyz,gauss);
5625  }
5626 
5627  /*Get new d*/
5628  epsxx_input->GetInputValue(&d_xx,gauss);
5629  epsyy_input->GetInputValue(&d_yy,gauss);
5630  epsxy_input->GetInputValue(&d_xy,gauss);
5631  if(dim==3){
5632  epszz_input->GetInputValue(&d_zz,gauss);
5633  epsxz_input->GetInputValue(&d_xz,gauss);
5634  epsyz_input->GetInputValue(&d_yz,gauss);
5635  }
5636 
5637  /*Get d and update tau accordingly*/
5638  tau_xx[ig] = sigmapxx + r*(epsxx - d_xx);
5639  tau_yy[ig] = sigmapyy + r*(epsyy - d_yy);
5640  tau_xy[ig] = sigmapxy + r*(epsxy - d_xy);
5641  if(dim==3){
5642  tau_zz[ig] = sigmapzz + r*(epszz - d_zz);
5643  tau_xz[ig] = sigmapxz + r*(epsxz - d_xz);
5644  tau_yz[ig] = sigmapyz + r*(epsyz - d_yz);
5645  }
5646  }
5647 
5648  /*Add inputs*/
5649  element->AddInput2(DeviatoricStressxxEnum,tau_xx,P1DGEnum);
5650  element->AddInput2(DeviatoricStressyyEnum,tau_yy,P1DGEnum);
5651  element->AddInput2(DeviatoricStressxyEnum,tau_xy,P1DGEnum);
5652  if(dim==3){
5653  element->AddInput2(DeviatoricStresszzEnum,tau_zz,P1DGEnum);
5654  element->AddInput2(DeviatoricStressxzEnum,tau_xz,P1DGEnum);
5655  element->AddInput2(DeviatoricStressyzEnum,tau_yz,P1DGEnum);
5656  }
5657 
5658  /*Clean up and */
5659  delete gauss;
5660  xDelete<IssmDouble>(xyz_list);
5661  xDelete<IssmDouble>(tau_xx);
5662  xDelete<IssmDouble>(tau_yy);
5663  xDelete<IssmDouble>(tau_zz);
5664  xDelete<IssmDouble>(tau_xy);
5665  xDelete<IssmDouble>(tau_xz);
5666  xDelete<IssmDouble>(tau_yz);
5667  }
5668 }/*}}}*/

◆ CreateKMatrixCouplingHOFS()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingHOFS ( Element *  element)

Definition at line 5671 of file StressbalanceAnalysis.cpp.

5671  {/*{{{*/
5672 
5673  /* Check if ice in element */
5674  if(!element->IsIceInElement()) return NULL;
5675 
5676  /*Constants*/
5677  int numnodes = 3*6+1;
5678  int numdofp = 2*6;
5679  int numdofs = 4*6 + 3;
5680  int numdoftotal = (2+4)*6+ 3;
5681 
5682  /*Intermediaries*/
5683  int i,j,init;
5684  int* cs_list = xNew<int>(6*3+1);
5685  int* cs_list2 = xNew<int>(6*2+1);
5686  Node **node_list = xNew<Node*>(6*3+1);
5687 
5688  /*Some parameters needed*/
5689  init = element->FiniteElement();
5690 
5691  /*prepare node list*/
5692  for(i=0;i<6+1;i++){
5693  node_list[i+6] = element->GetNode(i);
5694  cs_list[i+6] = XYZEnum;
5695  cs_list2[i] = XYZEnum;
5696  }
5697  for(i=0;i<6;i++){
5698  node_list[i] = element->GetNode(i);
5699  node_list[i+2*6+1] = element->GetNode(i+6*1);
5700  cs_list[i] = XYEnum;
5701  cs_list[i+2*6+1] = PressureEnum;
5702  cs_list2[i+6+1] = PressureEnum;
5703  }
5704 
5705  /*compute all stiffness matrices for this element*/
5706  ElementMatrix* Ke1=element->NewElementMatrixCoupling(6,HOApproximationEnum);
5707  ElementMatrix* Ke2=element->NewElementMatrix(FSvelocityEnum);
5708  ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
5709  delete Ke1; delete Ke2;
5710 
5711  /*Compute HO Matrix with P1 element type\n");*/
5712  Ke1=CreateKMatrixFS(element); element->TransformInvStiffnessMatrixCoord(Ke1,node_list,2*6+1,cs_list2);
5713  int indices[3]={18,19,20};
5714  Ke1->StaticCondensation(3,&indices[0]);
5715  element->SetTemporaryElementType(P1Enum); // P1 needed for HO
5716  Ke2=CreateKMatrixHO(element); element->TransformInvStiffnessMatrixCoord(Ke2,XYEnum);
5717  element->SetTemporaryElementType(init); // P1 needed for HO
5718  /*Compute FS Matrix and condense it \n");*/
5719 
5720  for(i=0;i<numdofs;i++) for(j=0;j<6;j++){
5721  Ke->values[(i+numdofp)*numdoftotal+2*j+0]+=Ke1->values[i*numdofs+3*j+0];
5722  Ke->values[(i+numdofp)*numdoftotal+2*j+1]+=Ke1->values[i*numdofs+3*j+1];
5723  }
5724  for(i=0;i<numdofp;i++) for(j=0;j<6;j++){
5725  Ke->values[i*numdoftotal+numdofp+3*j+0]+=Ke2->values[i*numdofp+2*j+0];
5726  Ke->values[i*numdoftotal+numdofp+3*j+1]+=Ke2->values[i*numdofp+2*j+1];
5727  }
5728 
5729  /*Transform Coordinate System*/ //Do not transform, already done in the matrices
5730  element->TransformStiffnessMatrixCoord(Ke,node_list,numnodes,cs_list);
5731 
5732  /*clean-up and return*/
5733  xDelete<int>(cs_list);
5734  xDelete<int>(cs_list2);
5735  xDelete<Node*>(node_list);
5736  delete Ke1;
5737  delete Ke2;
5738  return Ke;
5739 }/*}}}*/

◆ CreateKMatrixCouplingSSAFS()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingSSAFS ( Element *  element)

Definition at line 5740 of file StressbalanceAnalysis.cpp.

5740  {/*{{{*/
5741 
5742  /*compute all stiffness matrices for this element*/
5743  ElementMatrix* Ke1=CreateKMatrixCouplingSSAFSViscous(element);
5744  ElementMatrix* Ke2=CreateKMatrixCouplingSSAFSFriction(element);
5745  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
5746 
5747  /*clean-up and return*/
5748  delete Ke1;
5749  delete Ke2;
5750  return Ke;
5751 }/*}}}*/

◆ CreateKMatrixCouplingSSAFSFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingSSAFSFriction ( Element *  element)

Definition at line 5752 of file StressbalanceAnalysis.cpp.

5752  {/*{{{*/
5753 
5754  /* Check if ice in element */
5755  if(!element->IsIceInElement()) return NULL;
5756 
5757  /*Constants*/
5758  const int numdofs = (6+1)*3 + 6*1;
5759  const int numdofm = 6 *2;
5760  const int numdof2d = 3 *3;
5761  const int numdof2dm = 3 *2;
5762  const int numdoftot = 6*2 + (6+1)*3 +6; // HO + FS vel + FS Pressure
5763 
5764  /*Intermediaries */
5765  int i,j,approximation;
5766  int dim=3;
5767  IssmDouble FSreconditioning,viscosity,alpha2_gauss,Jdet2d;
5768  IssmDouble bed_normal[3];
5769  IssmDouble LSSAFS[8][numdof2dm];
5770  IssmDouble LprimeSSAFS[8][numdofs];
5771  IssmDouble DLSSAFS[8][8]={0.0};
5772  IssmDouble LFSSSA[4][numdof2d];
5773  IssmDouble LprimeFSSSA[4][numdof2dm];
5774  IssmDouble DLFSSSA[4][4]={0.0};
5775  IssmDouble Ke_drag[numdof2dm][numdofs]={0.0};
5776  IssmDouble Ke_drag2[numdof2d][numdof2dm]={0.0};
5777  IssmDouble *xyz_list = NULL;
5778  IssmDouble *xyz_list_tria = NULL;
5779 
5780  /*If on water or not FS, skip stiffness: */
5781  element->GetInput2Value(&approximation,ApproximationEnum);
5782  if(element->IsFloating() || !element->IsOnBase()) return NULL;
5783 
5784  int vnumnodes = element->NumberofNodesVelocity();
5785  int pnumnodes = element->NumberofNodesPressure();
5786  int numnodes = 2*vnumnodes-1+pnumnodes;
5787 
5788  /*Prepare node list*/
5789  int* cs_list = xNew<int>(2*vnumnodes-1+pnumnodes);
5790  Node **node_list = xNew<Node*>(2*vnumnodes-1+pnumnodes);
5791  for(i=0;i<vnumnodes-1;i++){
5792  node_list[i] = element->GetNode(i);
5793  cs_list[i] = XYEnum;
5794  }
5795  for(i=0;i<vnumnodes;i++){
5796  node_list[i+vnumnodes-1] = element->GetNode(i);
5797  cs_list[i+vnumnodes-1] = XYZEnum;
5798  }
5799  for(i=0;i<pnumnodes;i++){
5800  node_list[2*vnumnodes-1+i] = element->GetNode(vnumnodes+i);
5801  cs_list[2*vnumnodes-1+i] = PressureEnum;
5802  }
5803 
5804  ElementMatrix* Ke1=element->NewElementMatrixCoupling(6,SSAApproximationEnum);
5805  ElementMatrix* Ke2=element->NewElementMatrix(FSvelocityEnum);
5806  ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
5807  delete Ke1; delete Ke2;
5808 
5809  /*Retrieve all inputs and parameters*/
5810  element->GetVerticesCoordinates(&xyz_list);
5811  element->GetVerticesCoordinatesBase(&xyz_list_tria);
5812  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
5813  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
5814  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
5815  Input2* vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
5816 
5817  /*build friction object, used later on: */
5818  Friction* friction=new Friction(element,3);
5819 
5820  /* Start looping on the number of gaussian points: */
5821  Gauss* gauss=element->NewGaussBase(2);
5822  for(int ig=gauss->begin();ig<gauss->end();ig++){
5823 
5824  gauss->GaussPoint(ig);
5825 
5826  element->JacobianDeterminantBase(&Jdet2d,xyz_list_tria,gauss);
5827  this->GetLSSAFS(&LSSAFS[0][0], element,gauss);
5828  this->GetLprimeSSAFS(&LprimeSSAFS[0][0], element,xyz_list, gauss);
5829  this->GetLFSSSA(&LFSSSA[0][0],element, gauss);
5830  this->GetLprimeFSSSA(&LprimeFSSSA[0][0], element,xyz_list, gauss);
5831 
5832  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
5833 
5834  element->NormalBase(&bed_normal[0],xyz_list_tria);
5835  friction->GetAlpha2(&alpha2_gauss,gauss);
5836 
5837  DLSSAFS[0][0]=alpha2_gauss*gauss->weight*Jdet2d;
5838  DLSSAFS[1][1]=alpha2_gauss*gauss->weight*Jdet2d;
5839  DLSSAFS[2][2]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[0]*bed_normal[2];
5840  DLSSAFS[3][3]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[1]*bed_normal[2];
5841  DLSSAFS[4][4]=-2*viscosity*gauss->weight*Jdet2d*bed_normal[0];
5842  DLSSAFS[5][5]=-2*viscosity*gauss->weight*Jdet2d*bed_normal[1];
5843  DLSSAFS[6][6]=FSreconditioning*gauss->weight*Jdet2d*bed_normal[0];
5844  DLSSAFS[7][7]=FSreconditioning*gauss->weight*Jdet2d*bed_normal[1];
5845 
5846  DLFSSSA[0][0]=alpha2_gauss*gauss->weight*Jdet2d;
5847  DLFSSSA[1][1]=alpha2_gauss*gauss->weight*Jdet2d;
5848  DLFSSSA[2][2]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[0]*bed_normal[2];
5849  DLFSSSA[3][3]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[1]*bed_normal[2];
5850 
5851  TripleMultiply( &LSSAFS[0][0],8,numdof2dm,1,
5852  &DLSSAFS[0][0],8,8,0,
5853  &LprimeSSAFS[0][0],8,numdofs,0,
5854  &Ke_drag[0][0],1);
5855 
5856  TripleMultiply( &LFSSSA[0][0],4,numdof2d,1,
5857  &DLFSSSA[0][0],4,4,0,
5858  &LprimeFSSSA[0][0],4,numdof2dm,0,
5859  &Ke_drag2[0][0],1);
5860  }
5861 
5862  for(i=0;i<numdof2dm;i++) for(j=0;j<numdofs;j++) Ke->values[i*numdoftot+j+numdofm]+=Ke_drag[i][j];
5863  for(i=0;i<numdof2d;i++) for(j=0;j<numdof2dm;j++) Ke->values[(i+numdofm)*numdoftot+j]+=Ke_drag2[i][j];
5864 
5865  /*Transform Coordinate System*/
5866  element->TransformStiffnessMatrixCoord(Ke,node_list,numnodes,cs_list);
5867 
5868  /*Clean up and return*/
5869  xDelete<int>(cs_list);
5870  xDelete<Node*>(node_list);
5871  xDelete<IssmDouble>(xyz_list);
5872  xDelete<IssmDouble>(xyz_list_tria);
5873  delete gauss;
5874  delete friction;
5875  return Ke;
5876 }/*}}}*/

◆ CreateKMatrixCouplingSSAFSViscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingSSAFSViscous ( Element *  element)

Definition at line 5877 of file StressbalanceAnalysis.cpp.

5877  {/*{{{*/
5878 
5879  /* Check if ice in element */
5880  if(!element->IsIceInElement()) return NULL;
5881 
5882  /*Constants*/
5883  const int numdofm = 2 *3;
5884  const int numdofs = 4 *6+ 3;
5885  const int numdoftotal = 2 *numdofm+numdofs;
5886 
5887  /*Intermediaries */
5888  int i,j;
5889  int dim=3;
5890  IssmDouble Jdet,viscosity,FSreconditioning,D_scalar;
5891  IssmDouble B[4][numdofs];
5892  IssmDouble Bprime[4][numdofm];
5893  IssmDouble B2[3][numdofm];
5894  IssmDouble Bprime2[3][numdofs];
5895  IssmDouble D[4][4]={0.0}; // material matrix, simple scalar matrix.
5896  IssmDouble D2[3][3]={0.0}; // material matrix, simple scalar matrix.
5897  IssmDouble Ke_gg[numdofs][numdofm]={0.0}; //local element stiffness matrix
5898  IssmDouble Ke_gg2[numdofm][numdofs]={0.0}; //local element stiffness matrix
5899  IssmDouble *xyz_list = NULL;
5900 
5901  /*Find penta on bed as FS must be coupled to the dofs on the bed: */
5902  Element* pentabase=element->GetBasalElement();
5903  Element* basaltria=pentabase->SpawnBasalElement();
5904 
5905  int vnumnodes = element->NumberofNodesVelocity();
5906  int pnumnodes = element->NumberofNodesPressure();
5907  int numnodes = 2*vnumnodes-1+pnumnodes;
5908 
5909  /*Prepare node list*/
5910  int* cs_list = xNew<int>(2*vnumnodes-1+pnumnodes);
5911  Node **node_list = xNew<Node*>(2*vnumnodes-1+pnumnodes);
5912  for(i=0;i<vnumnodes-1;i++){
5913  node_list[i] = pentabase->GetNode(i);
5914  cs_list[i] = XYEnum;
5915  }
5916  for(i=0;i<vnumnodes;i++){
5917  node_list[i+vnumnodes-1] = element->GetNode(i);
5918  cs_list[i+vnumnodes-1] = XYZEnum;
5919  }
5920  for(i=0;i<pnumnodes;i++){
5921  node_list[2*vnumnodes-1+i] = element->GetNode(vnumnodes+i);
5922  cs_list[2*vnumnodes-1+i] = PressureEnum;
5923  }
5924 
5925  /*Initialize Element matrix and return if necessary*/
5926  ElementMatrix* Ke1=pentabase->NewElementMatrixCoupling(6,SSAApproximationEnum);
5927  ElementMatrix* Ke2=element->NewElementMatrix(FSvelocityEnum);
5928  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
5929  delete Ke1; delete Ke2;
5930 
5931  /* Get node coordinates and dof list: */
5932  element->GetVerticesCoordinates(&xyz_list);
5933  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
5934  Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
5935  Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
5936  Input2* vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
5937 
5938  /* Start looping on the number of gaussian points: */
5939  Gauss* gauss=element->NewGauss(5);
5940  Gauss* gauss_tria=new GaussTria();
5941  for(int ig=gauss->begin();ig<gauss->end();ig++){
5942 
5943  gauss->GaussPoint(ig);
5944  gauss->SynchronizeGaussBase(gauss_tria);
5945 
5946  element->JacobianDeterminant(&Jdet, xyz_list,gauss);
5947  this->GetBSSAFS(&B[0][0],element,xyz_list, gauss);
5948  this->GetBprimeSSAFSTria(&Bprime[0][0], basaltria,xyz_list, gauss_tria);
5949  this->GetBSSAFSTria(&B2[0][0], basaltria,xyz_list, gauss_tria);
5950  this->GetBprimeSSAFS(&Bprime2[0][0], element,xyz_list, gauss);
5951 
5952  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
5953 
5954  D_scalar=2*viscosity*gauss->weight*Jdet;
5955  for (i=0;i<3;i++) D[i][i]=D_scalar;
5956  D[3][3]=-gauss->weight*Jdet*FSreconditioning;
5957  for (i=0;i<3;i++) D2[i][i]=D_scalar;
5958 
5959  TripleMultiply( &B[0][0],4,numdofs,1,
5960  &D[0][0],4,4,0,
5961  &Bprime[0][0],4,numdofm,0,
5962  &Ke_gg[0][0],1);
5963 
5964  TripleMultiply( &B2[0][0],3,numdofm,1,
5965  &D2[0][0],3,3,0,
5966  &Bprime2[0][0],3,numdofs,0,
5967  &Ke_gg2[0][0],1);
5968 
5969  }
5970  for(i=0;i<numdofs;i++) for(j=0;j<numdofm;j++) Ke->values[(i+2*numdofm)*numdoftotal+j]+=Ke_gg[i][j];
5971  for(i=0;i<numdofm;i++) for(j=0;j<numdofs;j++) Ke->values[i*numdoftotal+(j+2*numdofm)]+=Ke_gg2[i][j];
5972 
5973  /*Transform Coordinate System*/
5974  element->TransformStiffnessMatrixCoord(Ke,node_list,numnodes,cs_list);
5975 
5976  /*Clean-up and return*/
5977  xDelete<int>(cs_list);
5978  xDelete<Node*>(node_list);
5979  xDelete<IssmDouble>(xyz_list);
5980  delete basaltria->material; delete basaltria;
5981  delete gauss;
5982  delete gauss_tria;
5983  return Ke;
5984 
5985 }/*}}}*/

◆ CreateKMatrixCouplingSSAHO()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingSSAHO ( Element *  element)

Definition at line 5986 of file StressbalanceAnalysis.cpp.

5986  {/*{{{*/
5987 
5988  /*compute all stiffness matrices for this element*/
5989  ElementMatrix* Ke1=CreateKMatrixCouplingSSAHOViscous(element);
5990  ElementMatrix* Ke2=CreateKMatrixCouplingSSAHOFriction(element);
5991  ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
5992 
5993  /*clean-up and return*/
5994  delete Ke1;
5995  delete Ke2;
5996  return Ke;
5997 }/*}}}*/

◆ CreateKMatrixCouplingSSAHOFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingSSAHOFriction ( Element *  element)

Definition at line 5998 of file StressbalanceAnalysis.cpp.

5998  {/*{{{*/
5999 
6000  /* Check if ice in element */
6001  if(!element->IsIceInElement()) return NULL;
6002 
6003  if(element->IsFloating() || !element->IsOnBase()) return NULL;
6004 
6005  /*Constants*/
6006  int numnodes = element->GetNumberOfNodes();
6007  int numdof = 2*numnodes;
6008  int numdoftotal = 4*numnodes;
6009 
6010  /*Intermediaries */
6011  int i,j;
6012  IssmDouble Jdet2d,alpha2;
6013  IssmDouble *xyz_list_tria = NULL;
6014  IssmDouble* L = xNewZeroInit<IssmDouble>(2*numdof);
6015  IssmDouble DL[2][2] = {{ 0,0 },{0,0}}; //for basal drag
6016  IssmDouble DL_scalar;
6017  IssmDouble* Ke_gg = xNewZeroInit<IssmDouble>(numdof*numdof);
6018  Node **node_list = xNew<Node*>(2*numnodes);
6019  int* cs_list = xNew<int>(2*numnodes);
6020 
6021  /*Initialize Element matrix and return if necessary*/
6022  ElementMatrix* Ke1=element->NewElementMatrix(SSAApproximationEnum);
6023  ElementMatrix* Ke2=element->NewElementMatrix(HOApproximationEnum);
6024  ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
6025  delete Ke1; delete Ke2;
6026 
6027  /*Prepare node list*/
6028  for(i=0;i<numnodes;i++){
6029  node_list[i+0*numnodes] = element->GetNode(i);
6030  node_list[i+1*numnodes] = element->GetNode(i);
6031  cs_list[i+0*numnodes] = XYEnum;
6032  cs_list[i+1*numnodes] = XYEnum;
6033  }
6034 
6035  /*retrieve inputs :*/
6036  element->GetVerticesCoordinatesBase(&xyz_list_tria);
6037 
6038  /*build friction object, used later on: */
6039  Friction* friction=new Friction(element,2);
6040 
6041  /* Start looping on the number of gaussian points: */
6042  Gauss* gauss=element->NewGaussBase(2);
6043  for(int ig=gauss->begin();ig<gauss->end();ig++){
6044 
6045  gauss->GaussPoint(ig);
6046 
6047  /*Friction: */
6048  friction->GetAlpha2(&alpha2,gauss);
6049  element->JacobianDeterminantBase(&Jdet2d, xyz_list_tria,gauss);
6050  this->GetBHOFriction(L,element,3,xyz_list_tria,gauss);
6051 
6052  DL_scalar=alpha2*gauss->weight*Jdet2d;
6053  for (i=0;i<2;i++) DL[i][i]=DL_scalar;
6054 
6055  /* Do the triple producte tL*D*L: */
6056  TripleMultiply( L,2,numdof,1,
6057  &DL[0][0],2,2,0,
6058  L,2,numdof,0,
6059  Ke_gg,1);
6060  }
6061 
6062  for(i=0;i<numdof;i++) for(j=0;j<numdof;j++) Ke->values[i*numdoftotal+(numdof+j)]+=Ke_gg[i*numdof+j];
6063  for(i=0;i<numdof;i++) for(j=0;j<numdof;j++) Ke->values[(i+numdof)*numdoftotal+j]+=Ke_gg[i*numdof+j];
6064 
6065  /*Transform Coordinate System*/
6066  element->TransformStiffnessMatrixCoord(Ke,node_list,2*numnodes,cs_list);
6067 
6068  /*Clean up and return*/
6069  delete gauss;
6070  delete friction;
6071  xDelete<int>(cs_list);
6072  xDelete<Node*>(node_list);
6073  xDelete<IssmDouble>(xyz_list_tria);
6074  xDelete<IssmDouble>(Ke_gg);
6075  xDelete<IssmDouble>(L);
6076  return Ke;
6077 }/*}}}*/

◆ CreateKMatrixCouplingSSAHOViscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixCouplingSSAHOViscous ( Element *  element)

Definition at line 6078 of file StressbalanceAnalysis.cpp.

6078  {/*{{{*/
6079 
6080  /* Check if ice in element */
6081  if(!element->IsIceInElement()) return NULL;
6082 
6083  /*Constants*/
6084  int numnodes = element->GetNumberOfNodes();
6085  int numdofm = 1 *numnodes; //*2/2
6086  int numdofp = 2 *numnodes;
6087  int numdoftotal = 2 *2 *numnodes;//2 dof per nodes and 2 sets of nodes for HO and SSA
6088 
6089  /*Intermediaries */
6090  int i,j;
6091  IssmDouble Jdet,viscosity;
6092  IssmDouble *xyz_list = NULL;
6093  IssmDouble* B = xNew<IssmDouble>(3*numdofp);
6094  IssmDouble* Bprime = xNew<IssmDouble>(3*numdofm);
6095  IssmDouble D[3][3]={0.0}; // material matrix, simple scalar matrix.
6096  IssmDouble D_scalar;
6097  IssmDouble* Ke_gg = xNewZeroInit<IssmDouble>(numdofp*numdofm);
6098  Node **node_list = xNew<Node*>(2*numnodes);
6099  int* cs_list= xNew<int>(2*numnodes);
6100 
6101  /*Find penta on bed as HO must be coupled to the dofs on the bed: */
6102  Element* pentabase=element->GetBasalElement();
6103  Element* basaltria=pentabase->SpawnBasalElement();
6104 
6105  /*prepare node list*/
6106  for(i=0;i<numnodes;i++){
6107  node_list[i+0*numnodes] = pentabase->GetNode(i);
6108  node_list[i+1*numnodes] = element ->GetNode(i);
6109  cs_list[i+0*numnodes] = XYEnum;
6110  cs_list[i+1*numnodes] = XYEnum;
6111  }
6112 
6113  /*Initialize Element matrix*/
6114  ElementMatrix* Ke1= pentabase->NewElementMatrix(SSAApproximationEnum);
6115  ElementMatrix* Ke2= element ->NewElementMatrix(HOApproximationEnum);
6116  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
6117  delete Ke1; delete Ke2;
6118 
6119  /* Get node coordinates and dof list: */
6120  element->GetVerticesCoordinates(&xyz_list);
6121  Input2* vx_input =element->GetInput2(VxEnum); _assert_(vx_input);
6122  Input2* vy_input =element->GetInput2(VyEnum); _assert_(vy_input);
6123 
6124  /* Start looping on the number of gaussian points: */
6125  Gauss* gauss=element->NewGauss(5);
6126  Gauss* gauss_tria=new GaussTria();
6127  for(int ig=gauss->begin();ig<gauss->end();ig++){
6128 
6129  gauss->GaussPoint(ig);
6130  gauss->SynchronizeGaussBase(gauss_tria);
6131 
6132  element->JacobianDeterminant(&Jdet, xyz_list,gauss);
6133  this->GetBSSAHO(B, element,xyz_list, gauss);
6134  this->GetBSSAprime(Bprime,basaltria,2,xyz_list, gauss_tria);
6135  element->material->ViscosityHO(&viscosity,3,xyz_list,gauss,vx_input,vy_input);
6136 
6137  D_scalar=2*viscosity*gauss->weight*Jdet;
6138  for (i=0;i<3;i++) D[i][i]=D_scalar;
6139 
6140  TripleMultiply( B,3,numdofp,1,
6141  &D[0][0],3,3,0,
6142  Bprime,3,numdofm,0,
6143  Ke_gg,1);
6144  }
6145  for(i=0;i<numdofp;i++) for(j=0;j<numdofm;j++) Ke->values[(i+2*numdofm)*numdoftotal+j]+=Ke_gg[i*numdofm+j];
6146  for(i=0;i<numdofm;i++) for(j=0;j<numdofp;j++) Ke->values[i*numdoftotal+(j+2*numdofm)]+=Ke_gg[j*numdofm+i];
6147 
6148  /*Transform Coordinate System*/
6149  element->TransformStiffnessMatrixCoord(Ke,node_list,2*numnodes,cs_list);
6150 
6151  /*Clean-up and return*/
6152  basaltria->DeleteMaterials(); delete basaltria;
6153 
6154  delete gauss;
6155  delete gauss_tria;
6156  xDelete<IssmDouble>(B);
6157  xDelete<IssmDouble>(Bprime);
6158  xDelete<IssmDouble>(Ke_gg);
6159  xDelete<IssmDouble>(xyz_list);
6160  xDelete<Node*>(node_list);
6161  xDelete<int>(cs_list);
6162  return Ke;
6163 
6164 }/*}}}*/

◆ CreateKMatrixHOFS()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixHOFS ( Element *  element)

Definition at line 6165 of file StressbalanceAnalysis.cpp.

6165  {/*{{{*/
6166 
6167  /*compute all stiffness matrices for this element*/
6168  ElementMatrix* Ke1=CreateKMatrixFS(element);
6169  int indices[3]={18,19,20};
6170  Ke1->StaticCondensation(3,&indices[0]);
6171  int init = element->FiniteElement();
6172  element->SetTemporaryElementType(P1Enum); // P1 needed for HO
6173  ElementMatrix* Ke2=CreateKMatrixHO(element);
6174  element->SetTemporaryElementType(init); // P1 needed for HO
6175  ElementMatrix* Ke3=CreateKMatrixCouplingHOFS(element);
6176  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3);
6177 
6178  /*clean-up and return*/
6179  delete Ke1;
6180  delete Ke2;
6181  delete Ke3;
6182  return Ke;
6183 }/*}}}*/

◆ CreateKMatrixSSAFS()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSAFS ( Element *  element)

Definition at line 6184 of file StressbalanceAnalysis.cpp.

6184  {/*{{{*/
6185 
6186  /*compute all stiffness matrices for this element*/
6187  ElementMatrix* Ke1=CreateKMatrixFS(element);
6188  int indices[3]={18,19,20};
6189  Ke1->StaticCondensation(3,&indices[0]);
6190  int init = element->FiniteElement();
6191  element->SetTemporaryElementType(P1Enum);
6192  ElementMatrix* Ke2=CreateKMatrixSSA3d(element);
6193  element->SetTemporaryElementType(init);
6194  ElementMatrix* Ke3=CreateKMatrixCouplingSSAFS(element);
6195  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3);
6196 
6197  /*clean-up and return*/
6198  delete Ke1;
6199  delete Ke2;
6200  delete Ke3;
6201  return Ke;
6202 }/*}}}*/

◆ CreateKMatrixSSAHO()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSAHO ( Element *  element)

Definition at line 6203 of file StressbalanceAnalysis.cpp.

6203  {/*{{{*/
6204 
6205  /*compute all stiffness matrices for this element*/
6206  ElementMatrix* Ke1=CreateKMatrixSSA3d(element);
6207  ElementMatrix* Ke2=CreateKMatrixHO(element);
6208  ElementMatrix* Ke3=CreateKMatrixCouplingSSAHO(element);
6209  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3);
6210 
6211  /*clean-up and return*/
6212  delete Ke1;
6213  delete Ke2;
6214  delete Ke3;
6215  return Ke;
6216 }/*}}}*/

◆ CreateKMatrixSSA3d()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSA3d ( Element *  element)

Definition at line 6217 of file StressbalanceAnalysis.cpp.

6217  {/*{{{*/
6218 
6219  /*compute all stiffness matrices for this element*/
6220  ElementMatrix* Ke1=CreateKMatrixSSA3dViscous(element);
6221  ElementMatrix* Ke2=CreateKMatrixSSA3dFriction(element);
6222  ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
6223 
6224  /*clean-up and return*/
6225  delete Ke1;
6226  delete Ke2;
6227  return Ke;
6228 }/*}}}*/

◆ CreateKMatrixSSA3dFriction()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSA3dFriction ( Element *  element)

Definition at line 6229 of file StressbalanceAnalysis.cpp.

6229  {/*{{{*/
6230 
6231  /* Check if ice in element */
6232  if(!element->IsIceInElement()) return NULL;
6233 
6234  /*Initialize Element matrix and return if necessary*/
6235  if(element->IsFloating() || !element->IsOnBase()) return NULL;
6236 
6237  /*Build a tria element using the 3 nodes of the base of the penta. Then use
6238  * the tria functionality to build a friction stiffness matrix on these 3
6239  * nodes: */
6240  Element* basalelement = element->SpawnBasalElement();
6241  ElementMatrix* Ke=CreateKMatrixSSAFriction(basalelement);
6242  basalelement->DeleteMaterials(); delete basalelement;
6243 
6244  /*clean-up and return*/
6245  return Ke;
6246 }/*}}}*/

◆ CreateKMatrixSSA3dViscous()

ElementMatrix * StressbalanceAnalysis::CreateKMatrixSSA3dViscous ( Element *  element)

Definition at line 6247 of file StressbalanceAnalysis.cpp.

6247  {/*{{{*/
6248 
6249  /* Check if ice in element */
6250  if(!element->IsIceInElement()) return NULL;
6251 
6252  /*Constants*/
6253  const int numdof2d=2*3;
6254 
6255  /*Intermediaries */
6256  int i,j,approximation;
6257  int dim=3;
6258  IssmDouble Jdet,viscosity;
6259  IssmDouble epsilon[5],oldepsilon[5]; /* epsilon=[exx,eyy,exy,exz,eyz];*/
6260  IssmDouble epsilons[6]; //6 for FS
6261  IssmDouble B[3][numdof2d];
6262  IssmDouble Bprime[3][numdof2d];
6263  IssmDouble D[3][3]= {0.0}; // material matrix, simple scalar matrix.
6264  IssmDouble D_scalar;
6265  IssmDouble Ke_gg[numdof2d][numdof2d]={0.0};
6266  IssmDouble *xyz_list = NULL;
6267 
6268  /*Find penta on bed as this is a SSA elements: */
6269  Element* pentabase=element->GetBasalElement();
6270  Element* basaltria=pentabase->SpawnBasalElement();
6271 
6272  /*Initialize Element matrix*/
6273  ElementMatrix* Ke=basaltria->NewElementMatrix(SSAApproximationEnum);
6274  element->GetInput2Value(&approximation,ApproximationEnum);
6275 
6276  /*Retrieve all inputs and parameters*/
6277  element->GetVerticesCoordinates(&xyz_list);
6278  Input2* vx_input =element->GetInput2(VxEnum); _assert_(vx_input);
6279  Input2* vy_input =element->GetInput2(VyEnum); _assert_(vy_input);
6280  Input2* vz_input =element->GetInput2(VzEnum); _assert_(vz_input);
6281 
6282  /* Start looping on the number of gaussian points: */
6283  Gauss* gauss=element->NewGauss(5);
6284  Gauss* gauss_tria=new GaussTria();
6285  for(int ig=gauss->begin();ig<gauss->end();ig++){
6286 
6287  gauss->GaussPoint(ig);
6288  gauss->SynchronizeGaussBase(gauss_tria);
6289 
6290  element->JacobianDeterminant(&Jdet, xyz_list,gauss);
6291  this->GetBSSA(&B[0][0],basaltria,2,xyz_list, gauss_tria);
6292  this->GetBSSAprime(&Bprime[0][0],basaltria,2,xyz_list, gauss_tria);
6293 
6294  if(approximation==SSAHOApproximationEnum){
6295  element->material->ViscosityHO(&viscosity,dim,xyz_list,gauss,vx_input,vy_input);
6296  }
6297  else if (approximation==SSAFSApproximationEnum){
6298  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
6299  }
6300  else _error_("approximation " << approximation << " (" << EnumToStringx(approximation) << ") not supported yet");
6301 
6302  D_scalar=2*viscosity*gauss->weight*Jdet;
6303  for (i=0;i<3;i++) D[i][i]=D_scalar;
6304 
6305  TripleMultiply( &B[0][0],3,numdof2d,1,
6306  &D[0][0],3,3,0,
6307  &Bprime[0][0],3,numdof2d,0,
6308  &Ke_gg[0][0],1);
6309 
6310  }
6311  for(i=0;i<numdof2d;i++) for(j=0;j<numdof2d;j++) Ke->values[i*numdof2d+j]+=Ke_gg[i][j];
6312 
6313  /*Transform Coordinate System*/
6314  basaltria->TransformStiffnessMatrixCoord(Ke,XYEnum);
6315 
6316  /*Clean up and return*/
6317  xDelete<IssmDouble>(xyz_list);
6318  delete basaltria->material;
6319  delete basaltria;
6320  delete gauss_tria;
6321  delete gauss;
6322  return Ke;
6323 
6324 }/*}}}*/

◆ CreatePVectorSSAFS()

ElementVector * StressbalanceAnalysis::CreatePVectorSSAFS ( Element *  element)

Definition at line 6683 of file StressbalanceAnalysis.cpp.

6683  {/*{{{*/
6684 
6685  /*compute all load vectors for this element*/
6686  int init = element->FiniteElement();
6687  element->SetTemporaryElementType(P1Enum); // P1 needed for HO
6688  ElementVector* pe1=CreatePVectorSSA(element);
6689  element->SetTemporaryElementType(init); // P1 needed for HO
6690  ElementVector* pe2=CreatePVectorFS(element);
6691  int indices[3]={18,19,20};
6692  element->SetTemporaryElementType(MINIcondensedEnum); // P1 needed for HO
6693  ElementMatrix* Ke = CreateKMatrixFS(element);
6694  element->SetTemporaryElementType(init); // P1 needed for HO
6695  pe2->StaticCondensation(Ke,3,&indices[0]);
6696  delete Ke;
6697  ElementVector* pe3=CreatePVectorCouplingSSAFS(element);
6698  ElementVector* pe =new ElementVector(pe1,pe2,pe3);
6699 
6700  /*clean-up and return*/
6701  delete pe1;
6702  delete pe2;
6703  delete pe3;
6704  return pe;
6705 }/*}}}*/

◆ CreatePVectorSSAHO()

ElementVector * StressbalanceAnalysis::CreatePVectorSSAHO ( Element *  element)

Definition at line 6706 of file StressbalanceAnalysis.cpp.

6706  {/*{{{*/
6707 
6708  /*compute all load vectors for this element*/
6709  ElementVector* pe1=CreatePVectorSSA(element);
6710  ElementVector* pe2=CreatePVectorHO(element);
6711  ElementVector* pe =new ElementVector(pe1,pe2);
6712 
6713  /*clean-up and return*/
6714  delete pe1;
6715  delete pe2;
6716  return pe;
6717 }/*}}}*/

◆ CreatePVectorCouplingSSAFS()

ElementVector * StressbalanceAnalysis::CreatePVectorCouplingSSAFS ( Element *  element)

Definition at line 6495 of file StressbalanceAnalysis.cpp.

6495  {/*{{{*/
6496 
6497  /*compute all load vectors for this element*/
6498  ElementVector* pe1=CreatePVectorCouplingSSAFSViscous(element);
6499  ElementVector* pe2=CreatePVectorCouplingSSAFSFriction(element);
6500  ElementVector* pe =new ElementVector(pe1,pe2);
6501 
6502  /*clean-up and return*/
6503  delete pe1;
6504  delete pe2;
6505  return pe;
6506 }/*}}}*/

◆ CreatePVectorCouplingSSAFSFriction()

ElementVector * StressbalanceAnalysis::CreatePVectorCouplingSSAFSFriction ( Element *  element)

Definition at line 6507 of file StressbalanceAnalysis.cpp.

6507  {/*{{{*/
6508 
6509  /* Check if ice in element */
6510  if(!element->IsIceInElement()) return NULL;
6511 
6512  /*Intermediaries*/
6513  int i,j,approximation;
6514  int dim=3;
6515  IssmDouble Jdet,Jdet2d,FSreconditioning;
6516  IssmDouble bed_normal[3];
6517  IssmDouble viscosity, w, alpha2_gauss;
6518  IssmDouble dw[3];
6519  IssmDouble basis[6]; //for the six nodes of the penta
6520  IssmDouble *xyz_list_tria = NULL;
6521  IssmDouble *xyz_list = NULL;
6522 
6523  /*Initialize Element vector and return if necessary*/
6524  if(!element->IsOnBase() || element->IsFloating()) return NULL;
6525  element->GetInput2Value(&approximation,ApproximationEnum);
6526  if(approximation!=SSAFSApproximationEnum) return NULL;
6527  int vnumnodes = element->NumberofNodesVelocity();
6528  int pnumnodes = element->NumberofNodesPressure();
6529 
6530  /*Prepare coordinate system list*/
6531  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
6532  Node **node_list = xNew<Node*>(vnumnodes+pnumnodes);
6533  for(i=0;i<vnumnodes;i++){
6534  cs_list[i] = XYZEnum;
6535  node_list[i] = element->GetNode(i);
6536  }
6537  for(i=0;i<pnumnodes;i++){
6538  cs_list[vnumnodes+i] = PressureEnum;
6539  node_list[vnumnodes+i] = element->GetNode(vnumnodes+i);
6540  }
6541  ElementVector* pe=element->NewElementVector(FSvelocityEnum);
6542 
6543  /*Retrieve all inputs and parameters*/
6544  element->GetVerticesCoordinates(&xyz_list);
6545  element->GetVerticesCoordinatesBase(&xyz_list_tria);
6546  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
6547  Input2* vx_input= element->GetInput2(VxEnum); _assert_(vx_input);
6548  Input2* vy_input= element->GetInput2(VyEnum); _assert_(vy_input);
6549  Input2* vz_input= element->GetInput2(VzEnum); _assert_(vz_input);
6550  Input2* vzSSA_input=element->GetInput2(VzSSAEnum); _assert_(vzSSA_input);
6551 
6552  /*build friction object, used later on: */
6553  Friction* friction=new Friction(element,3);
6554 
6555  /* Start looping on the number of gauss 2d (nodes on the bedrock) */
6556  Gauss* gauss=element->NewGaussBase(2);
6557  for(int ig=gauss->begin();ig<gauss->end();ig++){
6558 
6559  gauss->GaussPoint(ig);
6560 
6561  element->JacobianDeterminantBase(&Jdet2d,xyz_list_tria,gauss);
6562  element->NodalFunctionsP1(basis, gauss);
6563 
6564  vzSSA_input->GetInputValue(&w, gauss);
6565  vzSSA_input->GetInputDerivativeValue(&dw[0],xyz_list,gauss);
6566 
6567  element->NormalBase(&bed_normal[0],xyz_list_tria);
6568  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
6569  friction->GetAlpha2(&alpha2_gauss,gauss);
6570 
6571  for(i=0;i<3;i++){
6572  pe->values[i*3+0]+=Jdet2d*gauss->weight*(alpha2_gauss*w*bed_normal[0]*bed_normal[2]+2*viscosity*dw[2]*bed_normal[0])*basis[i];
6573  pe->values[i*3+1]+=Jdet2d*gauss->weight*(alpha2_gauss*w*bed_normal[1]*bed_normal[2]+2*viscosity*dw[2]*bed_normal[1])*basis[i];
6574  pe->values[i*3+2]+=Jdet2d*gauss->weight*2*viscosity*(dw[0]*bed_normal[0]+dw[1]*bed_normal[1]+dw[2]*bed_normal[2])*basis[i];
6575  }
6576  }
6577 
6578  /*Transform coordinate system*/
6579  element->TransformLoadVectorCoord(pe,node_list,vnumnodes+pnumnodes,cs_list);
6580 
6581  /*Clean up and return*/
6582  xDelete<int>(cs_list);
6583  xDelete<IssmDouble>(xyz_list);
6584  xDelete<IssmDouble>(xyz_list_tria);
6585  xDelete<Node*>(node_list);
6586  delete gauss;
6587  delete friction;
6588  return pe;
6589 }/*}}}*/

◆ CreatePVectorCouplingSSAFSViscous()

ElementVector * StressbalanceAnalysis::CreatePVectorCouplingSSAFSViscous ( Element *  element)

Definition at line 6590 of file StressbalanceAnalysis.cpp.

6590  {/*{{{*/
6591 
6592  /* Check if ice in element */
6593  if(!element->IsIceInElement()) return NULL;
6594 
6595  /*Intermediaries */
6596  int i,approximation;
6597  IssmDouble viscosity,Jdet,FSreconditioning;
6598  IssmDouble dw[3];
6599  IssmDouble *xyz_list = NULL;
6600  IssmDouble basis[6]; //for the six nodes of the penta
6601  IssmDouble dbasis[3][6]; //for the six nodes of the penta
6602 
6603  /*Initialize Element vector and return if necessary*/
6604  element->GetInput2Value(&approximation,ApproximationEnum);
6605  if(approximation!=SSAFSApproximationEnum) return NULL;
6606  int vnumnodes = element->NumberofNodesVelocity();
6607  int pnumnodes = element->NumberofNodesPressure();
6608 
6609  /*Prepare coordinate system list*/
6610  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
6611  Node **node_list = xNew<Node*>(vnumnodes+pnumnodes);
6612  for(i=0;i<vnumnodes;i++){
6613  cs_list[i] = XYZEnum;
6614  node_list[i] = element->GetNode(i);
6615  }
6616  for(i=0;i<pnumnodes;i++){
6617  cs_list[vnumnodes+i] = PressureEnum;
6618  node_list[vnumnodes+i] = element->GetNode(vnumnodes+i);
6619  }
6620  ElementVector* pe=element->NewElementVector(FSvelocityEnum);
6621 
6622  /*Retrieve all inputs and parameters*/
6623  element->GetVerticesCoordinates(&xyz_list);
6624  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
6625  Input2* vx_input =element->GetInput2(VxEnum); _assert_(vx_input);
6626  Input2* vy_input =element->GetInput2(VyEnum); _assert_(vy_input);
6627  Input2* vz_input =element->GetInput2(VzEnum); _assert_(vz_input);
6628  Input2* vzSSA_input=element->GetInput2(VzSSAEnum); _assert_(vzSSA_input);
6629 
6630  /* Start looping on the number of gaussian points: */
6631  Gauss* gauss=element->NewGauss(5);
6632  for(int ig=gauss->begin();ig<gauss->end();ig++){
6633 
6634  gauss->GaussPoint(ig);
6635  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
6636  element->NodalFunctionsP1(&basis[0], gauss);
6637  element->NodalFunctionsP1Derivatives(&dbasis[0][0],xyz_list, gauss);
6638 
6639  vzSSA_input->GetInputDerivativeValue(&dw[0],xyz_list,gauss);
6640  element->material->ViscosityFS(&viscosity,3,xyz_list,gauss,vx_input,vy_input,vz_input);
6641 
6642  for(i=0;i<6;i++){
6643  pe->values[i*3+0]+=-Jdet*gauss->weight*viscosity*dw[0]*dbasis[2][i];
6644  pe->values[i*3+1]+=-Jdet*gauss->weight*viscosity*dw[1]*dbasis[2][i];
6645  pe->values[i*3+2]+=-Jdet*gauss->weight*viscosity*(dw[0]*dbasis[0][i]+dw[1]*dbasis[1][i]+2*dw[2]*dbasis[2][i]);
6646  pe->values[3*vnumnodes+i]+=Jdet*gauss->weight*FSreconditioning*dw[2]*basis[i];
6647  }
6648  }
6649 
6650  /*Transform coordinate system*/
6651  element->TransformLoadVectorCoord(pe,node_list,vnumnodes+pnumnodes,cs_list);
6652 
6653  /*Clean up and return*/
6654  xDelete<int>(cs_list);
6655  xDelete<Node*>(node_list);
6656  xDelete<IssmDouble>(xyz_list);
6657  delete gauss;
6658  return pe;
6659 }/*}}}*/

◆ CreatePVectorHOFS()

ElementVector * StressbalanceAnalysis::CreatePVectorHOFS ( Element *  element)

Definition at line 6660 of file StressbalanceAnalysis.cpp.

6660  {/*{{{*/
6661 
6662  /*compute all load vectors for this element*/
6663  int init = element->FiniteElement();
6664  element->SetTemporaryElementType(P1Enum);
6665  ElementVector* pe1=CreatePVectorHO(element);
6666  element->SetTemporaryElementType(init);
6667  ElementVector* pe2=CreatePVectorFS(element);
6668  int indices[3]={18,19,20};
6669  element->SetTemporaryElementType(MINIcondensedEnum);
6670  ElementMatrix* Ke = CreateKMatrixFS(element);
6671  element->SetTemporaryElementType(init);
6672  pe2->StaticCondensation(Ke,3,&indices[0]);
6673  delete Ke;
6674  ElementVector* pe3=CreatePVectorCouplingHOFS(element);
6675  ElementVector* pe =new ElementVector(pe1,pe2,pe3);
6676 
6677  /*clean-up and return*/
6678  delete pe1;
6679  delete pe2;
6680  delete pe3;
6681  return pe;
6682 }/*}}}*/

◆ CreatePVectorCouplingHOFS()

ElementVector * StressbalanceAnalysis::CreatePVectorCouplingHOFS ( Element *  element)

Definition at line 6325 of file StressbalanceAnalysis.cpp.

6325  {/*{{{*/
6326 
6327  /*compute all load vectors for this element*/
6328  ElementVector* pe1=CreatePVectorCouplingHOFSViscous(element);
6329  ElementVector* pe2=CreatePVectorCouplingHOFSFriction(element);
6330  ElementVector* pe =new ElementVector(pe1,pe2);
6331 
6332  /*clean-up and return*/
6333  delete pe1;
6334  delete pe2;
6335  return pe;
6336 }/*}}}*/

◆ CreatePVectorCouplingHOFSFriction()

ElementVector * StressbalanceAnalysis::CreatePVectorCouplingHOFSFriction ( Element *  element)

Definition at line 6337 of file StressbalanceAnalysis.cpp.

6337  {/*{{{*/
6338 
6339  /* Check if ice in element */
6340  if(!element->IsIceInElement()) return NULL;
6341 
6342  /*Intermediaries*/
6343  int i,approximation;
6344  int dim=3;
6345  IssmDouble Jdet,Jdet2d,FSreconditioning;
6346  IssmDouble bed_normal[3];
6347  IssmDouble viscosity, w, alpha2_gauss;
6348  IssmDouble dw[3];
6349  IssmDouble *xyz_list_tria = NULL;
6350  IssmDouble *xyz_list = NULL;
6351  IssmDouble basis[6]; //for the six nodes of the penta
6352 
6353  /*Initialize Element vector and return if necessary*/
6354  if(!element->IsOnBase() || element->IsFloating()) return NULL;
6355  element->GetInput2Value(&approximation,ApproximationEnum);
6356  if(approximation!=HOFSApproximationEnum) return NULL;
6357 
6358  int vnumnodes = element->NumberofNodesVelocity();
6359  int pnumnodes = element->NumberofNodesPressure();
6360  int numnodes = vnumnodes+pnumnodes;
6361 
6362  /*Prepare coordinate system list*/
6363  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
6364  Node **node_list = xNew<Node*>(vnumnodes+pnumnodes);
6365  for(i=0;i<vnumnodes;i++){
6366  cs_list[i] = XYZEnum;
6367  node_list[i] = element->GetNode(i);
6368  }
6369  for(i=0;i<pnumnodes;i++){
6370  cs_list[vnumnodes+i] = PressureEnum;
6371  node_list[vnumnodes+i] = element->GetNode(vnumnodes+i);
6372  }
6373 
6374  ElementVector* pe=element->NewElementVector(FSvelocityEnum);
6375 
6376  /*Retrieve all inputs and parameters*/
6377  element->GetVerticesCoordinates(&xyz_list);
6378  element->GetVerticesCoordinatesBase(&xyz_list_tria);
6379  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
6380  Input2* vx_input= element->GetInput2(VxEnum); _assert_(vx_input);
6381  Input2* vy_input= element->GetInput2(VyEnum); _assert_(vy_input);
6382  Input2* vz_input= element->GetInput2(VzEnum); _assert_(vz_input);
6383  Input2* vzHO_input=element->GetInput2(VzHOEnum); _assert_(vzHO_input);
6384 
6385  /*build friction object, used later on: */
6386  Friction* friction=new Friction(element,3);
6387 
6388  /* Start looping on the number of gauss 2d (nodes on the bedrock) */
6389  Gauss* gauss=element->NewGaussBase(2);
6390  for(int ig=gauss->begin();ig<gauss->end();ig++){
6391 
6392  gauss->GaussPoint(ig);
6393 
6394  element->JacobianDeterminantBase(&Jdet2d,xyz_list_tria,gauss);
6395  element->NodalFunctionsP1(basis, gauss);
6396 
6397  vzHO_input->GetInputValue(&w, gauss);
6398  vzHO_input->GetInputDerivativeValue(&dw[0],xyz_list,gauss);
6399 
6400  element->NormalBase(&bed_normal[0],xyz_list_tria);
6401  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
6402  friction->GetAlpha2(&alpha2_gauss,gauss);
6403 
6404  for(i=0;i<3;i++){
6405  pe->values[i*3+0]+=Jdet2d*gauss->weight*(alpha2_gauss*w*bed_normal[0]*bed_normal[2]+2*viscosity*dw[2]*bed_normal[0])*basis[i];
6406  pe->values[i*3+1]+=Jdet2d*gauss->weight*(alpha2_gauss*w*bed_normal[1]*bed_normal[2]+2*viscosity*dw[2]*bed_normal[1])*basis[i];
6407  pe->values[i*3+2]+=Jdet2d*gauss->weight*2*viscosity*(dw[0]*bed_normal[0]+dw[1]*bed_normal[1]+dw[2]*bed_normal[2])*basis[i];
6408  }
6409  }
6410 
6411  /*Transform coordinate system*/
6412  element->TransformLoadVectorCoord(pe,node_list,vnumnodes+pnumnodes,cs_list);
6413 
6414  /*Clean up and return*/
6415  xDelete<int>(cs_list);
6416  xDelete<Node*>(node_list);
6417  xDelete<IssmDouble>(xyz_list);
6418  xDelete<IssmDouble>(xyz_list_tria);
6419  delete gauss;
6420  delete friction;
6421  return pe;
6422 }/*}}}*/

◆ CreatePVectorCouplingHOFSViscous()

ElementVector * StressbalanceAnalysis::CreatePVectorCouplingHOFSViscous ( Element *  element)

Definition at line 6423 of file StressbalanceAnalysis.cpp.

6423  {/*{{{*/
6424 
6425  /* Check if ice in element */
6426  if(!element->IsIceInElement()) return NULL;
6427 
6428  /*Intermediaries */
6429  int i,approximation;
6430  int dim=3;
6431  IssmDouble viscosity,Jdet,FSreconditioning;
6432  IssmDouble dw[3];
6433  IssmDouble *xyz_list = NULL;
6434  IssmDouble basis[6]; //for the six nodes of the penta
6435  IssmDouble dbasis[3][6]; //for the six nodes of the penta
6436 
6437  /*Initialize Element vector and return if necessary*/
6438  element->GetInput2Value(&approximation,ApproximationEnum);
6439  if(approximation!=HOFSApproximationEnum) return NULL;
6440  int vnumnodes = element->NumberofNodesVelocity();
6441  int pnumnodes = element->NumberofNodesPressure();
6442 
6443  /*Prepare coordinate system list*/
6444  int* cs_list = xNew<int>(vnumnodes+pnumnodes);
6445  Node **node_list = xNew<Node*>(vnumnodes+pnumnodes);
6446  for(i=0;i<vnumnodes;i++){
6447  cs_list[i] = XYZEnum;
6448  node_list[i] = element->GetNode(i);
6449  }
6450  for(i=0;i<pnumnodes;i++){
6451  cs_list[vnumnodes+i] = PressureEnum;
6452  node_list[vnumnodes+i] = element->GetNode(vnumnodes+i);
6453  }
6454  ElementVector* pe = element->NewElementVector(FSvelocityEnum);
6455 
6456  /*Retrieve all inputs and parameters*/
6457  element->GetVerticesCoordinates(&xyz_list);
6458  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
6459  Input2* vx_input =element->GetInput2(VxEnum); _assert_(vx_input);
6460  Input2* vy_input =element->GetInput2(VyEnum); _assert_(vy_input);
6461  Input2* vz_input =element->GetInput2(VzEnum); _assert_(vz_input);
6462  Input2* vzHO_input=element->GetInput2(VzHOEnum); _assert_(vzHO_input);
6463 
6464  /* Start looping on the number of gaussian points: */
6465  Gauss* gauss=element->NewGauss(5);
6466  for(int ig=gauss->begin();ig<gauss->end();ig++){
6467 
6468  gauss->GaussPoint(ig);
6469 
6470  element->JacobianDeterminant(&Jdet, xyz_list,gauss);
6471  element->NodalFunctionsP1(&basis[0],gauss);
6472  element->NodalFunctionsP1Derivatives(&dbasis[0][0],xyz_list,gauss);
6473 
6474  element->material->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
6475  vzHO_input->GetInputDerivativeValue(&dw[0],xyz_list,gauss);
6476 
6477  for(i=0;i<6;i++){
6478  pe->values[i*3+0]+=-Jdet*gauss->weight*viscosity*dw[0]*dbasis[2][i];
6479  pe->values[i*3+1]+=-Jdet*gauss->weight*viscosity*dw[1]*dbasis[2][i];
6480  pe->values[i*3+2]+=-Jdet*gauss->weight*viscosity*(dw[0]*dbasis[0][i]+dw[1]*dbasis[1][i]+2*dw[2]*dbasis[2][i]);
6481  pe->values[3*vnumnodes+i]+=Jdet*gauss->weight*FSreconditioning*dw[2]*basis[i];
6482  }
6483  }
6484 
6485  /*Transform coordinate system*/
6486  element->TransformLoadVectorCoord(pe,node_list,vnumnodes+pnumnodes,cs_list);
6487 
6488  /*Clean up and return*/
6489  xDelete<int>(cs_list);
6490  xDelete<Node*>(node_list);
6491  xDelete<IssmDouble>(xyz_list);
6492  delete gauss;
6493  return pe;
6494 }/*}}}*/

◆ GetBprimeSSAFS()

void StressbalanceAnalysis::GetBprimeSSAFS ( IssmDouble *  Bprime,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6718 of file StressbalanceAnalysis.cpp.

6718  {/*{{{*/
6719  /*Compute Bprime matrix. Bprime=[Bprime1 Bprime2 Bprime3 Bprime4 Bprime5 Bprime6] where Bprimei is of size 5*2.
6720  * For node i, Bprimei can be expressed in the actual coordinate system
6721  * by:
6722  * Bprimei=[ 2*dh/dx dh/dy 0 0 ]
6723  * [ dh/dx 2*dh/dy 0 0 ]
6724  * [ dh/dy dh/dx 0 0 ]
6725  * where h is the interpolation function for node i.
6726  *
6727  * We assume Bprime has been allocated already, of size: 5x(2*NUMNODESP1)
6728  */
6729 
6730  int i;
6731  IssmDouble dbasismini[3][7];
6732 
6733  /*Get dbasis in actual coordinate system: */
6734  element->NodalFunctionsMINIDerivatives(&dbasismini[0][0],xyz_list, gauss);
6735 
6736  /*Build Bprime: */
6737  for(i=0;i<6;i++){
6738  Bprime[(3*7+6)*0+3*i+0] = 2.*dbasismini[0][i];
6739  Bprime[(3*7+6)*0+3*i+1] = dbasismini[1][i];
6740  Bprime[(3*7+6)*0+3*i+2] = 0.;
6741  Bprime[(3*7+6)*1+3*i+0] = dbasismini[0][i];
6742  Bprime[(3*7+6)*1+3*i+1] = 2.*dbasismini[1][i];
6743  Bprime[(3*7+6)*1+3*i+2] = 0.;
6744  Bprime[(3*7+6)*2+3*i+0] = dbasismini[1][i];
6745  Bprime[(3*7+6)*2+3*i+1] = dbasismini[0][i];
6746  Bprime[(3*7+6)*2+3*i+2] = 0.;
6747  }
6748 
6749  for(i=0;i<1;i++){ //Add zeros for the bubble function
6750  Bprime[(3*7+6)*0+3*(6+i)+0] = 0.;
6751  Bprime[(3*7+6)*0+3*(6+i)+1] = 0.;
6752  Bprime[(3*7+6)*0+3*(6+i)+2] = 0.;
6753  Bprime[(3*7+6)*1+3*(6+i)+0] = 0.;
6754  Bprime[(3*7+6)*1+3*(6+i)+1] = 0.;
6755  Bprime[(3*7+6)*1+3*(6+i)+2] = 0.;
6756  Bprime[(3*7+6)*2+3*(6+i)+0] = 0.;
6757  Bprime[(3*7+6)*2+3*(6+i)+1] = 0.;
6758  Bprime[(3*7+6)*2+3*(6+i)+2] = 0.;
6759  }
6760 
6761  for(i=0;i<6;i++){ //last column not for the bubble function
6762  Bprime[(3*7+6)*0+7*3+i] = 0.;
6763  Bprime[(3*7+6)*1+7*3+i] = 0.;
6764  Bprime[(3*7+6)*2+7*3+i] = 0.;
6765  }
6766 }/*}}}*/

◆ GetBprimeSSAFSTria()

void StressbalanceAnalysis::GetBprimeSSAFSTria ( IssmDouble *  Bprime,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6767 of file StressbalanceAnalysis.cpp.

6767  {/*{{{*/
6768  /*Compute Bprime matrix. Bprime=[Bprime1 Bprime2 Bprime3] where Bprimei is of size 3*2.
6769  * For node i, Bprimei can be expressed in the actual coordinate system
6770  * by:
6771  * Bprimei=[ dN/dx 0 ]
6772  * [ 0 dN/dy ]
6773  * [ dN/dy dN/dx ]
6774  N [ dN/dx dN/dy ]
6775  * where N is the finiteelement function for node i.
6776  *
6777  * We assume Bprime has been allocated already, of size: 3x(2*numnodes)
6778  */
6779 
6780  /*Fetch number of nodes for this finite element*/
6781  int numnodes = element->GetNumberOfNodes();
6782 
6783  /*Get nodal functions*/
6784  IssmDouble* dbasis=xNew<IssmDouble>(2*numnodes);
6785  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
6786 
6787  /*Build Bprime: */
6788  for(int i=0;i<numnodes;i++){
6789  Bprime[2*numnodes*0+2*i+0] = dbasis[0*numnodes+i];
6790  Bprime[2*numnodes*0+2*i+1] = 0.;
6791  Bprime[2*numnodes*1+2*i+0] = 0.;
6792  Bprime[2*numnodes*1+2*i+1] = dbasis[1*numnodes+i];
6793  Bprime[2*numnodes*2+2*i+0] = dbasis[1*numnodes+i];
6794  Bprime[2*numnodes*2+2*i+1] = dbasis[0*numnodes+i];
6795  Bprime[2*numnodes*3+2*i+0] = dbasis[0*numnodes+i];
6796  Bprime[2*numnodes*3+2*i+1] = dbasis[1*numnodes+i];
6797  }
6798 
6799  /*Clean-up*/
6800  xDelete<IssmDouble>(dbasis);
6801 }/*}}}*/

◆ GetBSSAFS()

void StressbalanceAnalysis::GetBSSAFS ( IssmDouble *  B,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6802 of file StressbalanceAnalysis.cpp.

6802  {/*{{{*/
6803  /*Compute B matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 5*2.
6804  * For node i, Bi can be expressed in the actual coordinate system
6805  * by:
6806  * Bi=[ dh/dx 0 0 0 ]
6807  * [ 0 dh/dy 0 0 ]
6808  * [ 1/2*dh/dy 1/2*dh/dx 0 0 ]
6809  * [ 0 0 0 h ]
6810  * where h is the interpolation function for node i.
6811  *
6812  * We assume B has been allocated already, of size: 5x(2*NUMNODESP1)
6813  */
6814 
6815  int i;
6816  IssmDouble dbasismini[3][7];
6817  IssmDouble basis[6];
6818 
6819  /*Get dbasis in actual coordinate system: */
6820  element->NodalFunctionsMINIDerivatives(&dbasismini[0][0],xyz_list, gauss);
6821  element->NodalFunctionsP1(basis,gauss);
6822 
6823  /*Build B: */
6824  for(i=0;i<6;i++){
6825  B[(3*7+6)*0+3*i+0] = dbasismini[0][i];
6826  B[(3*7+6)*0+3*i+1] = 0.;
6827  B[(3*7+6)*0+3*i+2] = 0.;
6828  B[(3*7+6)*1+3*i+0] = 0.;
6829  B[(3*7+6)*1+3*i+1] = dbasismini[1][i];
6830  B[(3*7+6)*1+3*i+2] = 0.;
6831  B[(3*7+6)*2+3*i+0] = 0.5*dbasismini[1][i];
6832  B[(3*7+6)*2+3*i+1] = 0.5*dbasismini[0][i];
6833  B[(3*7+6)*2+3*i+2] = 0.;
6834  B[(3*7+6)*3+3*i+0] = 0.;
6835  B[(3*7+6)*3+3*i+1] = 0.;
6836  B[(3*7+6)*3+3*i+2] = 0.;
6837  }
6838  for(i=0;i<1;i++){
6839  B[(3*7+6)*0+3*(6+i)+0] = 0.;
6840  B[(3*7+6)*0+3*(6+i)+1] = 0.;
6841  B[(3*7+6)*0+3*(6+i)+2] = 0.;
6842  B[(3*7+6)*1+3*(6+i)+0] = 0.;
6843  B[(3*7+6)*1+3*(6+i)+1] = 0.;
6844  B[(3*7+6)*1+3*(6+i)+2] = 0.;
6845  B[(3*7+6)*2+3*(6+i)+0] = 0.;
6846  B[(3*7+6)*2+3*(6+i)+1] = 0.;
6847  B[(3*7+6)*2+3*(6+i)+2] = 0.;
6848  B[(3*7+6)*3+3*(6+i)+0] = 0.;
6849  B[(3*7+6)*3+3*(6+i)+1] = 0.;
6850  B[(3*7+6)*3+3*(6+i)+2] = 0.;
6851  }
6852 
6853  for(i=0;i<6;i++){ //last column not for the bubble function
6854  B[(3*7+6)*0+7*3+i] = 0;
6855  B[(3*7+6)*1+7*3+i] = 0;
6856  B[(3*7+6)*2+7*3+i] = 0;
6857  B[(3*7+6)*3+7*3+i] = basis[i];
6858  }
6859 }/*}}}*/

◆ GetBSSAFSTria()

void StressbalanceAnalysis::GetBSSAFSTria ( IssmDouble *  B,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6860 of file StressbalanceAnalysis.cpp.

6860  {/*{{{*/
6861  /*Compute B matrix. B=[B1 B2 B3] where Bi is of size 3*2.
6862  * For node i, Bi can be expressed in the actual coordinate system
6863  * by:
6864  * Bi=[ dN/dx 0 ]
6865  * [ 0 dN/dy ]
6866  * [ 1/2*dN/dy 1/2*dN/dx ]
6867  * where N is the finiteelement function for node i.
6868  *
6869  * We assume B has been allocated already, of size: 3x(2*numnodes)
6870  */
6871 
6872  /*Fetch number of nodes for this finite element*/
6873  int numnodes = element->GetNumberOfNodes();
6874 
6875  /*Get nodal functions derivatives*/
6876  IssmDouble* dbasis=xNew<IssmDouble>(2*numnodes);
6877  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
6878 
6879  /*Build B': */
6880  for(int i=0;i<numnodes;i++){
6881  B[2*numnodes*0+2*i+0] = dbasis[0*numnodes+i];
6882  B[2*numnodes*0+2*i+1] = 0.;
6883  B[2*numnodes*1+2*i+0] = 0.;
6884  B[2*numnodes*1+2*i+1] = dbasis[1*numnodes+i];
6885  B[2*numnodes*2+2*i+0] = 0.5*dbasis[1*numnodes+i];
6886  B[2*numnodes*2+2*i+1] = 0.5*dbasis[0*numnodes+i];
6887  }
6888 
6889  /*Clean-up*/
6890  xDelete<IssmDouble>(dbasis);
6891 }/*}}}*/

◆ GetBSSAHO()

void StressbalanceAnalysis::GetBSSAHO ( IssmDouble *  B,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6892 of file StressbalanceAnalysis.cpp.

6892  {/*{{{*/
6893  /*Compute B matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 3*2.
6894  * For node i, Bi can be expressed in the actual coordinate system
6895  * by:
6896  * Bi=[ dh/dx 0 ]
6897  * [ 0 dh/dy ]
6898  * [ 1/2*dh/dy 1/2*dh/dx ]
6899  * where h is the interpolation function for node i.
6900  *
6901  * We assume B has been allocated already, of size: 5x(2*NUMNODESP1)
6902  */
6903 
6904  int numnodes = element->GetNumberOfNodes();
6905  IssmDouble* dbasis=xNew<IssmDouble>(3*numnodes);
6906 
6907  /*Get dbasis in actual coordinate system: */
6908  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
6909 
6910  /*Build B: */
6911  for(int i=0;i<numnodes;i++){
6912  B[2*numnodes*0+2*i+0] = dbasis[0*numnodes+i];
6913  B[2*numnodes*0+2*i+1] = 0.;
6914  B[2*numnodes*1+2*i+0] = 0.;
6915  B[2*numnodes*1+2*i+1] = dbasis[1*numnodes+i];
6916  B[2*numnodes*2+2*i+0] = .5*dbasis[1*numnodes+i];
6917  B[2*numnodes*2+2*i+1] = .5*dbasis[0*numnodes+i];
6918  }
6919 
6920  /*Clean-up*/
6921  xDelete<IssmDouble>(dbasis);
6922 }/*}}}*/

◆ GetLFSSSA()

void StressbalanceAnalysis::GetLFSSSA ( IssmDouble *  L,
Element *  element,
Gauss *  gauss 
)

Definition at line 7062 of file StressbalanceAnalysis.cpp.

7062  {/*{{{*/
7063  /* Compute L matrix. L=[L1 L2 L3] where Li is square and of size numdof.
7064  * For node i, Li can be expressed in the actual coordinate system
7065  * by:
7066  * Li=[ h 0 0 ]
7067  * [ 0 h 0 ]
7068  * [ 0 0 h ]
7069  * [ 0 0 h ]
7070  * where h is the interpolation function for node i.
7071  */
7072 
7073  int num_dof=3;
7074  IssmDouble basis[3];
7075 
7076  /*Cast gauss to GaussPenta*/
7077  _assert_(gauss_in->Enum()==GaussPentaEnum);
7078  GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
7079 
7080  /*Get basis in actual coordinate system: */
7081  basis[0]=gauss->coord1*(1-gauss->coord4)/2.0;
7082  basis[1]=gauss->coord2*(1-gauss->coord4)/2.0;
7083  basis[2]=gauss->coord3*(1-gauss->coord4)/2.0;
7084 
7085  /*Build LFS: */
7086  for(int i=0;i<3;i++){
7087  LFS[num_dof*3*0+num_dof*i+0] = basis[i];
7088  LFS[num_dof*3*0+num_dof*i+1] = 0.;
7089  LFS[num_dof*3*0+num_dof*i+2] = 0.;
7090  LFS[num_dof*3*1+num_dof*i+0] = 0.;
7091  LFS[num_dof*3*1+num_dof*i+1] = basis[i];
7092  LFS[num_dof*3*1+num_dof*i+2] = 0.;
7093  LFS[num_dof*3*2+num_dof*i+0] = 0.;
7094  LFS[num_dof*3*2+num_dof*i+1] = 0.;
7095  LFS[num_dof*3*2+num_dof*i+2] = basis[i];
7096  LFS[num_dof*3*3+num_dof*i+0] = 0.;
7097  LFS[num_dof*3*3+num_dof*i+1] = 0.;
7098  LFS[num_dof*3*3+num_dof*i+2] = basis[i];
7099  }
7100 }/*}}}*/

◆ GetLprimeFSSSA()

void StressbalanceAnalysis::GetLprimeFSSSA ( IssmDouble *  Lprime,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6923 of file StressbalanceAnalysis.cpp.

6923  {/*{{{*/
6924  /* Compute Lprime matrix. Lprime=[Lp1 Lp2 Lp3] where Lpi is square and of size numdof.
6925  * For node i, Lpi can be expressed in the actual coordinate system
6926  * by:
6927  * Lpi=[ h 0 ]
6928  * [ 0 h ]
6929  * [ h 0 ]
6930  * [ 0 h ]
6931  * where h is the interpolation function for node i.
6932  */
6933  int num_dof=2;
6934  IssmDouble basis[3];
6935 
6936  /*Cast gauss to GaussPenta*/
6937  _assert_(gauss_in->Enum()==GaussPentaEnum);
6938  GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
6939 
6940  /*Get basis in actual coordinate system: */
6941  basis[0]=gauss->coord1*(1-gauss->coord4)/2.0;
6942  basis[1]=gauss->coord2*(1-gauss->coord4)/2.0;
6943  basis[2]=gauss->coord3*(1-gauss->coord4)/2.0;
6944 
6945  /*Build LprimeFS: */
6946  for(int i=0;i<3;i++){
6947  LprimeFS[num_dof*3*0+num_dof*i+0] = basis[i];
6948  LprimeFS[num_dof*3*0+num_dof*i+1] = 0.;
6949  LprimeFS[num_dof*3*1+num_dof*i+0] = 0.;
6950  LprimeFS[num_dof*3*1+num_dof*i+1] = basis[i];
6951  LprimeFS[num_dof*3*2+num_dof*i+0] = basis[i];
6952  LprimeFS[num_dof*3*2+num_dof*i+1] = 0.;
6953  LprimeFS[num_dof*3*3+num_dof*i+0] = 0.;
6954  LprimeFS[num_dof*3*3+num_dof*i+1] = basis[i];
6955  }
6956 }/*}}}*/

◆ GetLprimeSSAFS()

void StressbalanceAnalysis::GetLprimeSSAFS ( IssmDouble *  Lprime,
Element *  element,
IssmDouble *  xyz_list,
Gauss *  gauss 
)

Definition at line 6957 of file StressbalanceAnalysis.cpp.

6957  {/*{{{*/
6958  /* Compute Lprime matrix. Lprime=[Lp1 Lp2 Lp3] where Lpi is square and of size numdof.
6959  * For node i, Lpi can be expressed in the actual coordinate system
6960  * by:
6961  * Lpi=[ h 0 0 0]
6962  * [ 0 h 0 0]
6963  * [ 0 0 h 0]
6964  * [ 0 0 h 0]
6965  * [ 0 0 dh/dz 0]
6966  * [ 0 0 dh/dz 0]
6967  * [ 0 0 0 h]
6968  * [ 0 0 0 h]
6969  * where h is the interpolation function for node i.
6970  */
6971  int num_dof=3;
6972  int num_dof_vel=3*7;
6973  int num_dof_total=3*7+1*6;
6974  IssmDouble basis[3];
6975  IssmDouble dbasis[3][6];
6976 
6977  /*Cast gauss to GaussPenta*/
6978  _assert_(gauss_in->Enum()==GaussPentaEnum);
6979  GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
6980 
6981  /*Get basis in actual coordinate system: */
6982  basis[0]=gauss->coord1*(1-gauss->coord4)/2.0;
6983  basis[1]=gauss->coord2*(1-gauss->coord4)/2.0;
6984  basis[2]=gauss->coord3*(1-gauss->coord4)/2.0;
6985 
6986  element->NodalFunctionsP1Derivatives(&dbasis[0][0],xyz_list,gauss);
6987 
6988  /*Build LprimeFS: */
6989  for(int i=0;i<3;i++){
6990  LprimeFS[num_dof_total*0+num_dof*i+0] = basis[i];
6991  LprimeFS[num_dof_total*0+num_dof*i+1] = 0.;
6992  LprimeFS[num_dof_total*0+num_dof*i+2] = 0.;
6993  LprimeFS[num_dof_total*1+num_dof*i+0] = 0.;
6994  LprimeFS[num_dof_total*1+num_dof*i+1] = basis[i];
6995  LprimeFS[num_dof_total*1+num_dof*i+2] = 0.;
6996  LprimeFS[num_dof_total*2+num_dof*i+0] = 0.;
6997  LprimeFS[num_dof_total*2+num_dof*i+1] = 0.;
6998  LprimeFS[num_dof_total*2+num_dof*i+2] = basis[i];
6999  LprimeFS[num_dof_total*3+num_dof*i+0] = 0.;
7000  LprimeFS[num_dof_total*3+num_dof*i+1] = 0.;
7001  LprimeFS[num_dof_total*3+num_dof*i+2] = basis[i];
7002  LprimeFS[num_dof_total*4+num_dof*i+0] = 0.;
7003  LprimeFS[num_dof_total*4+num_dof*i+1] = 0.;
7004  LprimeFS[num_dof_total*4+num_dof*i+2] = dbasis[2][i];
7005  LprimeFS[num_dof_total*5+num_dof*i+0] = 0.;
7006  LprimeFS[num_dof_total*5+num_dof*i+1] = 0.;
7007  LprimeFS[num_dof_total*5+num_dof*i+2] = dbasis[2][i];
7008  LprimeFS[num_dof_total*6+num_dof*i+0] = 0.;
7009  LprimeFS[num_dof_total*6+num_dof*i+1] = 0.;
7010  LprimeFS[num_dof_total*6+num_dof*i+2] = 0.;
7011  LprimeFS[num_dof_total*7+num_dof*i+0] = 0.;
7012  LprimeFS[num_dof_total*7+num_dof*i+1] = 0.;
7013  LprimeFS[num_dof_total*7+num_dof*i+2] = 0.;
7014  }
7015  for(int i=3;i<7;i++){
7016  LprimeFS[num_dof_total*0+num_dof*i+0] = 0.;
7017  LprimeFS[num_dof_total*0+num_dof*i+1] = 0.;
7018  LprimeFS[num_dof_total*0+num_dof*i+2] = 0.;
7019  LprimeFS[num_dof_total*1+num_dof*i+0] = 0.;
7020  LprimeFS[num_dof_total*1+num_dof*i+1] = 0.;
7021  LprimeFS[num_dof_total*1+num_dof*i+2] = 0.;
7022  LprimeFS[num_dof_total*2+num_dof*i+0] = 0.;
7023  LprimeFS[num_dof_total*2+num_dof*i+1] = 0.;
7024  LprimeFS[num_dof_total*2+num_dof*i+2] = 0.;
7025  LprimeFS[num_dof_total*3+num_dof*i+0] = 0.;
7026  LprimeFS[num_dof_total*3+num_dof*i+1] = 0.;
7027  LprimeFS[num_dof_total*3+num_dof*i+2] = 0.;
7028  LprimeFS[num_dof_total*4+num_dof*i+0] = 0.;
7029  LprimeFS[num_dof_total*4+num_dof*i+1] = 0.;
7030  LprimeFS[num_dof_total*4+num_dof*i+2] = 0.;
7031  LprimeFS[num_dof_total*5+num_dof*i+0] = 0.;
7032  LprimeFS[num_dof_total*5+num_dof*i+1] = 0.;
7033  LprimeFS[num_dof_total*5+num_dof*i+2] = 0.;
7034  LprimeFS[num_dof_total*6+num_dof*i+0] = 0.;
7035  LprimeFS[num_dof_total*6+num_dof*i+1] = 0.;
7036  LprimeFS[num_dof_total*6+num_dof*i+2] = 0.;
7037  LprimeFS[num_dof_total*7+num_dof*i+0] = 0.;
7038  LprimeFS[num_dof_total*7+num_dof*i+1] = 0.;
7039  LprimeFS[num_dof_total*7+num_dof*i+2] = 0.;
7040  }
7041  for(int i=0;i<3;i++){
7042  LprimeFS[num_dof_total*0+num_dof_vel+i] = 0.;
7043  LprimeFS[num_dof_total*1+num_dof_vel+i] = 0.;
7044  LprimeFS[num_dof_total*2+num_dof_vel+i] = 0.;
7045  LprimeFS[num_dof_total*3+num_dof_vel+i] = 0.;
7046  LprimeFS[num_dof_total*4+num_dof_vel+i] = 0.;
7047  LprimeFS[num_dof_total*5+num_dof_vel+i] = 0.;
7048  LprimeFS[num_dof_total*6+num_dof_vel+i] = basis[i];
7049  LprimeFS[num_dof_total*7+num_dof_vel+i] = basis[i];
7050  }
7051  for(int i=3;i<6;i++){
7052  LprimeFS[num_dof_total*0+num_dof_vel+i] = 0.;
7053  LprimeFS[num_dof_total*1+num_dof_vel+i] = 0.;
7054  LprimeFS[num_dof_total*2+num_dof_vel+i] = 0.;
7055  LprimeFS[num_dof_total*3+num_dof_vel+i] = 0.;
7056  LprimeFS[num_dof_total*4+num_dof_vel+i] = 0.;
7057  LprimeFS[num_dof_total*5+num_dof_vel+i] = 0.;
7058  LprimeFS[num_dof_total*6+num_dof_vel+i] = 0.;
7059  LprimeFS[num_dof_total*7+num_dof_vel+i] = 0.;
7060  }
7061 }/*}}}*/

◆ GetLSSAFS()

void StressbalanceAnalysis::GetLSSAFS ( IssmDouble *  L,
Element *  element,
Gauss *  gauss 
)

Definition at line 7101 of file StressbalanceAnalysis.cpp.

7101  {/*{{{*/
7102  /*
7103  * Compute L matrix. L=[L1 L2 L3] where Li is square and of size numdof.
7104  * For node i, Li can be expressed in the actual coordinate system
7105  * by:
7106  * Li=[ h 0 ]
7107  * [ 0 h ]
7108  * [ h 0 ]
7109  * [ 0 h ]
7110  * [ h 0 ]
7111  * [ 0 h ]
7112  * [ h 0 ]
7113  * [ 0 h ]
7114  * where h is the interpolation function for node i.
7115  */
7116 
7117  int num_dof=2;
7118  IssmDouble basis[3];
7119 
7120  /*Cast gauss to GaussPenta*/
7121  _assert_(gauss_in->Enum()==GaussPentaEnum);
7122  GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
7123 
7124  /*Get basis in actual coordinate system: */
7125  basis[0]=gauss->coord1*(1-gauss->coord4)/2.0;
7126  basis[1]=gauss->coord2*(1-gauss->coord4)/2.0;
7127  basis[2]=gauss->coord3*(1-gauss->coord4)/2.0;
7128 
7129  /*Build LFS: */
7130  for(int i=0;i<3;i++){
7131  LFS[num_dof*3*0+num_dof*i+0] = basis[i];
7132  LFS[num_dof*3*0+num_dof*i+1] = 0;
7133  LFS[num_dof*3*1+num_dof*i+0] = 0;
7134  LFS[num_dof*3*1+num_dof*i+1] = basis[i];
7135  LFS[num_dof*3*2+num_dof*i+0] = basis[i];
7136  LFS[num_dof*3*2+num_dof*i+1] = 0;
7137  LFS[num_dof*3*3+num_dof*i+0] = 0;
7138  LFS[num_dof*3*3+num_dof*i+1] = basis[i];
7139  LFS[num_dof*3*4+num_dof*i+0] = basis[i];
7140  LFS[num_dof*3*4+num_dof*i+1] = 0;
7141  LFS[num_dof*3*5+num_dof*i+0] = 0;
7142  LFS[num_dof*3*5+num_dof*i+1] = basis[i];
7143  LFS[num_dof*3*6+num_dof*i+0] = basis[i];
7144  LFS[num_dof*3*6+num_dof*i+1] = 0;
7145  LFS[num_dof*3*7+num_dof*i+0] = 0;
7146  LFS[num_dof*3*7+num_dof*i+1] = basis[i];
7147  }
7148 }/*}}}*/

◆ InputUpdateFromSolutionHOFS()

void StressbalanceAnalysis::InputUpdateFromSolutionHOFS ( IssmDouble *  solution,
Element *  element 
)

Definition at line 7149 of file StressbalanceAnalysis.cpp.

7149  {/*{{{*/
7150 
7151  int i;
7152  IssmDouble rho_ice,g,FSreconditioning;
7153  int* doflistHO = NULL;
7154  int* doflistFSv = NULL;
7155  int* doflistFSp = NULL;
7156 
7157  /*Only works with Penta for now*/
7158  if(element->ObjectEnum()!=PentaEnum) _error_("Coupling not supported for "<<EnumToStringx(element->ObjectEnum()));
7159 
7160  /*Fetch number of nodes and dof for this finite element*/
7161  int numnodes = 6;
7162  int numdofHO = 6*2;
7163  int numdofFSv = 6*3;
7164  int numdofFSp = 6;
7165 
7166  /*Fetch dof list and allocate solution vectors*/
7167  element->GetDofListLocal(&doflistFSv,FSvelocityEnum,GsetEnum);
7168  element->GetDofListLocal(&doflistHO, HOApproximationEnum, GsetEnum);
7169  element->GetDofListLocalPressure(&doflistFSp,GsetEnum);
7170  IssmDouble* HOvalues = xNew<IssmDouble>(numdofHO);
7171  IssmDouble* FSvalues = xNew<IssmDouble>(numdofFSv+numdofFSp);
7172  IssmDouble* vx = xNew<IssmDouble>(numnodes);
7173  IssmDouble* vy = xNew<IssmDouble>(numnodes);
7174  IssmDouble* vz = xNew<IssmDouble>(numnodes);
7175  IssmDouble* vzHO = xNew<IssmDouble>(numnodes);
7176  IssmDouble* vzFS = xNew<IssmDouble>(numnodes);
7177  IssmDouble* vel = xNew<IssmDouble>(numnodes);
7178  IssmDouble* pressure = xNew<IssmDouble>(numnodes);
7179 
7180  /*Prepare coordinate system list*/
7181  int* cs_list = xNew<int>(2*numnodes);
7182  for(i=0;i<numnodes;i++) cs_list[i] = XYZEnum;
7183  for(i=0;i<numnodes;i++) cs_list[numnodes+i] = PressureEnum;
7184 
7185  /*Use the dof list to index into the solution vector: */
7186  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
7187  for(i=0;i<numdofHO ;i++) HOvalues[i]=solution[doflistHO[i]];
7188  for(i=0;i<numdofFSv;i++) FSvalues[i]=solution[doflistFSv[i]];
7189  for(i=0;i<numdofFSp;i++) FSvalues[numdofFSv+i]=solution[doflistFSp[i]];
7190 
7191  /*Transform solution in Cartesian Space*/
7192  element->TransformSolutionCoord(FSvalues,2*numnodes,cs_list);
7193  element->TransformSolutionCoord(HOvalues,numnodes,XYEnum);
7194 
7195  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
7196  for(i=0;i<numnodes;i++){
7197  vx[i] = FSvalues[i*3+0]+HOvalues[i*2+0];
7198  vy[i] = FSvalues[i*3+1]+HOvalues[i*2+1];
7199  vzFS[i] = FSvalues[i*3+2];
7200  pressure[i] = FSvalues[numnodes*3+i]*FSreconditioning;
7201 
7202  /*Check solution*/
7203  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
7204  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
7205  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
7206  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
7207  if(xIsNan<IssmDouble>(vzFS[i])) _error_("NaN found in solution vector");
7208  if(xIsInf<IssmDouble>(vzFS[i])) _error_("Inf found in solution vector");
7209  if(xIsNan<IssmDouble>(pressure[i])) _error_("NaN found in solution vector");
7210  if(xIsInf<IssmDouble>(pressure[i])) _error_("Inf found in solution vector");
7211  }
7212 
7213  /*Get Vz and compute vel*/
7214  element->GetInputListOnVertices(vzHO,VzHOEnum);
7215  for(i=0;i<numnodes;i++){
7216  vz[i] = vzHO[i]+vzFS[i];
7217  vel[i]= sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
7218  }
7219 
7220  /*Add vx and vy as inputs to element: */
7221  element->AddInput2(VxEnum,vx,P1Enum);
7222  element->AddInput2(VyEnum,vy,P1Enum);
7223  element->AddInput2(VzEnum,vz,P1Enum);
7224  element->AddInput2(VzFSEnum,vzFS,P1Enum);
7225  element->AddInput2(VelEnum,vel,P1Enum);
7226  element->AddInput2(PressureEnum,pressure,P1Enum);
7227 
7228  /*Free ressources:*/
7229  xDelete<IssmDouble>(pressure);
7230  xDelete<IssmDouble>(vel);
7231  xDelete<IssmDouble>(vz);
7232  xDelete<IssmDouble>(vzHO);
7233  xDelete<IssmDouble>(vzFS);
7234  xDelete<IssmDouble>(vy);
7235  xDelete<IssmDouble>(vx);
7236  xDelete<IssmDouble>(FSvalues);
7237  xDelete<IssmDouble>(HOvalues);
7238  xDelete<int>(doflistFSp);
7239  xDelete<int>(doflistFSv);
7240  xDelete<int>(doflistHO);
7241  xDelete<int>(cs_list);
7242 }/*}}}*/

◆ InputUpdateFromSolutionSSAFS()

void StressbalanceAnalysis::InputUpdateFromSolutionSSAFS ( IssmDouble *  solution,
Element *  element 
)

Definition at line 7243 of file StressbalanceAnalysis.cpp.

7243  {/*{{{*/
7244 
7245  int i;
7246  IssmDouble rho_ice,g,FSreconditioning;
7247  int* doflistSSA = NULL;
7248  int* doflistFSv = NULL;
7249  int* doflistFSp = NULL;
7250 
7251  /*we have to add results of this element for FS and results from the element
7252  * at base for SSA, so we need to have the pointer toward the basal element*/
7253  Element* basalelement=element->GetBasalElement();
7254  if(basalelement->ObjectEnum()!=PentaEnum){
7255  _error_("Coupling not supported for "<<EnumToStringx(basalelement->ObjectEnum()));
7256  }
7257 
7258  /*Fetch number of nodes and dof for this finite element*/
7259  int numnodes = 6;
7260  int numdof2d = numnodes;
7261  int numdofSSA = 6*2;
7262  int numdofFSv = 6*3;
7263  int numdofFSp = 6;
7264 
7265  /*Fetch dof list and allocate solution vectors*/
7266  element->GetDofListLocal(&doflistFSv,FSvelocityEnum,GsetEnum);
7267  element->GetDofListLocalPressure(&doflistFSp,GsetEnum);
7268  basalelement->GetDofListLocal(&doflistSSA, SSAApproximationEnum, GsetEnum);
7269  IssmDouble* SSAvalues = xNew<IssmDouble>(numdofSSA);
7270  IssmDouble* FSvalues = xNew<IssmDouble>(numdofFSv+numdofFSp);
7271  IssmDouble* vx = xNew<IssmDouble>(numnodes);
7272  IssmDouble* vy = xNew<IssmDouble>(numnodes);
7273  IssmDouble* vz = xNew<IssmDouble>(numnodes);
7274  IssmDouble* vzSSA = xNew<IssmDouble>(numnodes);
7275  IssmDouble* vzFS = xNew<IssmDouble>(numnodes);
7276  IssmDouble* vel = xNew<IssmDouble>(numnodes);
7277  IssmDouble* pressure = xNew<IssmDouble>(numnodes);
7278 
7279  /*Prepare coordinate system list*/
7280  int* cs_list = xNew<int>(2*numnodes);
7281  for(i=0;i<numnodes;i++) cs_list[i] = XYZEnum;
7282  for(i=0;i<numnodes;i++) cs_list[numnodes+i] = PressureEnum;
7283 
7284  /*Use the dof list to index into the solution vector: */
7285  element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
7286  for(i=0;i<numdof2d;i++){
7287  SSAvalues[i] = solution[doflistSSA[i]];
7288  SSAvalues[i+numdof2d] = solution[doflistSSA[i]];
7289  }
7290  for(i=0;i<numdofFSv;i++) FSvalues[i]=solution[doflistFSv[i]];
7291  for(i=0;i<numdofFSp;i++) FSvalues[numdofFSv+i]=solution[doflistFSp[i]];
7292 
7293  /*Transform solution in Cartesian Space*/
7294  element->TransformSolutionCoord(FSvalues,2*numnodes,cs_list);
7295  element->TransformSolutionCoord(SSAvalues,numnodes,XYEnum);
7296 
7297  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
7298 
7299  for(i=0;i<numnodes;i++){
7300  vx[i] = FSvalues[i*3+0]+SSAvalues[i*2+0];
7301  vy[i] = FSvalues[i*3+1]+SSAvalues[i*2+1];
7302  vzFS[i] = FSvalues[i*3+2];
7303  pressure[i] = FSvalues[numnodes*3+i]*FSreconditioning;
7304 
7305  /*Check solution*/
7306  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
7307  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
7308  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
7309  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
7310  if(xIsNan<IssmDouble>(vzFS[i])) _error_("NaN found in solution vector");
7311  if(xIsInf<IssmDouble>(vzFS[i])) _error_("Inf found in solution vector");
7312  if(xIsNan<IssmDouble>(pressure[i])) _error_("NaN found in solution vector");
7313  if(xIsInf<IssmDouble>(pressure[i])) _error_("Inf found in solution vector");
7314  }
7315 
7316  /*Get Vz and compute vel*/
7317  element->GetInputListOnVertices(vzSSA,VzSSAEnum);
7318  for(i=0;i<numnodes;i++){
7319  vz[i] = vzSSA[i]+vzFS[i];
7320  vel[i]= sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
7321  }
7322 
7323  /*Add vx and vy as inputs to element: */
7324  element->AddInput2(VxEnum,vx,P1Enum);
7325  element->AddInput2(VyEnum,vy,P1Enum);
7326  element->AddInput2(VzEnum,vz,P1Enum);
7327  element->AddInput2(VzFSEnum,vzFS,P1Enum);
7328  element->AddInput2(VelEnum,vel,P1Enum);
7329  element->AddInput2(PressureEnum,pressure,P1Enum);
7330 
7331  /*Free ressources:*/
7332  xDelete<IssmDouble>(pressure);
7333  xDelete<IssmDouble>(vel);
7334  xDelete<IssmDouble>(vz);
7335  xDelete<IssmDouble>(vzSSA);
7336  xDelete<IssmDouble>(vzFS);
7337  xDelete<IssmDouble>(vy);
7338  xDelete<IssmDouble>(vx);
7339  xDelete<IssmDouble>(FSvalues);
7340  xDelete<IssmDouble>(SSAvalues);
7341  xDelete<int>(doflistFSp);
7342  xDelete<int>(doflistFSv);
7343  xDelete<int>(doflistSSA);
7344  xDelete<int>(cs_list);
7345 }/*}}}*/

◆ InputUpdateFromSolutionSSAHO()

void StressbalanceAnalysis::InputUpdateFromSolutionSSAHO ( IssmDouble *  solution,
Element *  element 
)

Definition at line 7346 of file StressbalanceAnalysis.cpp.

7346  {/*{{{*/
7347 
7348  int i,domaintype;
7349  IssmDouble rho_ice,g;
7350  int* SSAdoflist = NULL;
7351  int* HOdoflist = NULL;
7352  IssmDouble* xyz_list = NULL;
7353 
7354  /*we have to add results of this element for HO and results from the element
7355  * at base for SSA, so we need to have the pointer toward the basal element*/
7356  Element* basalelement=element->GetBasalElement();
7357  if(basalelement->ObjectEnum()!=PentaEnum){
7358  _error_("Coupling not supported for "<<EnumToStringx(basalelement->ObjectEnum()));
7359  }
7360 
7361  /*Fetch number of nodes and dof for this finite element*/
7362  int numnodes = element->GetNumberOfNodes();
7363  int numdof = numnodes*2;
7364  int numdof2d = numnodes;
7365 
7366  /*Fetch dof list and allocate solution vectors*/
7367  basalelement->GetDofListLocal(&SSAdoflist,SSAApproximationEnum,GsetEnum);
7368  element ->GetDofListLocal(&HOdoflist, HOApproximationEnum, GsetEnum);
7369  IssmDouble* HOvalues = xNew<IssmDouble>(numdof);
7370  IssmDouble* SSAvalues = xNew<IssmDouble>(numdof);
7371  IssmDouble* vx = xNew<IssmDouble>(numnodes);
7372  IssmDouble* vy = xNew<IssmDouble>(numnodes);
7373  IssmDouble* vz = xNew<IssmDouble>(numnodes);
7374  IssmDouble* vel = xNew<IssmDouble>(numnodes);
7375  IssmDouble* pressure = xNew<IssmDouble>(numnodes);
7376  IssmDouble* surface = xNew<IssmDouble>(numnodes);
7377 
7378  /*Use the dof list to index into the solution vector: */
7379  for(i=0;i<numdof2d;i++){
7380  HOvalues[i] = solution[HOdoflist[i]];
7381  SSAvalues[i] = solution[SSAdoflist[i]];
7382  }
7383  for(i=numdof2d;i<numdof;i++){
7384  HOvalues[i] = solution[HOdoflist[i]];
7385  SSAvalues[i] = SSAvalues[i-numdof2d];
7386  }
7387 
7388  /*Transform solution in Cartesian Space*/
7389  basalelement->TransformSolutionCoord(SSAvalues,XYEnum);
7390  element->TransformSolutionCoord(HOvalues,XYEnum);
7391 
7392  /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
7393  for(i=0;i<numnodes;i++){
7394  vx[i]=SSAvalues[i*2+0]+HOvalues[i*2+0];
7395  vy[i]=SSAvalues[i*2+1]+HOvalues[i*2+1];
7396 
7397  /*Check solution*/
7398  if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
7399  if(xIsInf<IssmDouble>(vx[i])) _error_("Inf found in solution vector");
7400  if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
7401  if(xIsInf<IssmDouble>(vy[i])) _error_("Inf found in solution vector");
7402  }
7403 
7404  /*Get Vz and compute vel*/
7405  element->GetInputListOnNodes(&vz[0],VzEnum,0.);
7406  for(i=0;i<numnodes;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
7407 
7408  /*For pressure: we have not computed pressure in this analysis, for this element. We are in 2D,
7409  *so the pressure is just the pressure at the bedrock: */
7410  rho_ice = element->FindParam(MaterialsRhoIceEnum);
7411  g = element->FindParam(ConstantsGEnum);
7412  element->GetVerticesCoordinates(&xyz_list);
7413  element->GetInputListOnNodes(&surface[0],SurfaceEnum);
7414  for(i=0;i<numnodes;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
7415 
7416  /*Add vx and vy as inputs to element: */
7417  element->AddInput2(VxEnum,vx,P1Enum);
7418  element->AddInput2(VyEnum,vy,P1Enum);
7419  element->AddInput2(VelEnum,vel,P1Enum);
7420  element->AddInput2(PressureEnum,pressure,P1Enum);
7421 
7422  /*Free ressources:*/
7423  xDelete<IssmDouble>(surface);
7424  xDelete<IssmDouble>(pressure);
7425  xDelete<IssmDouble>(vel);
7426  xDelete<IssmDouble>(vz);
7427  xDelete<IssmDouble>(vy);
7428  xDelete<IssmDouble>(vx);
7429  xDelete<IssmDouble>(xyz_list);
7430  xDelete<IssmDouble>(SSAvalues);
7431  xDelete<IssmDouble>(HOvalues);
7432  xDelete<int>(SSAdoflist);
7433  xDelete<int>(HOdoflist);
7434 }/*}}}*/
The documentation for this class was generated from the following files:
StressbalanceAnalysis::GetLFSSSA
void GetLFSSSA(IssmDouble *L, Element *element, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:7062
DataSet::Size
int Size()
Definition: DataSet.cpp:399
BasalforcingsPicoBasinIdEnum
@ BasalforcingsPicoBasinIdEnum
Definition: EnumDefinitions.h:486
FrictionCoefficientEnum
@ FrictionCoefficientEnum
Definition: EnumDefinitions.h:574
StressbalanceAnalysis::CreatePVectorCouplingHOFSViscous
ElementVector * CreatePVectorCouplingHOFSViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:6423
BasalforcingsOceanTempEnum
@ BasalforcingsOceanTempEnum
Definition: EnumDefinitions.h:485
Element::TransformStiffnessMatrixCoord
void TransformStiffnessMatrixCoord(ElementMatrix *Ke, int cs_enum)
Definition: Element.cpp:4473
StressbalanceShelfDampeningEnum
@ StressbalanceShelfDampeningEnum
Definition: EnumDefinitions.h:414
CrouzeixRaviartEnum
@ CrouzeixRaviartEnum
Definition: EnumDefinitions.h:1023
BaseEnum
@ BaseEnum
Definition: EnumDefinitions.h:495
StressbalanceAnalysis::InputUpdateFromSolutionHO
void InputUpdateFromSolutionHO(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:2938
Element::GetElementType
virtual int GetElementType(void)=0
ElementVector::StaticCondensation
void StaticCondensation(ElementMatrix *Ke, int numindices, int *indices)
Definition: ElementVector.cpp:266
StressbalancePenaltyFactorEnum
@ StressbalancePenaltyFactorEnum
Definition: EnumDefinitions.h:409
StressbalanceAnalysis::CreatePVectorFSViscousLA
ElementVector * CreatePVectorFSViscousLA(Element *element)
Definition: StressbalanceAnalysis.cpp:4291
Element::GetInputListOnNodes
void GetInputListOnNodes(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1106
StressbalanceAnalysis::CreatePVectorSSA
ElementVector * CreatePVectorSSA(Element *element)
Definition: StressbalanceAnalysis.cpp:1648
DeviatoricStressxzEnum
@ DeviatoricStressxzEnum
Definition: EnumDefinitions.h:526
StressbalanceAnalysis::CreatePVectorHODrivingStress
ElementVector * CreatePVectorHODrivingStress(Element *element)
Definition: StressbalanceAnalysis.cpp:2684
StressbalanceAnalysis::CreateKMatrixFSViscous
ElementMatrix * CreateKMatrixFSViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:3232
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
StressbalanceAnalysis::CreateKMatrixSSA
ElementMatrix * CreateKMatrixSSA(Element *element)
Definition: StressbalanceAnalysis.cpp:1362
IssmDouble
double IssmDouble
Definition: types.h:37
Element::TransformSolutionCoord
void TransformSolutionCoord(IssmDouble *solution, int cs_enum)
Definition: Element.cpp:4397
Element::NormalSection
virtual void NormalSection(IssmDouble *normal, IssmDouble *xyz_list)=0
HOApproximationEnum
@ HOApproximationEnum
Definition: EnumDefinitions.h:1095
extrudefrombase_core
void extrudefrombase_core(FemModel *femmodel)
Definition: extrudefrombase_core.cpp:12
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
Element::GetDofList
void GetDofList(int **pdoflist, int approximation_enum, int setenum)
Definition: Element.cpp:961
Element::GetNumberOfNodes
virtual int GetNumberOfNodes(void)=0
FrictionPEnum
@ FrictionPEnum
Definition: EnumDefinitions.h:578
StressbalanceAnalysis::InputUpdateFromSolutionL1L2
void InputUpdateFromSolutionL1L2(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:2272
StressbalanceAnalysis::GetBFSprimeUzawa
void GetBFSprimeUzawa(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:4830
_printf0_
#define _printf0_(StreamArgs)
Definition: Print.h:29
FrictionFEnum
@ FrictionFEnum
Definition: EnumDefinitions.h:146
FrictionEffectivePressureEnum
@ FrictionEffectivePressureEnum
Definition: EnumDefinitions.h:576
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
PetscOptionsDetermineSolverType
void PetscOptionsDetermineSolverType(int *psolver_type)
Definition: PetscOptionsDetermineSolverType.cpp:20
StressbalanceAnalysis::CreateKMatrixSSA3d
ElementMatrix * CreateKMatrixSSA3d(Element *element)
Definition: StressbalanceAnalysis.cpp:6217
StressbalanceAnalysis::CreatePVectorSSAFront
ElementVector * CreatePVectorSSAFront(Element *element)
Definition: StressbalanceAnalysis.cpp:1740
Element::NodalFunctionsTensor
virtual void NodalFunctionsTensor(IssmDouble *basis, Gauss *gauss)=0
StressbalanceAnalysisEnum
@ StressbalanceAnalysisEnum
Definition: EnumDefinitions.h:1285
Element::NewGaussBase
virtual Gauss * NewGaussBase(int order)=0
DeviatoricStressyzEnum
@ DeviatoricStressyzEnum
Definition: EnumDefinitions.h:528
StressbalanceAnalysis::CreateKMatrixFSFriction
ElementMatrix * CreateKMatrixFSFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:3922
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
FlowequationIsSSAEnum
@ FlowequationIsSSAEnum
Definition: EnumDefinitions.h:142
GaussPenta::coord1
IssmDouble coord1
Definition: GaussPenta.h:24
StressbalanceAnalysis::InputUpdateFromSolutionSSAFS
void InputUpdateFromSolutionSSAFS(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:7243
MaskOceanLevelsetEnum
@ MaskOceanLevelsetEnum
Definition: EnumDefinitions.h:640
StressbalanceAnalysis::CreatePVectorHOFS
ElementVector * CreatePVectorHOFS(Element *element)
Definition: StressbalanceAnalysis.cpp:6660
SSAHOApproximationEnum
@ SSAHOApproximationEnum
Definition: EnumDefinitions.h:1257
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
MeshVertexonboundaryEnum
@ MeshVertexonboundaryEnum
Definition: EnumDefinitions.h:654
FemModel::parameters
Parameters * parameters
Definition: FemModel.h:46
StressbalanceFSreconditioningEnum
@ StressbalanceFSreconditioningEnum
Definition: EnumDefinitions.h:405
StressbalanceAnalysis::CreateKMatrixCouplingSSAFSFriction
ElementMatrix * CreateKMatrixCouplingSSAFSFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:5752
TimesteppingTimeStepEnum
@ TimesteppingTimeStepEnum
Definition: EnumDefinitions.h:433
Gauss::end
virtual int end(void)=0
DeviatoricStressxxEnum
@ DeviatoricStressxxEnum
Definition: EnumDefinitions.h:524
Element::PressureInterpolation
virtual int PressureInterpolation()=0
StressbalanceAnalysis::CreatePVectorCouplingHOFS
ElementVector * CreatePVectorCouplingHOFS(Element *element)
Definition: StressbalanceAnalysis.cpp:6325
MINIEnum
@ MINIEnum
Definition: EnumDefinitions.h:1156
Element::TransformInvStiffnessMatrixCoord
void TransformInvStiffnessMatrixCoord(ElementMatrix *Ke, int cs_enum)
Definition: Element.cpp:4299
StressbalanceAnalysis::CreateJacobianMatrixHO
ElementMatrix * CreateJacobianMatrixHO(Element *element)
Definition: StressbalanceAnalysis.cpp:2368
FrictionGammaEnum
@ FrictionGammaEnum
Definition: EnumDefinitions.h:147
solutionsequence_schurcg
void solutionsequence_schurcg(FemModel *femmodel)
Definition: solutionsequence_schurcg.cpp:834
Element::SpawnBasalElement
virtual Element * SpawnBasalElement(void)=0
IoCodeToEnumElementEquation
int IoCodeToEnumElementEquation(int enum_in)
Definition: IoCodeConversions.cpp:311
Element::NewElementMatrixCoupling
ElementMatrix * NewElementMatrixCoupling(int number_nodes, int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2501
StressbalanceAnalysis::CreatePVectorL1L2DrivingStress
ElementVector * CreatePVectorL1L2DrivingStress(Element *element)
Definition: StressbalanceAnalysis.cpp:2163
StressbalanceAnalysis::CreatePVectorCouplingHOFSFriction
ElementVector * CreatePVectorCouplingHOFSFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:6337
StressbalanceAnalysis::CreateKMatrixCouplingSSAHO
ElementMatrix * CreateKMatrixCouplingSSAHO(Element *element)
Definition: StressbalanceAnalysis.cpp:5986
StressbalanceAnalysis::CreateKMatrixHOFriction
ElementMatrix * CreateKMatrixHOFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:2444
StressbalanceAnalysis::InputUpdateFromSolutionFS
void InputUpdateFromSolutionFS(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:5234
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
Matrix4x4Solve
void Matrix4x4Solve(IssmDouble *X, IssmDouble *A, IssmDouble *B)
Definition: MatrixUtils.cpp:570
Material::ViscosityHODerivativeEpsSquare
virtual void ViscosityHODerivativeEpsSquare(IssmDouble *pmu_prime, IssmDouble *epsilon, Gauss *gauss)=0
StressbalanceAnalysis::CreateKMatrixL1L2Friction
ElementMatrix * CreateKMatrixL1L2Friction(Element *element)
Definition: StressbalanceAnalysis.cpp:2060
StressbalanceAnalysis::CreatePVectorHOFront
ElementVector * CreatePVectorHOFront(Element *element)
Definition: StressbalanceAnalysis.cpp:2733
StressbalanceAnalysis::InputUpdateFromSolutionHOFS
void InputUpdateFromSolutionHOFS(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:7149
Element::TransformLoadVectorCoord
void TransformLoadVectorCoord(ElementVector *pe, int cs_enum)
Definition: Element.cpp:4346
StressbalanceAnalysis::CreateKMatrixHO
ElementMatrix * CreateKMatrixHO(Element *element)
Definition: StressbalanceAnalysis.cpp:2429
Element::GetDofListPressure
void GetDofListPressure(int **pdoflist, int setenum)
Definition: Element.cpp:1007
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
Material::ViscosityHO
virtual void ViscosityHO(IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)=0
GaussPenta::coord3
IssmDouble coord3
Definition: GaussPenta.h:26
LoadingforceXEnum
@ LoadingforceXEnum
Definition: EnumDefinitions.h:637
PressureEnum
@ PressureEnum
Definition: EnumDefinitions.h:664
MaterialsRhoIceEnum
@ MaterialsRhoIceEnum
Definition: EnumDefinitions.h:264
MismipFloatingMeltRateEnum
@ MismipFloatingMeltRateEnum
Definition: EnumDefinitions.h:1190
XYZEnum
@ XYZEnum
Definition: EnumDefinitions.h:1331
P1DGEnum
@ P1DGEnum
Definition: EnumDefinitions.h:1215
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
StressbalanceAnalysis::GetBSSAHO
void GetBSSAHO(IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6892
FSSolverEnum
@ FSSolverEnum
Definition: EnumDefinitions.h:1061
StressbalanceAnalysis::CreateKMatrixCouplingHOFS
ElementMatrix * CreateKMatrixCouplingHOFS(Element *element)
Definition: StressbalanceAnalysis.cpp:5671
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
VzFSEnum
@ VzFSEnum
Definition: EnumDefinitions.h:854
BasalforcingsPicoEnum
@ BasalforcingsPicoEnum
Definition: EnumDefinitions.h:990
Element::GetZcoord
IssmDouble GetZcoord(IssmDouble *xyz_list, Gauss *gauss)
Definition: Element.cpp:1494
FrictionQEnum
@ FrictionQEnum
Definition: EnumDefinitions.h:580
VelocityEnum
@ VelocityEnum
Definition: EnumDefinitions.h:458
Gauss::GaussNode
virtual void GaussNode(int finitelement, int iv)=0
P1bubblecondensedEnum
@ P1bubblecondensedEnum
Definition: EnumDefinitions.h:1219
Element::JacobianDeterminantBase
virtual void JacobianDeterminantBase(IssmDouble *Jdet, IssmDouble *xyz_list_base, Gauss *gauss)=0
MaterialsRheologyNEnum
@ MaterialsRheologyNEnum
Definition: EnumDefinitions.h:651
Element::IsFloating
bool IsFloating()
Definition: Element.cpp:1987
Element::NormalBase
virtual void NormalBase(IssmDouble *normal, IssmDouble *xyz_list)=0
DeviatoricStressxyEnum
@ DeviatoricStressxyEnum
Definition: EnumDefinitions.h:525
StressbalanceAnalysis::CreatePVectorL1L2Front
ElementVector * CreatePVectorL1L2Front(Element *element)
Definition: StressbalanceAnalysis.cpp:2209
FSpressureEnum
@ FSpressureEnum
Definition: EnumDefinitions.h:1062
Material::ViscosityFSDerivativeEpsSquare
virtual void ViscosityFSDerivativeEpsSquare(IssmDouble *pmu_prime, IssmDouble *epsilon, Gauss *gauss)=0
BasalforcingsUpperwaterElevationEnum
@ BasalforcingsUpperwaterElevationEnum
Definition: EnumDefinitions.h:94
FrictionCouplingEnum
@ FrictionCouplingEnum
Definition: EnumDefinitions.h:143
Element::NodalFunctionsP1Derivatives
virtual void NodalFunctionsP1Derivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
StressbalanceRiftPenaltyThresholdEnum
@ StressbalanceRiftPenaltyThresholdEnum
Definition: EnumDefinitions.h:413
StressbalanceAnalysis::CreatePVectorFSShelf
ElementVector * CreatePVectorFSShelf(Element *element)
Definition: StressbalanceAnalysis.cpp:4216
AugmentedLagrangianThetaEnum
@ AugmentedLagrangianThetaEnum
Definition: EnumDefinitions.h:41
FSApproximationEnum
@ FSApproximationEnum
Definition: EnumDefinitions.h:1060
StressbalanceAnalysis::CreatePVectorFSViscous
ElementVector * CreatePVectorFSViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:4070
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
BasalforcingsDeepwaterMeltingRateEnum
@ BasalforcingsDeepwaterMeltingRateEnum
Definition: EnumDefinitions.h:62
FlowequationFeFSEnum
@ FlowequationFeFSEnum
Definition: EnumDefinitions.h:137
Element::NodalFunctionsPressure
virtual void NodalFunctionsPressure(IssmDouble *basis, Gauss *gauss)=0
Parameters::AddObject
void AddObject(Param *newparam)
Definition: Parameters.cpp:67
VzSSAEnum
@ VzSSAEnum
Definition: EnumDefinitions.h:857
solutionsequence_nonlinear
void solutionsequence_nonlinear(FemModel *femmodel, bool conserve_loads)
Definition: solutionsequence_nonlinear.cpp:11
StressbalanceAnalysis::GetSolutionFromInputsFS
void GetSolutionFromInputsFS(Vector< IssmDouble > *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:5084
StressbalanceAnalysis::GetBHOFriction
void GetBHOFriction(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:2856
SpcStatic
Definition: SpcStatic.h:13
IoModel::my_vertices
bool * my_vertices
Definition: IoModel.h:72
StressbalanceMaxiterEnum
@ StressbalanceMaxiterEnum
Definition: EnumDefinitions.h:407
FrictionAsEnum
@ FrictionAsEnum
Definition: EnumDefinitions.h:571
L1L2ApproximationEnum
@ L1L2ApproximationEnum
Definition: EnumDefinitions.h:1135
Input2::GetInputDerivativeValue
virtual void GetInputDerivativeValue(IssmDouble *derivativevalues, IssmDouble *xyz_list, Gauss *gauss)
Definition: Input2.h:37
Element::GetDofListLocalPressure
void GetDofListLocalPressure(int **pdoflist, int setenum)
Definition: Element.cpp:1054
StressbalanceAnalysis::CreateKMatrixCouplingSSAFS
ElementMatrix * CreateKMatrixCouplingSSAFS(Element *element)
Definition: StressbalanceAnalysis.cpp:5740
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
DeviatoricStresszzEnum
@ DeviatoricStresszzEnum
Definition: EnumDefinitions.h:529
FrictionThresholdSpeedEnum
@ FrictionThresholdSpeedEnum
Definition: EnumDefinitions.h:150
solutionsequence_FScoupling_nonlinear
void solutionsequence_FScoupling_nonlinear(FemModel *femmodel, bool conserve_loads)
Definition: solutionsequence_stokescoupling_nonlinear.cpp:11
IoModel::numberofvertices
int numberofvertices
Definition: IoModel.h:99
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
solutionsequence_la
void solutionsequence_la(FemModel *femmodel)
Definition: solutionsequence_la.cpp:10
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
ElementMatrix::StaticCondensation
void StaticCondensation(int numindices, int *indices)
Definition: ElementMatrix.cpp:524
StressbalanceAnalysis::CreateKMatrixFSViscousXTH
ElementMatrix * CreateKMatrixFSViscousXTH(Element *element)
Definition: StressbalanceAnalysis.cpp:3576
TaylorHoodEnum
@ TaylorHoodEnum
Definition: EnumDefinitions.h:1299
StressbalanceAnalysis::GetBprimeSSAFSTria
void GetBprimeSSAFSTria(IssmDouble *Bprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6767
GaussTria
Definition: GaussTria.h:12
Element::NodalFunctionsP1
virtual void NodalFunctionsP1(IssmDouble *basis, Gauss *gauss)=0
Element::NewElementVector
ElementVector * NewElementVector(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2505
StressbalanceIsnewtonEnum
@ StressbalanceIsnewtonEnum
Definition: EnumDefinitions.h:406
Parameters::SetParam
void SetParam(bool boolean, int enum_type)
Definition: Parameters.cpp:441
LATaylorHoodEnum
@ LATaylorHoodEnum
Definition: EnumDefinitions.h:1139
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
VzHOEnum
@ VzHOEnum
Definition: EnumDefinitions.h:855
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
XYEnum
@ XYEnum
Definition: EnumDefinitions.h:1330
FrictionLawEnum
@ FrictionLawEnum
Definition: EnumDefinitions.h:148
DoubleParam
Definition: DoubleParam.h:20
StressbalanceAnalysis::CreatePVectorFS
ElementVector * CreatePVectorFS(Element *element)
Definition: StressbalanceAnalysis.cpp:4022
IoModel::CopyConstantObject
Param * CopyConstantObject(const char *constant_name, int param_enum)
Definition: IoModel.cpp:418
ConstantsGEnum
@ ConstantsGEnum
Definition: EnumDefinitions.h:102
FrictionCmaxEnum
@ FrictionCmaxEnum
Definition: EnumDefinitions.h:573
StressbalanceAnalysis::GetBFSvel
void GetBFSvel(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:4951
InputToExtrudeEnum
@ InputToExtrudeEnum
Definition: EnumDefinitions.h:205
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
FrictionPseudoplasticityExponentEnum
@ FrictionPseudoplasticityExponentEnum
Definition: EnumDefinitions.h:149
Penpair
Definition: Penpair.h:16
Vector::SetValues
void SetValues(int ssize, int *list, doubletype *values, InsMode mode)
Definition: Vector.h:153
Element::GetGroundedPart
virtual void GetGroundedPart(int *point1, IssmDouble *fraction1, IssmDouble *fraction2, bool *mainlyfloating)=0
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
Element::AddInput2
virtual void AddInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Element.h:216
StressbalanceAnalysis::CreateKMatrixSSALateralFriction
ElementMatrix * CreateKMatrixSSALateralFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:1497
StressbalanceAnalysis::GetBFS
void GetBFS(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:4545
Element::NewGauss
virtual Gauss * NewGauss(void)=0
ApproximationEnum
@ ApproximationEnum
Definition: EnumDefinitions.h:470
FrictionPressureAdjustedTemperatureEnum
@ FrictionPressureAdjustedTemperatureEnum
Definition: EnumDefinitions.h:579
StressbalanceAnalysis::GetLprimeSSAFS
void GetLprimeSSAFS(IssmDouble *Lprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6957
StressbalanceAnalysis::CreateKMatrixCouplingSSAHOViscous
ElementMatrix * CreateKMatrixCouplingSSAHOViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:6078
StressbalanceAnalysis::CreateJacobianMatrixSSA
ElementMatrix * CreateJacobianMatrixSSA(Element *element)
Definition: StressbalanceAnalysis.cpp:1279
LoadingforceYEnum
@ LoadingforceYEnum
Definition: EnumDefinitions.h:638
StressbalanceAnalysis::GetBFSUzawa
void GetBFSUzawa(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:4929
FloatingMeltRateEnum
@ FloatingMeltRateEnum
Definition: EnumDefinitions.h:1069
BasalforcingsOceanSalinityEnum
@ BasalforcingsOceanSalinityEnum
Definition: EnumDefinitions.h:484
VzEnum
@ VzEnum
Definition: EnumDefinitions.h:853
StressbalanceAnalysis::CreateKMatrixHOFS
ElementMatrix * CreateKMatrixHOFS(Element *element)
Definition: StressbalanceAnalysis.cpp:6165
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
LinearFloatingMeltRateEnum
@ LinearFloatingMeltRateEnum
Definition: EnumDefinitions.h:1143
OneLayerP4zEnum
@ OneLayerP4zEnum
Definition: EnumDefinitions.h:1208
DeviatoricStressyyEnum
@ DeviatoricStressyyEnum
Definition: EnumDefinitions.h:527
StressbalanceAbstolEnum
@ StressbalanceAbstolEnum
Definition: EnumDefinitions.h:404
GaussPenta
Definition: GaussPenta.h:13
StressbalanceAnalysis::GetLSSAFS
void GetLSSAFS(IssmDouble *L, Element *element, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:7101
BeckmannGoosseFloatingMeltRateEnum
@ BeckmannGoosseFloatingMeltRateEnum
Definition: EnumDefinitions.h:991
MantlePlumeGeothermalFluxEnum
@ MantlePlumeGeothermalFluxEnum
Definition: EnumDefinitions.h:1158
DomainDimensionEnum
@ DomainDimensionEnum
Definition: EnumDefinitions.h:123
GaussPenta::coord2
IssmDouble coord2
Definition: GaussPenta.h:25
GsetEnum
@ GsetEnum
Definition: EnumDefinitions.h:1093
LoadingforceZEnum
@ LoadingforceZEnum
Definition: EnumDefinitions.h:639
MatdamageiceEnum
@ MatdamageiceEnum
Definition: EnumDefinitions.h:1165
NewtonSolveDnorm
int NewtonSolveDnorm(IssmDouble *pdnorm, IssmDouble c1, IssmDouble c2, IssmDouble c3, IssmDouble n, IssmDouble dnorm)
Definition: NewtonSolveDnorm.cpp:5
StressbalanceAnalysis::CreateKMatrixSSAFriction
ElementMatrix * CreateKMatrixSSAFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:1401
BasalforcingsFloatingiceMeltingRateEnum
@ BasalforcingsFloatingiceMeltingRateEnum
Definition: EnumDefinitions.h:476
StressbalanceReltolEnum
@ StressbalanceReltolEnum
Definition: EnumDefinitions.h:410
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
P2bubbleEnum
@ P2bubbleEnum
Definition: EnumDefinitions.h:1224
StressbalanceAnalysis::CreateKMatrixSSA3dViscous
ElementMatrix * CreateKMatrixSSA3dViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:6247
StringArrayParam
Definition: StringArrayParam.h:20
Element::GetInput2Value
void GetInput2Value(bool *pvalue, int enum_type)
Definition: Element.cpp:1185
P2xP4Enum
@ P2xP4Enum
Definition: EnumDefinitions.h:1227
Material::ViscosityFS
virtual void ViscosityFS(IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *vz_input)=0
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
Element::GetNode
Node * GetNode(int nodeindex)
Definition: Element.cpp:1207
DamageLawEnum
@ DamageLawEnum
Definition: EnumDefinitions.h:117
P1P1Enum
@ P1P1Enum
Definition: EnumDefinitions.h:1216
Element::SetTemporaryElementType
virtual void SetTemporaryElementType(int element_type_in)=0
StressbalanceAnalysis::GetBFSprimevel
void GetBFSprimevel(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:4866
BasalforcingsPicoOverturningCoeffEnum
@ BasalforcingsPicoOverturningCoeffEnum
Definition: EnumDefinitions.h:488
StressbalanceAnalysis::GetBFSprime
void GetBFSprime(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:4717
MINIcondensedEnum
@ MINIcondensedEnum
Definition: EnumDefinitions.h:1157
StressbalanceAnalysis::CreateKMatrixFSShelf
ElementMatrix * CreateKMatrixFSShelf(Element *element)
Definition: StressbalanceAnalysis.cpp:3164
IntParam
Definition: IntParam.h:20
INS_VAL
@ INS_VAL
Definition: toolkitsenums.h:14
SpatialLinearFloatingMeltRateEnum
@ SpatialLinearFloatingMeltRateEnum
Definition: EnumDefinitions.h:1278
StressbalanceAnalysis::CreateKMatrixCouplingSSAHOFriction
ElementMatrix * CreateKMatrixCouplingSSAHOFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:5998
SurfaceEnum
@ SurfaceEnum
Definition: EnumDefinitions.h:823
StressbalanceAnalysis::CreatePVectorHO
ElementVector * CreatePVectorHO(Element *element)
Definition: StressbalanceAnalysis.cpp:2668
StressbalanceAnalysis::GetBSSAFS
void GetBSSAFS(IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6802
Element::IsFaceOnBoundary
virtual bool IsFaceOnBoundary(void)=0
Element::GetIcefrontCoordinates
virtual void GetIcefrontCoordinates(IssmDouble **pxyz_front, IssmDouble *xyz_list, int levelsetenum)=0
Element::NumberofNodesPressure
virtual int NumberofNodesPressure(void)=0
IoModel::FetchData
void FetchData(bool *pboolean, const char *data_name)
Definition: IoModel.cpp:933
StressbalanceAnalysis::GetBSSA
void GetBSSA(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:1816
InputUpdateFromConstantx
void InputUpdateFromConstantx(FemModel *femmodel, bool constant, int name)
Definition: InputUpdateFromConstantx.cpp:10
StressbalanceAnalysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: StressbalanceAnalysis.cpp:509
StressbalanceAnalysis::CreatePVectorSSAFS
ElementVector * CreatePVectorSSAFS(Element *element)
Definition: StressbalanceAnalysis.cpp:6683
StressbalanceAnalysis::GetBSSAprime
void GetBSSAprime(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:1893
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
Gauss::SynchronizeGaussBase
virtual void SynchronizeGaussBase(Gauss *gauss)=0
MaterialsRhoSeawaterEnum
@ MaterialsRhoSeawaterEnum
Definition: EnumDefinitions.h:265
StressbalanceAnalysis::InputUpdateFromSolutionSSAHO
void InputUpdateFromSolutionSSAHO(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:7346
BasalforcingsIsmip6Enum
@ BasalforcingsIsmip6Enum
Definition: EnumDefinitions.h:989
StressbalanceAnalysis::CreateKMatrixHOViscous
ElementMatrix * CreateKMatrixHOViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:2535
StressbalanceAnalysis::CreatePVectorSSADrivingStress
ElementVector * CreatePVectorSSADrivingStress(Element *element)
Definition: StressbalanceAnalysis.cpp:1681
Friction
Definition: Friction.h:13
NoFrictionOnPartiallyFloatingEnum
@ NoFrictionOnPartiallyFloatingEnum
Definition: EnumDefinitions.h:1196
FSvelocityEnum
@ FSvelocityEnum
Definition: EnumDefinitions.h:1063
P1bubbleEnum
@ P1bubbleEnum
Definition: EnumDefinitions.h:1218
SSAFSApproximationEnum
@ SSAFSApproximationEnum
Definition: EnumDefinitions.h:1256
Object::ObjectEnum
virtual int ObjectEnum()=0
Element::NodalFunctionsDerivativesVelocity
virtual void NodalFunctionsDerivativesVelocity(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
Input2
Definition: Input2.h:18
StressbalanceAnalysis::GetBprimeSSAFS
void GetBprimeSSAFS(IssmDouble *Bprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6718
Element::GetDofListLocal
void GetDofListLocal(int **pdoflist, int approximation_enum, int setenum)
Definition: Element.cpp:984
SpcTransient
Definition: SpcTransient.h:13
StressbalanceAnalysis::CreateKMatrixFSViscousLA
ElementMatrix * CreateKMatrixFSViscousLA(Element *element)
Definition: StressbalanceAnalysis.cpp:3446
FrictionDeltaEnum
@ FrictionDeltaEnum
Definition: EnumDefinitions.h:144
StressbalanceAnalysis::CreatePVectorCouplingSSAFSViscous
ElementVector * CreatePVectorCouplingSSAFSViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:6590
FlowequationBorderFSEnum
@ FlowequationBorderFSEnum
Definition: EnumDefinitions.h:570
GaussPenta::coord4
IssmDouble coord4
Definition: GaussPenta.h:27
Material::ViscosityL1L2
virtual void ViscosityL1L2(IssmDouble *pviscosity, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *surf)=0
DamageStressThresholdEnum
@ DamageStressThresholdEnum
Definition: EnumDefinitions.h:120
TemperatureEnum
@ TemperatureEnum
Definition: EnumDefinitions.h:831
StressbalanceAnalysis::CreateKMatrixSSAViscous
ElementMatrix * CreateKMatrixSSAViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:1563
Element::AddBasalInput2
virtual void AddBasalInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Element.h:215
StressbalanceAnalysis::GetBSSAFSTria
void GetBSSAFSTria(IssmDouble *B, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6860
StressbalanceAnalysis::CreateJacobianMatrixFS
ElementMatrix * CreateJacobianMatrixFS(Element *element)
Definition: StressbalanceAnalysis.cpp:3051
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
SpcDynamic
Definition: SpcDynamic.h:13
StressbalanceAnalysis::CreateKMatrixSSA3dFriction
ElementMatrix * CreateKMatrixSSA3dFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:6229
Element::GetLevelCoordinates
virtual void GetLevelCoordinates(IssmDouble **pxyz_front, IssmDouble *xyz_list, int levelsetenum, IssmDouble level)=0
StressbalanceAnalysis::CreateKMatrixFS
ElementMatrix * CreateKMatrixFS(Element *element)
Definition: StressbalanceAnalysis.cpp:3136
Element::JacobianDeterminantSurface
virtual void JacobianDeterminantSurface(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)=0
StressbalanceAnalysis::InputUpdateFromSolutionSSA
void InputUpdateFromSolutionSSA(IssmDouble *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:1933
StressbalanceAnalysis::CreateKMatrixSSAHO
ElementMatrix * CreateKMatrixSSAHO(Element *element)
Definition: StressbalanceAnalysis.cpp:6203
AndroidFrictionCoefficientEnum
@ AndroidFrictionCoefficientEnum
Definition: EnumDefinitions.h:976
FrictionSedimentCompressibilityCoefficientEnum
@ FrictionSedimentCompressibilityCoefficientEnum
Definition: EnumDefinitions.h:581
BasalforcingsIsmip6BasinIdEnum
@ BasalforcingsIsmip6BasinIdEnum
Definition: EnumDefinitions.h:480
Element::NodalFunctionsVelocity
virtual void NodalFunctionsVelocity(IssmDouble *basis, Gauss *gauss)=0
StrainRatexxEnum
@ StrainRatexxEnum
Definition: EnumDefinitions.h:804
LACrouzeixRaviartEnum
@ LACrouzeixRaviartEnum
Definition: EnumDefinitions.h:1138
Element::IsIceInElement
bool IsIceInElement()
Definition: Element.cpp:2021
IoModel::Data
IssmDouble * Data(const char *data_name)
Definition: IoModel.cpp:437
StrainRateyzEnum
@ StrainRateyzEnum
Definition: EnumDefinitions.h:808
StressbalanceRequestedOutputsEnum
@ StressbalanceRequestedOutputsEnum
Definition: EnumDefinitions.h:411
StrainRatexzEnum
@ StrainRatexzEnum
Definition: EnumDefinitions.h:806
Inputs2::SetInput
void SetInput(int enum_in, int index, bool value)
Definition: Inputs2.cpp:572
FrictionfEnum
@ FrictionfEnum
Definition: EnumDefinitions.h:584
Node
Definition: Node.h:23
Element::StrainRateHO
void StrainRateHO(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4084
Node::Sid
int Sid(void)
Definition: Node.cpp:622
StressbalanceNumRequestedOutputsEnum
@ StressbalanceNumRequestedOutputsEnum
Definition: EnumDefinitions.h:408
NoneEnum
@ NoneEnum
Definition: EnumDefinitions.h:1202
Element::GetVerticesCoordinatesBase
virtual void GetVerticesCoordinatesBase(IssmDouble **xyz_list)=0
BasalforcingsDeepwaterElevationEnum
@ BasalforcingsDeepwaterElevationEnum
Definition: EnumDefinitions.h:61
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Node::Deactivate
void Deactivate(void)
Definition: Node.cpp:681
HydrologyWatercolumnMaxEnum
@ HydrologyWatercolumnMaxEnum
Definition: EnumDefinitions.h:623
SetActiveNodesLSMx
void SetActiveNodesLSMx(FemModel *femmodel)
Definition: SetActiveNodesLSMx.cpp:12
StressbalanceAnalysis::GetCFS
void GetCFS(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:5015
FlowequationIsFSEnum
@ FlowequationIsFSEnum
Definition: EnumDefinitions.h:138
MaterialsRheologyBEnum
@ MaterialsRheologyBEnum
Definition: EnumDefinitions.h:643
IoModel::numberofverticalfaces
int numberofverticalfaces
Definition: IoModel.h:98
StrainRateyyEnum
@ StrainRateyyEnum
Definition: EnumDefinitions.h:807
StressbalanceRestolEnum
@ StressbalanceRestolEnum
Definition: EnumDefinitions.h:412
Element::GetYcoord
IssmDouble GetYcoord(IssmDouble *xyz_list, Gauss *gauss)
Definition: Element.cpp:1478
Gauss::begin
virtual int begin(void)=0
StressbalanceAnalysis::CreateKMatrixL1L2
ElementMatrix * CreateKMatrixL1L2(Element *element)
Definition: StressbalanceAnalysis.cpp:2045
StressbalanceAnalysis::CreatePVectorCouplingSSAFS
ElementVector * CreatePVectorCouplingSSAFS(Element *element)
Definition: StressbalanceAnalysis.cpp:6495
VerboseSolution
bool VerboseSolution(void)
Definition: Verbosity.cpp:24
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
VxEnum
@ VxEnum
Definition: EnumDefinitions.h:846
MeshVertexonsurfaceEnum
@ MeshVertexonsurfaceEnum
Definition: EnumDefinitions.h:655
Material::ViscositySSA
virtual void ViscositySSA(IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)=0
min
IssmDouble min(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:14
WatercolumnEnum
@ WatercolumnEnum
Definition: EnumDefinitions.h:859
StressbalanceAnalysis::CreatePVectorL1L2
ElementVector * CreatePVectorL1L2(Element *element)
Definition: StressbalanceAnalysis.cpp:2130
PentaEnum
@ PentaEnum
Definition: EnumDefinitions.h:1231
Element::GetGroundedPortion
virtual IssmDouble GetGroundedPortion(IssmDouble *xyz_list)=0
Element::NodalFunctionsP2
virtual void NodalFunctionsP2(IssmDouble *basis, Gauss *gauss)=0
Element::JacobianDeterminant
virtual void JacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)=0
FrictionEffectivePressureLimitEnum
@ FrictionEffectivePressureLimitEnum
Definition: EnumDefinitions.h:145
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
bamg::D2
P2< double, double > D2
Definition: Metric.h:11
FrictionTillFrictionAngleEnum
@ FrictionTillFrictionAngleEnum
Definition: EnumDefinitions.h:582
FemModel::SetCurrentConfiguration
void SetCurrentConfiguration(int configuration_type)
Definition: FemModel.cpp:634
Element::GetBasalElement
virtual Element * GetBasalElement(void)=0
SubelementFriction1Enum
@ SubelementFriction1Enum
Definition: EnumDefinitions.h:1293
solutionsequence_la_theta
void solutionsequence_la_theta(FemModel *femmodel)
Definition: solutionsequence_la_theta.cpp:10
HOFSApproximationEnum
@ HOFSApproximationEnum
Definition: EnumDefinitions.h:1096
Element::VelocityInterpolation
virtual int VelocityInterpolation()=0
Parameters::FindParam
void FindParam(bool *pinteger, int enum_type)
Definition: Parameters.cpp:262
SubelementFriction2Enum
@ SubelementFriction2Enum
Definition: EnumDefinitions.h:1294
Element::FiniteElement
virtual int FiniteElement(void)=0
ThicknessEnum
@ ThicknessEnum
Definition: EnumDefinitions.h:840
StressbalanceAnalysis::CreatePVectorCouplingSSAFSFriction
ElementVector * CreatePVectorCouplingSSAFSFriction(Element *element)
Definition: StressbalanceAnalysis.cpp:6507
AugmentedLagrangianREnum
@ AugmentedLagrangianREnum
Definition: EnumDefinitions.h:37
StressbalanceAnalysis::GetSolutionFromInputsHoriz
void GetSolutionFromInputsHoriz(Vector< IssmDouble > *solution, Element *element)
Definition: StressbalanceAnalysis.cpp:1189
Friction::GetAlpha2
void GetAlpha2(IssmDouble *palpha2, Gauss *gauss)
Definition: Friction.cpp:164
IoModel::FetchDataToInput
void FetchDataToInput(Inputs2 *inputs2, Elements *elements, const char *vector_name, int input_enum)
Definition: IoModel.cpp:1651
MatrixMultiply
int MatrixMultiply(IssmDouble *a, int nrowa, int ncola, int itrna, IssmDouble *b, int nrowb, int ncolb, int itrnb, IssmDouble *c, int iaddc)
Definition: MatrixUtils.cpp:88
SSAApproximationEnum
@ SSAApproximationEnum
Definition: EnumDefinitions.h:1255
StressbalanceAnalysis::CreatePVectorFSViscousXTH
ElementVector * CreatePVectorFSViscousXTH(Element *element)
Definition: StressbalanceAnalysis.cpp:4373
P2Enum
@ P2Enum
Definition: EnumDefinitions.h:1223
StressbalanceAnalysis::GetCFSprime
void GetCFSprime(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:5036
FrictionCoefficientcoulombEnum
@ FrictionCoefficientcoulombEnum
Definition: EnumDefinitions.h:575
VelEnum
@ VelEnum
Definition: EnumDefinitions.h:844
StressbalanceAnalysis::GetBSSAFriction
void GetBSSAFriction(IssmDouble *B, Element *element, int dim, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:1856
IoModelToConstraintsx
void IoModelToConstraintsx(Constraints *constraints, IoModel *iomodel, const char *spc_name, int analysis_type, int finite_element, int dof)
Definition: IoModelToConstraintsx.cpp:10
StressbalanceAnalysis::CreateDVectorFS
ElementVector * CreateDVectorFS(Element *element)
Definition: StressbalanceAnalysis.cpp:3027
ElementVector
Definition: ElementVector.h:20
Element::StrainRateSSA
void StrainRateSSA(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4138
GroundinglineFrictionInterpolationEnum
@ GroundinglineFrictionInterpolationEnum
Definition: EnumDefinitions.h:159
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
StressbalanceAnalysis::CreatePVectorFSFront
ElementVector * CreatePVectorFSFront(Element *element)
Definition: StressbalanceAnalysis.cpp:4140
StrainRatexyEnum
@ StrainRatexyEnum
Definition: EnumDefinitions.h:805
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
P1P1GLSEnum
@ P1P1GLSEnum
Definition: EnumDefinitions.h:1217
FrictionMEnum
@ FrictionMEnum
Definition: EnumDefinitions.h:577
StressbalanceAnalysis::CreateKMatrixCouplingSSAFSViscous
ElementMatrix * CreateKMatrixCouplingSSAFSViscous(Element *element)
Definition: StressbalanceAnalysis.cpp:5877
StressbalanceAnalysis::GetLprimeFSSSA
void GetLprimeFSSSA(IssmDouble *Lprime, Element *element, IssmDouble *xyz_list, Gauss *gauss)
Definition: StressbalanceAnalysis.cpp:6923
StressbalanceAnalysis::CreateKMatrixSSAFS
ElementMatrix * CreateKMatrixSSAFS(Element *element)
Definition: StressbalanceAnalysis.cpp:6184
EffectivePressureEnum
@ EffectivePressureEnum
Definition: EnumDefinitions.h:548
IoCodeToEnumVertexEquation
int IoCodeToEnumVertexEquation(int enum_in)
Definition: IoCodeConversions.cpp:297
SigmaNNEnum
@ SigmaNNEnum
Definition: EnumDefinitions.h:704
AugmentedLagrangianRlambdaEnum
@ AugmentedLagrangianRlambdaEnum
Definition: EnumDefinitions.h:40
FrictionVoidRatioEnum
@ FrictionVoidRatioEnum
Definition: EnumDefinitions.h:151
StrainRatezzEnum
@ StrainRatezzEnum
Definition: EnumDefinitions.h:809
Matrix3x3Solve
void Matrix3x3Solve(IssmDouble *X, IssmDouble *A, IssmDouble *B)
Definition: MatrixUtils.cpp:471
Material::ViscositySSADerivativeEpsSquare
virtual void ViscositySSADerivativeEpsSquare(IssmDouble *pmu_prime, IssmDouble *epsilon, Gauss *gauss)=0
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
FrictionWaterLayerEnum
@ FrictionWaterLayerEnum
Definition: EnumDefinitions.h:583
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
ElementMatrix
Definition: ElementMatrix.h:19
solutionsequence_newton
void solutionsequence_newton(FemModel *femmodel)
Definition: solutionsequence_newton.cpp:11
FrictionCEnum
@ FrictionCEnum
Definition: EnumDefinitions.h:572
SIAApproximationEnum
@ SIAApproximationEnum
Definition: EnumDefinitions.h:1241
FlowequationIsSIAEnum
@ FlowequationIsSIAEnum
Definition: EnumDefinitions.h:141
StressbalanceAnalysis::CreatePVectorSSAHO
ElementVector * CreatePVectorSSAHO(Element *element)
Definition: StressbalanceAnalysis.cpp:6706
Element::IsIcefront
virtual bool IsIcefront(void)=0
Gauss
Definition: Gauss.h:8
Element::material
Material * material
Definition: Element.h:50
Element::GetDofListLocalVelocity
void GetDofListLocalVelocity(int **pdoflist, int setenum)
Definition: Element.cpp:1078
Element::GetDofListVelocity
void GetDofListVelocity(int **pdoflist, int setenum)
Definition: Element.cpp:1031
XTaylorHoodEnum
@ XTaylorHoodEnum
Definition: EnumDefinitions.h:1329
FlowequationIsHOEnum
@ FlowequationIsHOEnum
Definition: EnumDefinitions.h:139
Inputs2::DuplicateInput
void DuplicateInput(int original_enum, int new_enum)
Definition: Inputs2.cpp:206
StressbalanceAnalysis::CreateKMatrixL1L2Viscous
ElementMatrix * CreateKMatrixL1L2Viscous(Element *element)
Definition: StressbalanceAnalysis.cpp:2070
Element::NodalFunctionsDerivatives
virtual void NodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
Element::NodalFunctionsMINIDerivatives
virtual void NodalFunctionsMINIDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
Element::NumberofNodesVelocity
virtual int NumberofNodesVelocity(void)=0
DamageKappaEnum
@ DamageKappaEnum
Definition: EnumDefinitions.h:116
IoModel::numberofedges
int numberofedges
Definition: IoModel.h:93
Riftfront
Definition: Riftfront.h:16
ElementMatrix::values
IssmDouble * values
Definition: ElementMatrix.h:26
GaussPentaEnum
@ GaussPentaEnum
Definition: EnumDefinitions.h:1078
FlowequationIsL1L2Enum
@ FlowequationIsL1L2Enum
Definition: EnumDefinitions.h:140
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:30 for Ice Sheet System Model by   doxygen 1.8.19