Ice Sheet System Model  4.18
Code documentation
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Public Member Functions
AdjointBalancethickness2Analysis Class Reference

#include <AdjointBalancethickness2Analysis.h>

Inheritance diagram for AdjointBalancethickness2Analysis:
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 GradientJ (Vector< IssmDouble > *gradient, Element *element, int control_type, int control_index)
 
void GradientJdHdt (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void GradientJOmega (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void GradientJOmegaGradient (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void GradientJEtaDiff (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void InputUpdateFromSolution (IssmDouble *solution, Element *element)
 
void UpdateConstraints (FemModel *femmodel)
 
- Public Member Functions inherited from Analysis
virtual ~Analysis ()
 

Detailed Description

Definition at line 11 of file AdjointBalancethickness2Analysis.h.

Member Function Documentation

◆ CreateConstraints()

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

Implements Analysis.

Definition at line 9 of file AdjointBalancethickness2Analysis.cpp.

9  {/*{{{*/
10  _error_("not implemented yet");
11 }/*}}}*/

◆ CreateLoads()

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

Implements Analysis.

Definition at line 12 of file AdjointBalancethickness2Analysis.cpp.

12  {/*{{{*/
13  _error_("not implemented yet");
14 }/*}}}*/

◆ CreateNodes()

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

Implements Analysis.

Definition at line 15 of file AdjointBalancethickness2Analysis.cpp.

15  {/*{{{*/
16  _error_("not implemented yet");
17 }/*}}}*/

◆ DofsPerNode()

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

Implements Analysis.

Definition at line 18 of file AdjointBalancethickness2Analysis.cpp.

18  {/*{{{*/
19  return 1;
20 }/*}}}*/

◆ UpdateElements()

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

Implements Analysis.

Definition at line 21 of file AdjointBalancethickness2Analysis.cpp.

21  {/*{{{*/
22  _error_("not implemented yet");
23 }/*}}}*/

◆ UpdateParameters()

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

Implements Analysis.

Definition at line 24 of file AdjointBalancethickness2Analysis.cpp.

24  {/*{{{*/
25  _error_("not implemented yet");
26 }/*}}}*/

◆ Core()

void AdjointBalancethickness2Analysis::Core ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 29 of file AdjointBalancethickness2Analysis.cpp.

29  {/*{{{*/
30  _error_("not implemented");
31 }/*}}}*/

◆ CreateDVector()

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

Implements Analysis.

Definition at line 32 of file AdjointBalancethickness2Analysis.cpp.

32  {/*{{{*/
33  /*Default, return NULL*/
34  return NULL;
35 }/*}}}*/

◆ CreateJacobianMatrix()

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

Implements Analysis.

Definition at line 36 of file AdjointBalancethickness2Analysis.cpp.

36  {/*{{{*/
37 _error_("Not implemented");
38 }/*}}}*/

◆ CreateKMatrix()

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

Implements Analysis.

Definition at line 39 of file AdjointBalancethickness2Analysis.cpp.

39  {/*{{{*/
40 
41  Balancethickness2Analysis* analysis = new Balancethickness2Analysis();
42  ElementMatrix* Ke = analysis->CreateKMatrix(element);
43  delete analysis;
44 
45  return Ke;
46 }/*}}}*/

◆ CreatePVector()

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

Implements Analysis.

Definition at line 47 of file AdjointBalancethickness2Analysis.cpp.

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

◆ GetSolutionFromInputs()

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

Implements Analysis.

Definition at line 115 of file AdjointBalancethickness2Analysis.cpp.

115  {/*{{{*/
116  _error_("not implemented yet");
117 }/*}}}*/

◆ GradientJ()

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

Implements Analysis.

Definition at line 118 of file AdjointBalancethickness2Analysis.cpp.

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

◆ GradientJdHdt()

void AdjointBalancethickness2Analysis::GradientJdHdt ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 157 of file AdjointBalancethickness2Analysis.cpp.

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

◆ GradientJOmega()

void AdjointBalancethickness2Analysis::GradientJOmega ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 200 of file AdjointBalancethickness2Analysis.cpp.

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

◆ GradientJOmegaGradient()

void AdjointBalancethickness2Analysis::GradientJOmegaGradient ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 257 of file AdjointBalancethickness2Analysis.cpp.

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

◆ GradientJEtaDiff()

void AdjointBalancethickness2Analysis::GradientJEtaDiff ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 306 of file AdjointBalancethickness2Analysis.cpp.

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

◆ InputUpdateFromSolution()

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

Implements Analysis.

Definition at line 357 of file AdjointBalancethickness2Analysis.cpp.

357  {/*{{{*/
358  element->InputUpdateFromSolutionOneDof(solution,AdjointEnum);
359 }/*}}}*/

◆ UpdateConstraints()

void AdjointBalancethickness2Analysis::UpdateConstraints ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 360 of file AdjointBalancethickness2Analysis.cpp.

360  {/*{{{*/
361  /*Default, do nothing*/
362  return;
363 }/*}}}*/
The documentation for this class was generated from the following files:
Balancethickness2Analysis
Definition: Balancethickness2Analysis.h:11
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
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
InversionCostFunctionsCoefficientsEnum
@ InversionCostFunctionsCoefficientsEnum
Definition: EnumDefinitions.h:629
ADD_VAL
@ ADD_VAL
Definition: toolkitsenums.h:14
Balancethickness2Analysis::CreateKMatrix
ElementMatrix * CreateKMatrix(Element *element)
Definition: Balancethickness2Analysis.cpp:68
AdjointBalancethickness2Analysis::GradientJOmega
void GradientJOmega(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:200
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
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
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
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
Input2
Definition: Input2.h:18
AdjointBalancethickness2Analysis::GradientJdHdt
void GradientJdHdt(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:157
Element::IsIceInElement
bool IsIceInElement()
Definition: Element.cpp:2021
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Gauss::begin
virtual int begin(void)=0
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::GradientJEtaDiff
void GradientJEtaDiff(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethickness2Analysis.cpp:306
InversionVelObsEnum
@ InversionVelObsEnum
Definition: EnumDefinitions.h:632
SSAApproximationEnum
@ SSAApproximationEnum
Definition: EnumDefinitions.h:1255
ElementVector
Definition: ElementVector.h:20
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
Element::GetNumberOfVertices
virtual int GetNumberOfVertices(void)=0
ElementMatrix
Definition: ElementMatrix.h:19
Element::GradientIndexing
void GradientIndexing(int *indexing, int control_index)
Definition: Element.cpp:1510
Gauss
Definition: Gauss.h:8
Element::NodalFunctionsDerivatives
virtual void NodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
SurfaceSlopeYEnum
@ SurfaceSlopeYEnum
Definition: EnumDefinitions.h:830
Generated on Thu Jul 2 2020 08:09:26 for Ice Sheet System Model by   doxygen 1.8.19