MeltingAnalysis Class Reference

#include <MeltingAnalysis.h>

Inheritance diagram for MeltingAnalysis:

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 MeltingAnalysis.h.

Member Function Documentation

CreateConstraints()

void MeltingAnalysis::CreateConstraints ( Constraints *  constraints, IoModel *  iomodel  )

virtual

Implements Analysis.

Definition at line 8 of file MeltingAnalysis.cpp.

                                                                                {/*{{{*/
   /*No Constraints*/
}/*}}}*/

CreateLoads()

void MeltingAnalysis::CreateLoads ( Loads *  loads, IoModel *  iomodel  )

virtual

Implements Analysis.

Definition at line 11 of file MeltingAnalysis.cpp.

                                                               {/*{{{*/
 
   /*if 2d: Error*/
   if(iomodel->domaintype==Domain2DhorizontalEnum) _error_("2d meshes not supported yet");
 
   //create penalties for nodes: no node can have a temperature over the melting point
   iomodel->FetchData(1,"md.mesh.vertexonbase");
   CreateSingleNodeToElementConnectivity(iomodel);
 
   for(int i=0;i<iomodel->numberofvertices;i++){
      if(iomodel->my_vertices[i]){
         if (reCast<int>(iomodel->Data("md.mesh.vertexonbase")[i])){
            loads->AddObject(new Pengrid(i+1,i,iomodel));
         }
      }
   }
   iomodel->DeleteData(1,"md.mesh.vertexonbase");
 
}/*}}}*/

CreateNodes()

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

virtual

Implements Analysis.

Definition at line 30 of file MeltingAnalysis.cpp.

                                                                         {/*{{{*/
 
   if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
   ::CreateNodes(nodes,iomodel,MeltingAnalysisEnum,P1Enum);
   iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
}/*}}}*/

DofsPerNode()

int MeltingAnalysis::DofsPerNode ( int **  doflist, int  domaintype, int  approximation  )

virtual

Implements Analysis.

Definition at line 36 of file MeltingAnalysis.cpp.

                                                                               {/*{{{*/
   return 1;
}/*}}}*/

UpdateElements()

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

virtual

Implements Analysis.

Definition at line 39 of file MeltingAnalysis.cpp.

                                                                                                                               {/*{{{*/
 
   /*Now, is the model 3d? otherwise, do nothing: */
   if(iomodel->domaintype==Domain2DhorizontalEnum)return;
 
   /*Update elements: */
   int counter=0;
   for(int i=0;i<iomodel->numberofelements;i++){
      if(iomodel->my_elements[i]){
         Element* element=(Element*)elements->GetObjectByOffset(counter);
         element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
         counter++;
      }
   }
 
   /*Create inputs: */
   iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
   iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
   iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
   iomodel->FetchDataToInput(inputs2,elements,"md.solidearth.sealevel",SealevelEnum,0);
   iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
   if(iomodel->domaintype!=Domain2DhorizontalEnum){
      iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
      iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
   }
   iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
}/*}}}*/

UpdateParameters()

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

virtual

Implements Analysis.

Definition at line 66 of file MeltingAnalysis.cpp.

                                                                                                                 {/*{{{*/
}/*}}}*/

Core()

void MeltingAnalysis::Core ( FemModel *  femmodel )

virtual

Implements Analysis.

Definition at line 70 of file MeltingAnalysis.cpp.

                                                      {/*{{{*/
   _error_("not implemented");
}/*}}}*/

CreateDVector()

ElementVector * MeltingAnalysis::CreateDVector ( Element *  element )

virtual

Implements Analysis.

Definition at line 73 of file MeltingAnalysis.cpp.

                                                             {/*{{{*/
   /*Default, return NULL*/
   return NULL;
}/*}}}*/

CreateJacobianMatrix()

ElementMatrix * MeltingAnalysis::CreateJacobianMatrix ( Element *  element )

virtual

Implements Analysis.

Definition at line 77 of file MeltingAnalysis.cpp.

                                                                    {/*{{{*/
_error_("Not implemented");
}/*}}}*/

CreateKMatrix()

ElementMatrix * MeltingAnalysis::CreateKMatrix ( Element *  element )

virtual

Implements Analysis.

Definition at line 80 of file MeltingAnalysis.cpp.

                                                             {/*{{{*/
 
   /*Get basal element*/
   if(!element->IsOnBase()) return NULL;
   Element* basalelement = element->SpawnBasalElement();
 
   /*Intermediaries */
   IssmDouble  D,Jdet;
   IssmDouble *xyz_list  = NULL;
 
   /*Fetch number of nodes and dof for this finite element*/
   int numnodes = basalelement->GetNumberOfNodes();
 
   /*Initialize Element vector*/
   ElementMatrix* Ke    = basalelement->NewElementMatrix(NoneApproximationEnum);
   IssmDouble*    basis = xNew<IssmDouble>(numnodes);
 
   /*Retrieve all inputs and parameters*/
   basalelement->GetVerticesCoordinates(&xyz_list);
   IssmDouble latentheat   = element->FindParam(MaterialsLatentheatEnum);
   IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum);
 
   /* Start  looping on the number of gaussian points: */
   Gauss* gauss=basalelement->NewGauss(2);
   for(int ig=gauss->begin();ig<gauss->end();ig++){
      gauss->GaussPoint(ig);
 
      basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
      basalelement->NodalFunctions(basis,gauss);
      D=latentheat/heatcapacity*gauss->weight*Jdet;
 
      TripleMultiply(basis,1,numnodes,1,
               &D,1,1,0,
               basis,1,numnodes,0,
               &Ke->values[0],1);
   }
 
   /*Clean up and return*/
   xDelete<IssmDouble>(xyz_list);
   xDelete<IssmDouble>(basis);
   delete gauss;
   basalelement->DeleteMaterials(); delete basalelement;
   return Ke;
}/*}}}*/

CreatePVector()

ElementVector * MeltingAnalysis::CreatePVector ( Element *  element )

virtual

Implements Analysis.

Definition at line 124 of file MeltingAnalysis.cpp.

                                                             {/*{{{*/
   return NULL;
}/*}}}*/

GetSolutionFromInputs()

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

virtual

Implements Analysis.

Definition at line 127 of file MeltingAnalysis.cpp.

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

GradientJ()

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

virtual

Implements Analysis.

Definition at line 130 of file MeltingAnalysis.cpp.

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

InputUpdateFromSolution()

void MeltingAnalysis::InputUpdateFromSolution ( IssmDouble *  solution, Element *  element  )

virtual

Implements Analysis.

Definition at line 133 of file MeltingAnalysis.cpp.

                                                                                            {/*{{{*/
   element->InputUpdateFromSolutionOneDof(solution,BasalforcingsGroundediceMeltingRateEnum);
}/*}}}*/

UpdateConstraints()

void MeltingAnalysis::UpdateConstraints ( FemModel *  femmodel )

virtual

Implements Analysis.

Definition at line 136 of file MeltingAnalysis.cpp.

                                                                   {/*{{{*/
   /*Default, do nothing*/
   return;
}/*}}}*/

---

The documentation for this class was generated from the following files:

• src/c/analyses/MeltingAnalysis.h
• src/c/analyses/MeltingAnalysis.cpp