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

#include <L2ProjectionBaseAnalysis.h>

Inheritance diagram for L2ProjectionBaseAnalysis:
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 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 L2ProjectionBaseAnalysis.h.

Member Function Documentation

◆ CreateConstraints()

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

Implements Analysis.

Definition at line 8 of file L2ProjectionBaseAnalysis.cpp.

8  {/*{{{*/
9 
10  /*No constraints*/
11 }/*}}}*/

◆ CreateLoads()

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

Implements Analysis.

Definition at line 12 of file L2ProjectionBaseAnalysis.cpp.

12  {/*{{{*/
13 
14  /*No loads*/
15 }/*}}}*/

◆ CreateNodes()

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

Implements Analysis.

Definition at line 16 of file L2ProjectionBaseAnalysis.cpp.

16  {/*{{{*/
17 
18  if(iomodel->domaintype==Domain3DEnum){
19  iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
20  }
21  else if(iomodel->domaintype==Domain2DverticalEnum){
22  iomodel->FetchData(1,"md.mesh.vertexonbase");
23  }
24  ::CreateNodes(nodes,iomodel,L2ProjectionBaseAnalysisEnum,P1Enum);
25  iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
26 }/*}}}*/

◆ DofsPerNode()

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

Implements Analysis.

Definition at line 27 of file L2ProjectionBaseAnalysis.cpp.

27  {/*{{{*/
28  return 1;
29 }/*}}}*/

◆ UpdateElements()

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

Implements Analysis.

Definition at line 30 of file L2ProjectionBaseAnalysis.cpp.

30  {/*{{{*/
31 
32  /*Update elements: */
33  int counter=0;
34  for(int i=0;i<iomodel->numberofelements;i++){
35  if(iomodel->my_elements[i]){
36  Element* element=(Element*)elements->GetObjectByOffset(counter);
37  element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
38  counter++;
39  }
40  }
41 
42  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
43  iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
44  iomodel->FetchDataToInput(inputs2,elements,"md.solidearth.sealevel",SealevelEnum,0);
45  iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
46  if(iomodel->domaintype!=Domain2DhorizontalEnum & iomodel->domaintype!=Domain3DsurfaceEnum){
47  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
48  iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
49  }
50 }/*}}}*/

◆ UpdateParameters()

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

Implements Analysis.

Definition at line 51 of file L2ProjectionBaseAnalysis.cpp.

51  {/*{{{*/
52 }/*}}}*/

◆ Core()

void L2ProjectionBaseAnalysis::Core ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 55 of file L2ProjectionBaseAnalysis.cpp.

55  {/*{{{*/
56  _error_("not implemented");
57 }/*}}}*/

◆ CreateDVector()

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

Implements Analysis.

Definition at line 58 of file L2ProjectionBaseAnalysis.cpp.

58  {/*{{{*/
59  /*Default, return NULL*/
60  return NULL;
61 }/*}}}*/

◆ CreateJacobianMatrix()

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

Implements Analysis.

Definition at line 62 of file L2ProjectionBaseAnalysis.cpp.

62  {/*{{{*/
63 _error_("Not implemented");
64 }/*}}}*/

◆ CreateKMatrix()

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

Implements Analysis.

Definition at line 65 of file L2ProjectionBaseAnalysis.cpp.

65  {/*{{{*/
66 
67  /*Intermediaries*/
68  int domaintype;
69  Element* basalelement;
70 
71  /*Get basal element*/
72  element->FindParam(&domaintype,DomainTypeEnum);
73  switch(domaintype){
74  case Domain2DhorizontalEnum:
75  basalelement = element;
76  break;
77  case Domain2DverticalEnum:
78  if(!element->IsOnBase()) return NULL;
79  basalelement = element->SpawnBasalElement();
80  break;
81  case Domain3DEnum:
82  if(!element->IsOnBase()) return NULL;
83  basalelement = element->SpawnBasalElement();
84  break;
85  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
86  }
87 
88  /*Intermediaries */
89  IssmDouble D,Jdet;
90  IssmDouble *xyz_list = NULL;
91 
92  /*Fetch number of nodes and dof for this finite element*/
93  int numnodes = basalelement->GetNumberOfNodes();
94 
95  /*Initialize Element vector*/
96  ElementMatrix* Ke = basalelement->NewElementMatrix();
97  IssmDouble* basis = xNew<IssmDouble>(numnodes);
98 
99  /*Retrieve all inputs and parameters*/
100  basalelement->GetVerticesCoordinates(&xyz_list);
101 
102  /* Start looping on the number of gaussian points: */
103  Gauss* gauss=basalelement->NewGauss(2);
104  for(int ig=gauss->begin();ig<gauss->end();ig++){
105  gauss->GaussPoint(ig);
106 
107  basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
108  basalelement->NodalFunctions(basis,gauss);
109  D=gauss->weight*Jdet;
110 
111  TripleMultiply(basis,1,numnodes,1,
112  &D,1,1,0,
113  basis,1,numnodes,0,
114  &Ke->values[0],1);
115  }
116 
117  /*Clean up and return*/
118  xDelete<IssmDouble>(xyz_list);
119  xDelete<IssmDouble>(basis);
120  delete gauss;
121  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
122  return Ke;
123 }/*}}}*/

◆ CreatePVector()

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

Implements Analysis.

Definition at line 124 of file L2ProjectionBaseAnalysis.cpp.

124  {/*{{{*/
125 
126  /*Intermediaries*/
127  int domaintype;
128  Element* basalelement;
129 
130  /*Get basal element*/
131  element->FindParam(&domaintype,DomainTypeEnum);
132  switch(domaintype){
133  case Domain2DhorizontalEnum:
134  basalelement = element;
135  break;
136  case Domain2DverticalEnum:
137  if(!element->IsOnBase()) return NULL;
138  basalelement = element->SpawnBasalElement();
139  break;
140  case Domain3DEnum:
141  if(!element->IsOnBase()) return NULL;
142  basalelement = element->SpawnBasalElement();
143  break;
144  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
145  }
146 
147  /*Intermediaries */
148  int input_enum;
149  IssmDouble Jdet,value,slopes[2];
150  Input2 *input = NULL;
151  Input2 *input2 = NULL;
152  IssmDouble *xyz_list = NULL;
153 
154  /*Fetch number of nodes and dof for this finite element*/
155  int numnodes = basalelement->GetNumberOfNodes();
156 
157  /*Initialize Element vector*/
158  ElementVector* pe = basalelement->NewElementVector();
159  IssmDouble* basis = xNew<IssmDouble>(numnodes);
160 
161  /*Retrieve all inputs and parameters*/
162  basalelement->GetVerticesCoordinates(&xyz_list);
163  basalelement->FindParam(&input_enum,InputToL2ProjectEnum);
164  switch(input_enum){
165  case SurfaceSlopeXEnum: input2 = basalelement->GetInput2(SurfaceEnum); _assert_(input2); break;
166  case SurfaceSlopeYEnum: input2 = basalelement->GetInput2(SurfaceEnum); _assert_(input2); break;
167  case BedSlopeXEnum: input2 = basalelement->GetInput2(BaseEnum); _assert_(input2); break;
168  case BedSlopeYEnum: input2 = basalelement->GetInput2(BaseEnum); _assert_(input2); break;
169  case BaseSlopeXEnum: input2 = basalelement->GetInput2(BaseEnum); _assert_(input2); break;
170  case BaseSlopeYEnum: input2 = basalelement->GetInput2(BaseEnum); _assert_(input2); break;
171  case LevelsetfunctionSlopeXEnum: input2 = basalelement->GetInput2(MaskIceLevelsetEnum); _assert_(input2); break;
172  case LevelsetfunctionSlopeYEnum: input2 = basalelement->GetInput2(MaskIceLevelsetEnum); _assert_(input2); break;
173  default: input = element->GetInput2(input_enum);
174  }
175 
176  /* Start looping on the number of gaussian points: */
177  Gauss* gauss=basalelement->NewGauss(2);
178  for(int ig=gauss->begin();ig<gauss->end();ig++){
179  gauss->GaussPoint(ig);
180 
181  basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
182  basalelement->NodalFunctions(basis,gauss);
183 
184  if(input2) input2->GetInputDerivativeValue(&slopes[0],xyz_list,gauss);
185  switch(input_enum){
186  case SurfaceSlopeXEnum: case BedSlopeXEnum: case BaseSlopeXEnum: case LevelsetfunctionSlopeXEnum: value = slopes[0]; break;
187  case SurfaceSlopeYEnum: case BedSlopeYEnum: case BaseSlopeYEnum: case LevelsetfunctionSlopeYEnum: value = slopes[1]; break;
188  default: input->GetInputValue(&value,gauss);
189  }
190 
191  for(int i=0;i<numnodes;i++) pe->values[i]+=Jdet*gauss->weight*value*basis[i];
192  }
193 
194  /*Clean up and return*/
195  xDelete<IssmDouble>(xyz_list);
196  xDelete<IssmDouble>(basis);
197  delete gauss;
198  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
199  return pe;
200 }/*}}}*/

◆ GetSolutionFromInputs()

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

Implements Analysis.

Definition at line 201 of file L2ProjectionBaseAnalysis.cpp.

201  {/*{{{*/
202  _error_("not implemented yet");
203 }/*}}}*/

◆ GradientJ()

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

Implements Analysis.

Definition at line 204 of file L2ProjectionBaseAnalysis.cpp.

204  {/*{{{*/
205  _error_("Not implemented yet");
206 }/*}}}*/

◆ InputUpdateFromSolution()

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

Implements Analysis.

Definition at line 207 of file L2ProjectionBaseAnalysis.cpp.

207  {/*{{{*/
208 
209  int inputenum,domaintype,elementtype;
210 
211  element->FindParam(&inputenum,InputToL2ProjectEnum);
212  element->FindParam(&domaintype,DomainTypeEnum);
213  element->FindParam(&elementtype,MeshElementtypeEnum);
214  switch(domaintype){
215  case Domain2DhorizontalEnum:
216  element->InputUpdateFromSolutionOneDof(solution,inputenum);
217  break;
218  case Domain2DverticalEnum:
219  element->InputUpdateFromSolutionOneDof(solution,inputenum);
220  break;
221  case Domain3DEnum:
222  if(elementtype==TetraEnum)
223  element->InputUpdateFromSolutionOneDof(solution,inputenum);
224  else
225  element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum);
226  break;
227  default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
228  }
229 }/*}}}*/

◆ UpdateConstraints()

void L2ProjectionBaseAnalysis::UpdateConstraints ( FemModel *  femmodel)
virtual

Implements Analysis.

Definition at line 230 of file L2ProjectionBaseAnalysis.cpp.

230  {/*{{{*/
231  /*Default, do nothing*/
232  return;
233 }/*}}}*/
The documentation for this class was generated from the following files:
BaseEnum
@ BaseEnum
Definition: EnumDefinitions.h:495
L2ProjectionBaseAnalysis::CreateNodes
void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)
Definition: L2ProjectionBaseAnalysis.cpp:16
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
TetraEnum
@ TetraEnum
Definition: EnumDefinitions.h:1300
Element::GetNumberOfNodes
virtual int GetNumberOfNodes(void)=0
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
SurfaceSlopeXEnum
@ SurfaceSlopeXEnum
Definition: EnumDefinitions.h:829
LevelsetfunctionSlopeXEnum
@ LevelsetfunctionSlopeXEnum
Definition: EnumDefinitions.h:635
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
LevelsetfunctionSlopeYEnum
@ LevelsetfunctionSlopeYEnum
Definition: EnumDefinitions.h:636
Element::SpawnBasalElement
virtual Element * SpawnBasalElement(void)=0
MeshVertexonbaseEnum
@ MeshVertexonbaseEnum
Definition: EnumDefinitions.h:653
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
ElementVector::values
IssmDouble * values
Definition: ElementVector.h:24
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
BedSlopeXEnum
@ BedSlopeXEnum
Definition: EnumDefinitions.h:500
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
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
Element::NewElementVector
ElementVector * NewElementVector(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2505
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
L2ProjectionBaseAnalysisEnum
@ L2ProjectionBaseAnalysisEnum
Definition: EnumDefinitions.h:1136
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
Element::NewGauss
virtual Gauss * NewGauss(void)=0
Element::InputUpdateFromSolutionOneDof
virtual void InputUpdateFromSolutionOneDof(IssmDouble *solution, int inputenum)=0
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
Domain3DsurfaceEnum
@ Domain3DsurfaceEnum
Definition: EnumDefinitions.h:1039
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
MeshElementtypeEnum
@ MeshElementtypeEnum
Definition: EnumDefinitions.h:271
SurfaceEnum
@ SurfaceEnum
Definition: EnumDefinitions.h:823
IoModel::FetchData
void FetchData(bool *pboolean, const char *data_name)
Definition: IoModel.cpp:933
BaseSlopeXEnum
@ BaseSlopeXEnum
Definition: EnumDefinitions.h:497
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
BaseSlopeYEnum
@ BaseSlopeYEnum
Definition: EnumDefinitions.h:498
Input2
Definition: Input2.h:18
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Gauss::begin
virtual int begin(void)=0
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
MeshVertexonsurfaceEnum
@ MeshVertexonsurfaceEnum
Definition: EnumDefinitions.h:655
Element::JacobianDeterminant
virtual void JacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)=0
Gauss::GaussPoint
virtual void GaussPoint(int ig)=0
Element::Update
virtual void Update(Inputs2 *inputs2, int index, IoModel *iomodel, int analysis_counter, int analysis_type, int finite_element)=0
IoModel::FetchDataToInput
void FetchDataToInput(Inputs2 *inputs2, Elements *elements, const char *vector_name, int input_enum)
Definition: IoModel.cpp:1651
InputToL2ProjectEnum
@ InputToL2ProjectEnum
Definition: EnumDefinitions.h:206
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::domaintype
int domaintype
Definition: IoModel.h:78
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
ElementMatrix
Definition: ElementMatrix.h:19
Element::InputUpdateFromSolutionOneDofCollapsed
virtual void InputUpdateFromSolutionOneDofCollapsed(IssmDouble *solution, int inputenum)=0
Gauss
Definition: Gauss.h:8
BedSlopeYEnum
@ BedSlopeYEnum
Definition: EnumDefinitions.h:501
ElementMatrix::values
IssmDouble * values
Definition: ElementMatrix.h:26
SurfaceSlopeYEnum
@ SurfaceSlopeYEnum
Definition: EnumDefinitions.h:830
Element::NewElementMatrix
ElementMatrix * NewElementMatrix(int approximation_enum=NoneApproximationEnum)
Definition: Element.cpp:2497
Generated on Thu Jul 2 2020 08:09:28 for Ice Sheet System Model by   doxygen 1.8.19