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

#include <AdjointBalancethicknessAnalysis.h>

Inheritance diagram for AdjointBalancethicknessAnalysis:
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 GradientJDirichlet (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void GradientJDhDt (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void GradientJVx (Element *element, Vector< IssmDouble > *gradient, int control_index)
 
void GradientJVy (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 AdjointBalancethicknessAnalysis.h.

Member Function Documentation

◆ CreateConstraints()

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

Implements Analysis.

Definition at line 9 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ CreateLoads()

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

Implements Analysis.

Definition at line 12 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ CreateNodes()

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

Implements Analysis.

Definition at line 15 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ DofsPerNode()

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

Implements Analysis.

Definition at line 18 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ UpdateElements()

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

Implements Analysis.

Definition at line 21 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ UpdateParameters()

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

Implements Analysis.

Definition at line 24 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ Core()

void AdjointBalancethicknessAnalysis::Core ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 29 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ CreateDVector()

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

Implements Analysis.

Definition at line 32 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ CreateJacobianMatrix()

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

Implements Analysis.

Definition at line 36 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ CreateKMatrix()

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

Implements Analysis.

Definition at line 39 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ CreatePVector()

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

Implements Analysis.

Definition at line 49 of file AdjointBalancethicknessAnalysis.cpp.

49  {/*{{{*/
50 
51  /*Intermediaries*/
52  int domaintype;
53  Element* basalelement;
54 
55  /*Get basal element*/
56  element->FindParam(&domaintype,DomainTypeEnum);
57  switch(domaintype){
58  case Domain2DhorizontalEnum:
59  basalelement = element;
60  break;
61  case Domain3DEnum:
62  if(!element->IsOnBase()) return NULL;
63  basalelement = element->SpawnBasalElement();
64  break;
65  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
66  }
67 
68  /*Intermediaries */
69  int num_responses,i;
70  IssmDouble dH[2];
71  IssmDouble vx,vy,vel,Jdet;
72  IssmDouble thickness,thicknessobs,weight;
73  int *responses = NULL;
74  IssmDouble *xyz_list = NULL;
75 
76  /*Fetch number of nodes and dof for this finite element*/
77  int numnodes = basalelement->GetNumberOfNodes();
78 
79  /*Initialize Element vector and vectors*/
80  ElementVector* pe = basalelement->NewElementVector(SSAApproximationEnum);
81  IssmDouble* basis = xNew<IssmDouble>(numnodes);
82  IssmDouble* dbasis = xNew<IssmDouble>(2*numnodes);
83 
84  /*Retrieve all inputs and parameters*/
85  basalelement->GetVerticesCoordinates(&xyz_list);
86  basalelement->FindParam(&num_responses,InversionNumCostFunctionsEnum);
87  basalelement->FindParam(&responses,NULL,InversionCostFunctionsEnum);
88  Input2* thickness_input = basalelement->GetInput2(ThicknessEnum); _assert_(thickness_input);
89  Input2* thicknessobs_input = basalelement->GetInput2(InversionThicknessObsEnum); _assert_(thicknessobs_input);
90  DatasetInput2* weights_input = basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
91  Input2* vx_input = basalelement->GetInput2(VxEnum); _assert_(vx_input);
92  Input2* vy_input = basalelement->GetInput2(VyEnum); _assert_(vy_input);
93 
94  /* Start looping on the number of gaussian points: */
95  Gauss* gauss=basalelement->NewGauss(2);
96  for(int ig=gauss->begin();ig<gauss->end();ig++){
97  gauss->GaussPoint(ig);
98 
99  basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
100  basalelement->NodalFunctions(basis,gauss);
101  basalelement->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
102 
103  thickness_input->GetInputValue(&thickness, gauss);
104  thickness_input->GetInputDerivativeValue(&dH[0],xyz_list,gauss);
105  thicknessobs_input->GetInputValue(&thicknessobs, gauss);
106 
107  /*Loop over all requested responses*/
108  for(int resp=0;resp<num_responses;resp++){
109  weights_input->GetInputValue(&weight,gauss,responses[resp]);
110 
111  switch(responses[resp]){
112  case ThicknessAbsMisfitEnum:
113  for(i=0;i<numnodes;i++) pe->values[i]+=(thicknessobs-thickness)*weight*Jdet*gauss->weight*basis[i];
114  break;
115  case ThicknessAbsGradientEnum:
116  for(i=0;i<numnodes;i++) pe->values[i]+= - weight*dH[0]*dbasis[0*numnodes+i]*Jdet*gauss->weight;
117  for(i=0;i<numnodes;i++) pe->values[i]+= - weight*dH[1]*dbasis[1*numnodes+i]*Jdet*gauss->weight;
118  break;
119  case ThicknessAlongGradientEnum:
120  vx_input->GetInputValue(&vx,gauss);
121  vy_input->GetInputValue(&vy,gauss);
122  vel = sqrt(vx*vx+vy*vy);
123  vx = vx/(vel+1.e-9);
124  vy = vy/(vel+1.e-9);
125  for(i=0;i<numnodes;i++) pe->values[i]+= - weight*(dH[0]*vx+dH[1]*vy)*(dbasis[0*numnodes+i]*vx+dbasis[1*numnodes+i]*vy)*Jdet*gauss->weight;
126  break;
127  case ThicknessAcrossGradientEnum:
128  vx_input->GetInputValue(&vx,gauss);
129  vy_input->GetInputValue(&vy,gauss);
130  vel = sqrt(vx*vx+vy*vy);
131  vx = vx/(vel+1.e-9);
132  vy = vy/(vel+1.e-9);
133  for(i=0;i<numnodes;i++) pe->values[i]+= - weight*(dH[0]*(-vy)+dH[1]*vx)*(dbasis[0*numnodes+i]*(-vy)+dbasis[1*numnodes+i]*vx)*Jdet*gauss->weight;
134  break;
135  case ThicknessPositiveEnum:
136  if(thickness<0){
137  for(i=0;i<numnodes;i++) pe->values[i]+= - weight*2*thickness*Jdet*gauss->weight*basis[i];
138  }
139  break;
140  default:
141  _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
142  }
143  }
144  }
145 
146  /*Clean up and return*/
147  xDelete<int>(responses);
148  xDelete<IssmDouble>(xyz_list);
149  xDelete<IssmDouble>(basis);
150  xDelete<IssmDouble>(dbasis);
151  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
152  delete gauss;
153  return pe;
154 }/*}}}*/

◆ GetSolutionFromInputs()

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

Implements Analysis.

Definition at line 155 of file AdjointBalancethicknessAnalysis.cpp.

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

◆ GradientJ()

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

Implements Analysis.

Definition at line 158 of file AdjointBalancethicknessAnalysis.cpp.

158  {/*{{{*/
159  /*The gradient of the cost function is calculated in 2 parts.
160  *
161  * dJ \partial J \partial lambda^T(KU-F)
162  * -- = ---------- + ------------------------
163  * dk \partial k \parial k
164  *
165  * */
166 
167  /*If on water, grad = 0: */
168  if(!element->IsIceInElement()) return;
169 
170  /*Get list of cost functions*/
171  int *responses = NULL;
172  int num_responses,resp;
173  element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
174  element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
175 
176  /*Check that control_type is supported*/
177  if(control_type!=VxEnum &&
178  control_type!=VyEnum &&
179  control_type!=BalancethicknessSpcthicknessEnum &&
180  control_type!=BalancethicknessThickeningRateEnum){
181  _error_("Control "<<EnumToStringx(control_type)<<" not supported");
182  }
183 
184  /*Deal with first part (partial derivative a J with respect to k)*/
185  for(resp=0;resp<num_responses;resp++) switch(responses[resp]){
186  case ThicknessAbsMisfitEnum: /*Nothing, \partial J/\partial k = 0*/ break;
187  case ThicknessAbsGradientEnum: /*Nothing, \partial J/\partial k = 0*/ break;
188  case ThicknessAlongGradientEnum: /*Nothing, \partial J/\partial k = 0*/ break;
189  case ThicknessAcrossGradientEnum: /*Nothing, \partial J/\partial k = 0*/ break;
190  case ThicknessPositiveEnum: /*Nothing, \partial J/\partial k = 0*/ break;
191  default: _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
192  }
193 
194  /*Deal with second term*/
195  switch(control_type){
196  case BalancethicknessSpcthicknessEnum: GradientJDirichlet(element,gradient,control_index); break;
197  case BalancethicknessThickeningRateEnum: GradientJDhDt(element,gradient,control_index); break;
198  case VxEnum: GradientJVx( element,gradient,control_index); break;
199  case VyEnum: GradientJVy( element,gradient,control_index); break;
200  default: _error_("control type not supported yet: " << EnumToStringx(control_type));
201  }
202 
203  /*Clean up and return*/
204  xDelete<int>(responses);
205 
206 }/*}}}*/

◆ GradientJDirichlet()

void AdjointBalancethicknessAnalysis::GradientJDirichlet ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 207 of file AdjointBalancethicknessAnalysis.cpp.

207  {/*{{{*/
208 
209  /*Fetch number of vertices for this finite element*/
210  int numvertices = element->GetNumberOfVertices();
211 
212  /*Initialize some vectors*/
213  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
214  IssmDouble* lambda = xNew<IssmDouble>(numvertices);
215  int* vertexpidlist = xNew<int>(numvertices);
216 
217  /*Retrieve all inputs we will be needing: */
218  element->GradientIndexing(&vertexpidlist[0],control_index);
219  element->GetInputListOnVertices(lambda,AdjointEnum);
220 
221  BalancethicknessAnalysis* analysis = new BalancethicknessAnalysis();
222  ElementMatrix* Ke = analysis->CreateKMatrix(element);
223  delete analysis;
224 
225  /*Transpose and return Ke*/
226  Ke->Transpose();
227  _assert_(Ke->nrows == numvertices && Ke->ncols == numvertices);
228 
229  for(int i=0;i<numvertices;i++){
230  for(int j=0;j<numvertices;j++){
231  ge[i] += Ke->values[i*Ke->ncols + j] * lambda[j];
232  }
233  //ge[i]=-lambda[i];
234  _assert_(!xIsNan<IssmDouble>(ge[i]));
235  }
236  gradient->SetValues(numvertices,vertexpidlist,ge,INS_VAL);
237 
238  /*Clean up and return*/
239  xDelete<IssmDouble>(ge);
240  xDelete<IssmDouble>(lambda);
241  xDelete<int>(vertexpidlist);
242  delete Ke;
243 }/*}}}*/

◆ GradientJDhDt()

void AdjointBalancethicknessAnalysis::GradientJDhDt ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 244 of file AdjointBalancethicknessAnalysis.cpp.

244  {/*{{{*/
245 
246  /*Fetch number of vertices for this finite element*/
247  int numvertices = element->GetNumberOfVertices();
248 
249  /*Initialize some vectors*/
250  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
251  IssmDouble* lambda = xNew<IssmDouble>(numvertices);
252  int* vertexpidlist = xNew<int>(numvertices);
253 
254  /*Retrieve all inputs we will be needing: */
255  element->GradientIndexing(&vertexpidlist[0],control_index);
256  element->GetInputListOnVertices(lambda,AdjointEnum);
257  for(int i=0;i<numvertices;i++){
258  ge[i]=-lambda[i];
259  _assert_(!xIsNan<IssmDouble>(ge[i]));
260  }
261  gradient->SetValues(numvertices,vertexpidlist,ge,INS_VAL);
262 
263  /*Clean up and return*/
264  xDelete<IssmDouble>(ge);
265  xDelete<IssmDouble>(lambda);
266  xDelete<int>(vertexpidlist);
267 }/*}}}*/

◆ GradientJVx()

void AdjointBalancethicknessAnalysis::GradientJVx ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 268 of file AdjointBalancethicknessAnalysis.cpp.

268  {/*{{{*/
269 
270  /*Intermediaries*/
271  IssmDouble thickness,Jdet,Dlambda[3],dp[3];
272  IssmDouble *xyz_list= NULL;
273 
274  /*Fetch number of vertices for this finite element*/
275  int numvertices = element->GetNumberOfVertices();
276 
277  /*Initialize some vectors*/
278  IssmDouble* basis = xNew<IssmDouble>(numvertices);
279  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
280  int* vertexpidlist = xNew<int>(numvertices);
281 
282  /*Retrieve all inputs we will be needing: */
283  element->GetVerticesCoordinates(&xyz_list);
284  element->GradientIndexing(&vertexpidlist[0],control_index);
285  Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
286  Input2* adjoint_input = element->GetInput2(AdjointEnum); _assert_(adjoint_input);
287 
288  /* Start looping on the number of gaussian points: */
289  Gauss* gauss=element->NewGauss(4);
290  for(int ig=gauss->begin();ig<gauss->end();ig++){
291  gauss->GaussPoint(ig);
292 
293  adjoint_input->GetInputDerivativeValue(&Dlambda[0],xyz_list,gauss);
294  thickness_input->GetInputValue(&thickness, gauss);
295  thickness_input->GetInputDerivativeValue(&dp[0],xyz_list,gauss);
296 
297  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
298  element->NodalFunctionsP1(basis,gauss);
299 
300  /*Build gradient vector (actually -dJ/dD): */
301  for(int i=0;i<numvertices;i++){
302  ge[i]+=thickness*Dlambda[0]*Jdet*gauss->weight*basis[i];
303  _assert_(!xIsNan<IssmDouble>(ge[i]));
304  }
305  }
306  gradient->SetValues(numvertices,vertexpidlist,ge,ADD_VAL);
307 
308  /*Clean up and return*/
309  xDelete<IssmDouble>(xyz_list);
310  xDelete<IssmDouble>(basis);
311  xDelete<IssmDouble>(ge);
312  xDelete<int>(vertexpidlist);
313  delete gauss;
314 }/*}}}*/

◆ GradientJVy()

void AdjointBalancethicknessAnalysis::GradientJVy ( Element *  element,
Vector< IssmDouble > *  gradient,
int  control_index 
)

Definition at line 315 of file AdjointBalancethicknessAnalysis.cpp.

315  {/*{{{*/
316 
317  /*Intermediaries*/
318  IssmDouble thickness,Jdet,Dlambda[3],dp[3];
319  IssmDouble *xyz_list= NULL;
320 
321  /*Fetch number of vertices for this finite element*/
322  int numvertices = element->GetNumberOfVertices();
323 
324  /*Initialize some vectors*/
325  IssmDouble* basis = xNew<IssmDouble>(numvertices);
326  IssmDouble* ge = xNewZeroInit<IssmDouble>(numvertices);
327  int* vertexpidlist = xNew<int>(numvertices);
328 
329  /*Retrieve all inputs we will be needing: */
330  element->GetVerticesCoordinates(&xyz_list);
331  element->GradientIndexing(&vertexpidlist[0],control_index);
332  Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
333  Input2* adjoint_input = element->GetInput2(AdjointEnum); _assert_(adjoint_input);
334 
335  /* Start looping on the number of gaussian points: */
336  Gauss* gauss=element->NewGauss(4);
337  for(int ig=gauss->begin();ig<gauss->end();ig++){
338  gauss->GaussPoint(ig);
339 
340  adjoint_input->GetInputDerivativeValue(&Dlambda[0],xyz_list,gauss);
341  thickness_input->GetInputValue(&thickness, gauss);
342  thickness_input->GetInputDerivativeValue(&dp[0],xyz_list,gauss);
343 
344  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
345  element->NodalFunctionsP1(basis,gauss);
346 
347  /*Build gradient vector (actually -dJ/dvy): */
348  for(int i=0;i<numvertices;i++){
349  ge[i]+=thickness*Dlambda[1]*Jdet*gauss->weight*basis[i];
350  _assert_(!xIsNan<IssmDouble>(ge[i]));
351  }
352  }
353  gradient->SetValues(numvertices,vertexpidlist,ge,ADD_VAL);
354 
355  /*Clean up and return*/
356  xDelete<IssmDouble>(xyz_list);
357  xDelete<IssmDouble>(basis);
358  xDelete<IssmDouble>(ge);
359  xDelete<int>(vertexpidlist);
360  delete gauss;
361 }/*}}}*/

◆ InputUpdateFromSolution()

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

Implements Analysis.

Definition at line 362 of file AdjointBalancethicknessAnalysis.cpp.

362  {/*{{{*/
363 
364  int domaintype;
365  element->FindParam(&domaintype,DomainTypeEnum);
366  switch(domaintype){
367  case Domain2DhorizontalEnum:
368  element->InputUpdateFromSolutionOneDof(solution,AdjointEnum);
369  break;
370  case Domain3DEnum:
371  element->InputUpdateFromSolutionOneDofCollapsed(solution,AdjointEnum);
372  break;
373  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
374  }
375 }/*}}}*/

◆ UpdateConstraints()

void AdjointBalancethicknessAnalysis::UpdateConstraints ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 376 of file AdjointBalancethicknessAnalysis.cpp.

376  {/*{{{*/
377  /*Default, do nothing*/
378  return;
379 }/*}}}*/
The documentation for this class was generated from the following files:
InversionThicknessObsEnum
@ InversionThicknessObsEnum
Definition: EnumDefinitions.h:631
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
DatasetInput2
Definition: DatasetInput2.h:14
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
BalancethicknessThickeningRateEnum
@ BalancethicknessThickeningRateEnum
Definition: EnumDefinitions.h:474
InversionCostFunctionsCoefficientsEnum
@ InversionCostFunctionsCoefficientsEnum
Definition: EnumDefinitions.h:629
ADD_VAL
@ ADD_VAL
Definition: toolkitsenums.h:14
Element::SpawnBasalElement
virtual Element * SpawnBasalElement(void)=0
ThicknessPositiveEnum
@ ThicknessPositiveEnum
Definition: EnumDefinitions.h:842
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
ElementMatrix::ncols
int ncols
Definition: ElementMatrix.h:24
DatasetInput2::GetInputValue
void GetInputValue(IssmDouble *pvalue, Gauss *gauss, int index)
Definition: DatasetInput2.cpp:199
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
AdjointBalancethicknessAnalysis::GradientJDhDt
void GradientJDhDt(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethicknessAnalysis.cpp:244
AdjointBalancethicknessAnalysis::GradientJVx
void GradientJVx(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethicknessAnalysis.cpp:268
BalancethicknessAnalysis
Definition: BalancethicknessAnalysis.h:11
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::DeleteMaterials
void DeleteMaterials(void)
Definition: Element.cpp:429
Element
Definition: Element.h:41
Element::NodalFunctions
virtual void NodalFunctions(IssmDouble *basis, Gauss *gauss)=0
Element::GetDatasetInput2
virtual DatasetInput2 * GetDatasetInput2(int inputenum)
Definition: Element.h:250
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
Element::NodalFunctionsP1
virtual void NodalFunctionsP1(IssmDouble *basis, Gauss *gauss)=0
Element::NewElementVector
ElementVector * NewElementVector(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2505
Vector::SetValues
void SetValues(int ssize, int *list, doubletype *values, InsMode mode)
Definition: Vector.h:153
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
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
ThicknessAlongGradientEnum
@ ThicknessAlongGradientEnum
Definition: EnumDefinitions.h:839
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
INS_VAL
@ INS_VAL
Definition: toolkitsenums.h:14
ThicknessAbsMisfitEnum
@ ThicknessAbsMisfitEnum
Definition: EnumDefinitions.h:837
ElementMatrix::Transpose
void Transpose(void)
Definition: ElementMatrix.cpp:502
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
AdjointBalancethicknessAnalysis::GradientJDirichlet
void GradientJDirichlet(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethicknessAnalysis.cpp:207
Input2
Definition: Input2.h:18
ElementMatrix::nrows
int nrows
Definition: ElementMatrix.h:23
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
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
ThicknessEnum
@ ThicknessEnum
Definition: EnumDefinitions.h:840
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
BalancethicknessAnalysis::CreateKMatrix
ElementMatrix * CreateKMatrix(Element *element)
Definition: BalancethicknessAnalysis.cpp:129
ThicknessAbsGradientEnum
@ ThicknessAbsGradientEnum
Definition: EnumDefinitions.h:836
Element::GetNumberOfVertices
virtual int GetNumberOfVertices(void)=0
Element::GetInputListOnVertices
void GetInputListOnVertices(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1131
ElementMatrix
Definition: ElementMatrix.h:19
Element::GradientIndexing
void GradientIndexing(int *indexing, int control_index)
Definition: Element.cpp:1510
Element::InputUpdateFromSolutionOneDofCollapsed
virtual void InputUpdateFromSolutionOneDofCollapsed(IssmDouble *solution, int inputenum)=0
BalancethicknessSpcthicknessEnum
@ BalancethicknessSpcthicknessEnum
Definition: EnumDefinitions.h:986
Gauss
Definition: Gauss.h:8
AdjointBalancethicknessAnalysis::GradientJVy
void GradientJVy(Element *element, Vector< IssmDouble > *gradient, int control_index)
Definition: AdjointBalancethicknessAnalysis.cpp:315
Element::NodalFunctionsDerivatives
virtual void NodalFunctionsDerivatives(IssmDouble *dbasis, IssmDouble *xyz_list, Gauss *gauss)=0
ElementMatrix::values
IssmDouble * values
Definition: ElementMatrix.h:26
ThicknessAcrossGradientEnum
@ ThicknessAcrossGradientEnum
Definition: EnumDefinitions.h:838
Generated on Thu Jul 2 2020 08:09:26 for Ice Sheet System Model by   doxygen 1.8.19