Ice Sheet System Model  4.18
Code documentation
AdjointBalancethickness2Analysis.cpp
Go to the documentation of this file.
1 #include "./AdjointBalancethickness2Analysis.h"
2 #include "../toolkits/toolkits.h"
3 #include "../classes/classes.h"
4 #include "../shared/shared.h"
5 #include "../modules/modules.h"
6 #include "../classes/Inputs2/DatasetInput2.h"
7 
8 /*Model processor*/
9 void AdjointBalancethickness2Analysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
10  _error_("not implemented yet");
11 }/*}}}*/
12 void AdjointBalancethickness2Analysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
13  _error_("not implemented yet");
14 }/*}}}*/
15 void AdjointBalancethickness2Analysis::CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr){/*{{{*/
16  _error_("not implemented yet");
17 }/*}}}*/
18 int AdjointBalancethickness2Analysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/
19  return 1;
20 }/*}}}*/
21 void AdjointBalancethickness2Analysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
22  _error_("not implemented yet");
23 }/*}}}*/
24 void AdjointBalancethickness2Analysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
25  _error_("not implemented yet");
26 }/*}}}*/
27 
28 /*Finite Element Analysis*/
29 void AdjointBalancethickness2Analysis::Core(FemModel* femmodel){/*{{{*/
30  _error_("not implemented");
31 }/*}}}*/
32 ElementVector* AdjointBalancethickness2Analysis::CreateDVector(Element* element){/*{{{*/
33  /*Default, return NULL*/
34  return NULL;
35 }/*}}}*/
36 ElementMatrix* AdjointBalancethickness2Analysis::CreateJacobianMatrix(Element* element){/*{{{*/
37 _error_("Not implemented");
38 }/*}}}*/
39 ElementMatrix* AdjointBalancethickness2Analysis::CreateKMatrix(Element* element){/*{{{*/
40 
41  Balancethickness2Analysis* analysis = new Balancethickness2Analysis();
42  ElementMatrix* Ke = analysis->CreateKMatrix(element);
43  delete analysis;
44 
45  return Ke;
46 }/*}}}*/
47 ElementVector* AdjointBalancethickness2Analysis::CreatePVector(Element* element){/*{{{*/
48 
49  /*Intermediaries */
50  int num_responses,i;
51  IssmDouble vx,vy,vel,Jdet;
52  IssmDouble surface,surfaceobs,weight;
53  int *responses = NULL;
54  IssmDouble *xyz_list = NULL;
55 
56  /*Fetch number of nodes and dof for this finite element*/
57  int numnodes = element->GetNumberOfNodes();
58 
59  /*Initialize Element vector and vectors*/
60  ElementVector* pe = element->NewElementVector(SSAApproximationEnum);
61  IssmDouble* basis = xNew<IssmDouble>(numnodes);
62  IssmDouble* dbasis = xNew<IssmDouble>(2*numnodes);
63 
64  /*Retrieve all inputs and parameters*/
65  element->GetVerticesCoordinates(&xyz_list);
66  element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
67  element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
68  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
69  Input2* surfaceobs_input = element->GetInput2(InversionSurfaceObsEnum); _assert_(surfaceobs_input);
70  DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
71  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
72  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
73 
74  /* Start looping on the number of gaussian points: */
75  Gauss* gauss=element->NewGauss(2);
76  for(int ig=gauss->begin();ig<gauss->end();ig++){
77  gauss->GaussPoint(ig);
78 
79  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
80  element->NodalFunctions(basis,gauss);
81  element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
82 
83  surface_input->GetInputValue(&surface, gauss);
84  surfaceobs_input->GetInputValue(&surfaceobs, gauss);
85 
86  /*Loop over all requested responses*/
87  for(int resp=0;resp<num_responses;resp++){
88  weights_input->GetInputValue(&weight,gauss,responses[resp]);
89 
90  switch(responses[resp]){
91  case SurfaceAbsMisfitEnum:
92  for(i=0;i<numnodes;i++) pe->values[i]+=(surfaceobs-surface)*weight*Jdet*gauss->weight*basis[i];
93  break;
94  case OmegaAbsGradientEnum:
95  /*Nothing in P vector*/
96  break;
97  case EtaDiffEnum:
98  /*Nothing in P vector*/
99  break;
100  default:
101  _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
102  }
103  }
104  }
105 
106  /*Clean up and return*/
107  xDelete<int>(responses);
108  xDelete<IssmDouble>(xyz_list);
109  xDelete<IssmDouble>(basis);
110  xDelete<IssmDouble>(dbasis);
111  delete gauss;
112  return pe;
113 
114 }/*}}}*/
115 void AdjointBalancethickness2Analysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
116  _error_("not implemented yet");
117 }/*}}}*/
118 void AdjointBalancethickness2Analysis::GradientJ(Vector<IssmDouble>* gradient,Element* element,int control_type,int control_index){/*{{{*/
119  /*The gradient of the cost function is calculated in 2 parts.
120  *
121  * dJ \partial J \partial lambda^T(KU-F)
122  * -- = ---------- + ------------------------
123  * dk \partial k \parial k
124  *
125  * */
126 
127  /*If on water, grad = 0: */
128  if(!element->IsIceInElement()) return;
129 
130  /*Get list of cost functions*/
131  int *responses = NULL;
132  int num_responses,resp;
133  element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
134  element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
135 
136  /*Deal with first part (partial derivative a J with respect to k)*/
137  for(resp=0;resp<num_responses;resp++) switch(responses[resp]){
138  case SurfaceAbsMisfitEnum:
139  /*Nothing, \partial J/\partial k = 0*/
140  break;
141  case OmegaAbsGradientEnum: GradientJOmegaGradient(element,gradient,control_index); break;
142  case EtaDiffEnum: GradientJEtaDiff(element,gradient,control_index); break;
143  default: _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
144  }
145 
146  /*Deal with second term*/
147  switch(control_type){
148  case BalancethicknessOmegaEnum: GradientJOmega(element,gradient,control_index); break;
149  case BalancethicknessThickeningRateEnum: GradientJdHdt( element,gradient,control_index); break;
150  default: _error_("control type not supported yet: " << EnumToStringx(control_type));
151  }
152 
153  /*Clean up and return*/
154  xDelete<int>(responses);
155 
156 }/*}}}*/
157 void AdjointBalancethickness2Analysis::GradientJdHdt(Element* element,Vector<IssmDouble>* gradient,int control_index){/*{{{*/
158 
159  /*Intermediaries*/
160  IssmDouble lambda,Jdet;
161  IssmDouble *xyz_list= NULL;
162 
163  /*Fetch number of vertices for this finite element*/
164  int numvertices = element->GetNumberOfVertices();
165 
166  /*Initialize some vectors*/
167  IssmDouble* basis = xNew<IssmDouble>(numvertices);
168  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
169  int* vertexpidlist = xNew<int>(numvertices);
170 
171  /*Retrieve all inputs we will be needing: */
172  element->GetVerticesCoordinates(&xyz_list);
173  element->GradientIndexing(&vertexpidlist[0],control_index);
174  Input2* adjoint_input = element->GetInput2(AdjointEnum); _assert_(adjoint_input);
175 
176  Gauss* gauss=element->NewGauss(2);
177  for(int ig=gauss->begin();ig<gauss->end();ig++){
178  gauss->GaussPoint(ig);
179 
180  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
181  element->NodalFunctionsP1(basis,gauss);
182 
183  adjoint_input->GetInputValue(&lambda,gauss);
184 
185  /*Build gradient vector (actually -dJ/da): */
186  for(int i=0;i<numvertices;i++){
187  ge[i]+= -Jdet*gauss->weight*basis[i]*lambda;
188  _assert_(!xIsNan<IssmDouble>(ge[i]));
189  }
190  }
191  gradient->SetValues(numvertices,vertexpidlist,ge,ADD_VAL);
192 
193  /*Clean up and return*/
194  xDelete<IssmDouble>(ge);
195  xDelete<IssmDouble>(xyz_list);
196  xDelete<IssmDouble>(basis);
197  xDelete<int>(vertexpidlist);
198  delete gauss;
199 }/*}}}*/
200 void AdjointBalancethickness2Analysis::GradientJOmega(Element* element,Vector<IssmDouble>* gradient,int control_index){/*{{{*/
201 
202  /*Intermediaries*/
203  int n=3;
204  IssmDouble dlambda[2],ds[2],slopex,slopey,slope,omega,Jdet,velobs;
205  IssmDouble *xyz_list= NULL;
206 
207  /*Fetch number of vertices for this finite element*/
208  int numvertices = element->GetNumberOfVertices();
209 
210  /*Initialize some vectors*/
211  IssmDouble* basis = xNew<IssmDouble>(numvertices);
212  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
213  int* vertexpidlist = xNew<int>(numvertices);
214 
215  /*Retrieve all inputs we will be needing: */
216  element->GetVerticesCoordinates(&xyz_list);
217  element->GradientIndexing(&vertexpidlist[0],control_index);
218  Input2* adjoint_input = element->GetInput2(AdjointEnum); _assert_(adjoint_input);
219  Input2* omega_input = element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
220  Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
221  Input2* surfaceslopex_input = element->GetInput2(SurfaceSlopeXEnum); _assert_(surfaceslopex_input);
222  Input2* surfaceslopey_input = element->GetInput2(SurfaceSlopeYEnum); _assert_(surfaceslopey_input);
223  Input2* velobs_input = element->GetInput2(InversionVelObsEnum); _assert_(velobs_input);
224 
225  Gauss* gauss=element->NewGauss(2);
226  for(int ig=gauss->begin();ig<gauss->end();ig++){
227  gauss->GaussPoint(ig);
228 
229  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
230  element->NodalFunctionsP1(basis,gauss);
231 
232  omega_input->GetInputValue(&omega,gauss);
233  adjoint_input->GetInputDerivativeValue(&dlambda[0],xyz_list,gauss);
234  surface_input->GetInputDerivativeValue(&ds[0],xyz_list,gauss);
235  surfaceslopex_input->GetInputValue(&slopex,gauss);
236  surfaceslopey_input->GetInputValue(&slopey,gauss);
237  velobs_input->GetInputValue(&velobs,gauss);
238 
239  slope = sqrt(slopex*slopex + slopey*slopey);
240  //if(slope<1.e-5) slope = 1.e-5;
241 
242  /*Build gradient vector (actually -dJ/da): */
243  for(int i=0;i<numvertices;i++){
244  ge[i]+= - Jdet*gauss->weight*basis[i]*velobs/slope*(ds[0]*dlambda[0] + ds[1]*dlambda[1]);
245  _assert_(!xIsNan<IssmDouble>(ge[i]));
246  }
247  }
248  gradient->SetValues(numvertices,vertexpidlist,ge,ADD_VAL);
249 
250  /*Clean up and return*/
251  xDelete<IssmDouble>(ge);
252  xDelete<IssmDouble>(xyz_list);
253  xDelete<IssmDouble>(basis);
254  xDelete<int>(vertexpidlist);
255  delete gauss;
256 }/*}}}*/
257 void AdjointBalancethickness2Analysis::GradientJOmegaGradient(Element* element,Vector<IssmDouble>* gradient,int control_index){/*{{{*/
258 
259  /*Intermediaries*/
260  IssmDouble Jdet,weight;
261  IssmDouble dk[3];
262  IssmDouble *xyz_list= NULL;
263 
264  /*Fetch number of vertices for this finite element*/
265  int numvertices = element->GetNumberOfVertices();
266 
267  /*Initialize some vectors*/
268  IssmDouble* dbasis = xNew<IssmDouble>(2*numvertices);
269  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
270  int* vertexpidlist = xNew<int>(numvertices);
271 
272  /*Retrieve all inputs we will be needing: */
273  element->GetVerticesCoordinates(&xyz_list);
274  element->GradientIndexing(&vertexpidlist[0],control_index);
275  Input2* omega_input = element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
276  DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
277 
278  /* Start looping on the number of gaussian points: */
279  Gauss* gauss=element->NewGauss(2);
280  for(int ig=gauss->begin();ig<gauss->end();ig++){
281  gauss->GaussPoint(ig);
282 
283  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
284  element->NodalFunctionsP1Derivatives(dbasis,xyz_list,gauss);
285  weights_input->GetInputValue(&weight,gauss,OmegaAbsGradientEnum);
286 
287  /*Build alpha_complement_list: */
288  omega_input->GetInputDerivativeValue(&dk[0],xyz_list,gauss);
289 
290  /*Build gradient vector (actually -dJ/ddrag): */
291  for(int i=0;i<numvertices;i++){
292  ge[i]+=-weight*Jdet*gauss->weight*2*(dk[0]*dk[0] + dk[1]*dk[1])*(dbasis[0*numvertices+i]*dk[0]+dbasis[1*numvertices+i]*dk[1]);
293  _assert_(!xIsNan<IssmDouble>(ge[i]));
294  }
295  }
296  gradient->SetValues(numvertices,vertexpidlist,ge,ADD_VAL);
297 
298  /*Clean up and return*/
299  xDelete<IssmDouble>(xyz_list);
300  xDelete<IssmDouble>(dbasis);
301  xDelete<IssmDouble>(ge);
302  xDelete<int>(vertexpidlist);
303  delete gauss;
304 
305 }/*}}}*/
306 void AdjointBalancethickness2Analysis::GradientJEtaDiff(Element* element,Vector<IssmDouble>* gradient,int control_index){/*{{{*/
307 
308  /*Intermediaries*/
309  IssmDouble Jdet,weight;
310  IssmDouble omega,omega0;
311  IssmDouble *xyz_list= NULL;
312 
313  /*Fetch number of vertices for this finite element*/
314  int numvertices = element->GetNumberOfVertices();
315 
316  /*Initialize some vectors*/
317  IssmDouble* basis = xNew<IssmDouble>(numvertices);
318  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
319  int* vertexpidlist = xNew<int>(numvertices);
320 
321  /*Retrieve all inputs we will be needing: */
322  element->GetVerticesCoordinates(&xyz_list);
323  element->GradientIndexing(&vertexpidlist[0],control_index);
324  Input2* omega_input = element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
325  Input2* omega0_input = element->GetInput2(BalancethicknessOmega0Enum); _assert_(omega0_input);
326  DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
327 
328  /* Start looping on the number of gaussian points: */
329  Gauss* gauss=element->NewGauss(2);
330  for(int ig=gauss->begin();ig<gauss->end();ig++){
331  gauss->GaussPoint(ig);
332 
333  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
334  element->NodalFunctionsP1(basis,gauss);
335  weights_input->GetInputValue(&weight,gauss,EtaDiffEnum);
336 
337  /*Build alpha_complement_list: */
338  omega_input->GetInputValue(&omega,gauss);
339  omega0_input->GetInputValue(&omega0,gauss);
340 
341  /*Build gradient vector (actually -dJ/ddrag): */
342  for(int i=0;i<numvertices;i++){
343  ge[i]+=-weight*Jdet*gauss->weight*(omega - omega0)*basis[i];
344  _assert_(!xIsNan<IssmDouble>(ge[i]));
345  }
346  }
347  gradient->SetValues(numvertices,vertexpidlist,ge,ADD_VAL);
348 
349  /*Clean up and return*/
350  xDelete<IssmDouble>(xyz_list);
351  xDelete<IssmDouble>(basis);
352  xDelete<IssmDouble>(ge);
353  xDelete<int>(vertexpidlist);
354  delete gauss;
355 
356 }/*}}}*/
357 void AdjointBalancethickness2Analysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
358  element->InputUpdateFromSolutionOneDof(solution,AdjointEnum);
359 }/*}}}*/
360 void AdjointBalancethickness2Analysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
361  /*Default, do nothing*/
362  return;
363 }/*}}}*/
Balancethickness2Analysis
Definition: Balancethickness2Analysis.h:11
AdjointBalancethickness2Analysis::CreateConstraints
void CreateConstraints(Constraints *constraints, IoModel *iomodel)
Definition: AdjointBalancethickness2Analysis.cpp:9
AdjointBalancethickness2Analysis::CreateKMatrix
ElementMatrix * CreateKMatrix(Element *element)
Definition: AdjointBalancethickness2Analysis.cpp:39
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
Nodes
Declaration of Nodes class.
Definition: Nodes.h:19
DatasetInput2
Definition: DatasetInput2.h:14
AdjointBalancethickness2Analysis::GradientJOmegaGradient
void GradientJOmegaGradient(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:257
Element::GetNumberOfNodes
virtual int GetNumberOfNodes(void)=0
AdjointEnum
@ AdjointEnum
Definition: EnumDefinitions.h:464
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
SurfaceSlopeXEnum
@ SurfaceSlopeXEnum
Definition: EnumDefinitions.h:829
BalancethicknessThickeningRateEnum
@ BalancethicknessThickeningRateEnum
Definition: EnumDefinitions.h:474
AdjointBalancethickness2Analysis::CreateDVector
ElementVector * CreateDVector(Element *element)
Definition: AdjointBalancethickness2Analysis.cpp:32
AdjointBalancethickness2Analysis::GradientJ
void GradientJ(Vector< IssmDouble > *gradient, Element *element, int control_type, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:118
InversionCostFunctionsCoefficientsEnum
@ InversionCostFunctionsCoefficientsEnum
Definition: EnumDefinitions.h:629
Parameters
Declaration of Parameters class.
Definition: Parameters.h:18
ADD_VAL
@ ADD_VAL
Definition: toolkitsenums.h:14
Balancethickness2Analysis::CreateKMatrix
ElementMatrix * CreateKMatrix(Element *element)
Definition: Balancethickness2Analysis.cpp:68
Constraints
Declaration of Constraints class.
Definition: Constraints.h:13
Elements
Declaration of Elements class.
Definition: Elements.h:17
AdjointBalancethickness2Analysis::GradientJOmega
void GradientJOmega(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:200
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
AdjointBalancethickness2Analysis.h
: header file for generic external result object
DatasetInput2::GetInputValue
void GetInputValue(IssmDouble *pvalue, Gauss *gauss, int index)
Definition: DatasetInput2.cpp:199
Element::NodalFunctionsP1Derivatives
virtual void NodalFunctionsP1Derivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
Input2::GetInputDerivativeValue
virtual void GetInputDerivativeValue(IssmDouble *derivativevalues, IssmDouble *xyz_list, Gauss *gauss)
Definition: Input2.h:37
Element::GetInput2
virtual Input2 * GetInput2(int inputenum)=0
Element
Definition: Element.h:41
EtaDiffEnum
@ EtaDiffEnum
Definition: EnumDefinitions.h:569
Element::NodalFunctions
virtual void NodalFunctions(IssmDouble *basis, Gauss *gauss)=0
Element::GetDatasetInput2
virtual DatasetInput2 * GetDatasetInput2(int inputenum)
Definition: Element.h:250
AdjointBalancethickness2Analysis::CreatePVector
ElementVector * CreatePVector(Element *element)
Definition: AdjointBalancethickness2Analysis.cpp:47
Element::NodalFunctionsP1
virtual void NodalFunctionsP1(IssmDouble *basis, Gauss *gauss)=0
Element::NewElementVector
ElementVector * NewElementVector(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2505
BalancethicknessOmegaEnum
@ BalancethicknessOmegaEnum
Definition: EnumDefinitions.h:473
SurfaceAbsMisfitEnum
@ SurfaceAbsMisfitEnum
Definition: EnumDefinitions.h:817
Vector::SetValues
void SetValues(int ssize, int *list, doubletype *values, InsMode mode)
Definition: Vector.h:153
Element::NewGauss
virtual Gauss * NewGauss(void)=0
InversionCostFunctionsEnum
@ InversionCostFunctionsEnum
Definition: EnumDefinitions.h:211
Element::InputUpdateFromSolutionOneDof
virtual void InputUpdateFromSolutionOneDof(IssmDouble *solution, int inputenum)=0
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
OmegaAbsGradientEnum
@ OmegaAbsGradientEnum
Definition: EnumDefinitions.h:660
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
SurfaceEnum
@ SurfaceEnum
Definition: EnumDefinitions.h:823
InversionSurfaceObsEnum
@ InversionSurfaceObsEnum
Definition: EnumDefinitions.h:630
AdjointBalancethickness2Analysis::CreateJacobianMatrix
ElementMatrix * CreateJacobianMatrix(Element *element)
Definition: AdjointBalancethickness2Analysis.cpp:36
Inputs2
Declaration of Inputs class.
Definition: Inputs2.h:23
AdjointBalancethickness2Analysis::UpdateParameters
void UpdateParameters(Parameters *parameters, IoModel *iomodel, int solution_enum, int analysis_enum)
Definition: AdjointBalancethickness2Analysis.cpp:24
AdjointBalancethickness2Analysis::Core
void Core(FemModel *femmodel)
Definition: AdjointBalancethickness2Analysis.cpp:29
Input2
Definition: Input2.h:18
FemModel
Definition: FemModel.h:31
AdjointBalancethickness2Analysis::GradientJdHdt
void GradientJdHdt(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:157
Element::IsIceInElement
bool IsIceInElement()
Definition: Element.cpp:2021
Loads
Declaration of Loads class.
Definition: Loads.h:16
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Gauss::begin
virtual int begin(void)=0
AdjointBalancethickness2Analysis::CreateLoads
void CreateLoads(Loads *loads, IoModel *iomodel)
Definition: AdjointBalancethickness2Analysis.cpp:12
VxEnum
@ VxEnum
Definition: EnumDefinitions.h:846
BalancethicknessOmega0Enum
@ BalancethicknessOmega0Enum
Definition: EnumDefinitions.h:472
InversionNumCostFunctionsEnum
@ InversionNumCostFunctionsEnum
Definition: EnumDefinitions.h:224
Element::JacobianDeterminant
virtual void JacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)=0
Gauss::GaussPoint
virtual void GaussPoint(int ig)=0
AdjointBalancethickness2Analysis::GetSolutionFromInputs
void GetSolutionFromInputs(Vector< IssmDouble > *solution, Element *element)
Definition: AdjointBalancethickness2Analysis.cpp:115
AdjointBalancethickness2Analysis::GradientJEtaDiff
void GradientJEtaDiff(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:306
InversionVelObsEnum
@ InversionVelObsEnum
Definition: EnumDefinitions.h:632
AdjointBalancethickness2Analysis::UpdateElements
void UpdateElements(Elements *elements, Inputs2 *inputs2, IoModel *iomodel, int analysis_counter, int analysis_type)
Definition: AdjointBalancethickness2Analysis.cpp:21
SSAApproximationEnum
@ SSAApproximationEnum
Definition: EnumDefinitions.h:1255
AdjointBalancethickness2Analysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: AdjointBalancethickness2Analysis.cpp:15
AdjointBalancethickness2Analysis::UpdateConstraints
void UpdateConstraints(FemModel *femmodel)
Definition: AdjointBalancethickness2Analysis.cpp:360
ElementVector
Definition: ElementVector.h:20
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
IoModel
Definition: IoModel.h:48
Element::GetNumberOfVertices
virtual int GetNumberOfVertices(void)=0
AdjointBalancethickness2Analysis::DofsPerNode
int DofsPerNode(int **doflist, int domaintype, int approximation)
Definition: AdjointBalancethickness2Analysis.cpp:18
ElementMatrix
Definition: ElementMatrix.h:19
Vector< IssmDouble >
Element::GradientIndexing
void GradientIndexing(int *indexing, int control_index)
Definition: Element.cpp:1510
AdjointBalancethickness2Analysis::InputUpdateFromSolution
void InputUpdateFromSolution(IssmDouble *solution, Element *element)
Definition: AdjointBalancethickness2Analysis.cpp:357
Gauss
Definition: Gauss.h:8
Element::NodalFunctionsDerivatives
virtual void NodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
SurfaceSlopeYEnum
@ SurfaceSlopeYEnum
Definition: EnumDefinitions.h:830
femmodel
FemModel * femmodel
Definition: esmfbinders.cpp:16
Generated on Thu Jul 2 2020 08:09:14 for Ice Sheet System Model by   doxygen 1.8.19