Pengrid Class Reference

#include <Pengrid.h>

Inheritance diagram for Pengrid:

Public Member Functions
	Pengrid ()
	Pengrid (int id, int index, IoModel *iomodel)
	~Pengrid ()
Object *	copy ()
void	DeepEcho ()
void	Echo ()
int	Id ()
void	Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
int	ObjectEnum ()
void	Configure (Elements *elements, Loads *loads, Nodes *nodes, Vertices *vertices, Materials *materials, Parameters *parameters)
void	CreateJacobianMatrix (Matrix< IssmDouble > *Jff)
void	CreateKMatrix (Matrix< IssmDouble > *Kff, Matrix< IssmDouble > *Kfs)
void	CreatePVector (Vector< IssmDouble > *pf)
void	GetNodesLidList (int *lidlist)
void	GetNodesSidList (int *sidlist)
int	GetNumberOfNodes (void)
bool	IsPenalty (void)
void	PenaltyCreateJacobianMatrix (Matrix< IssmDouble > *Jff, IssmDouble kmax)
void	PenaltyCreateKMatrix (Matrix< IssmDouble > *Kff, Matrix< IssmDouble > *kfs, IssmDouble kmax)
void	PenaltyCreatePVector (Vector< IssmDouble > *pf, IssmDouble kmax)
void	ResetHooks ()
void	SetCurrentConfiguration (Elements *elements, Loads *loads, Nodes *nodes, Vertices *vertices, Materials *materials, Parameters *parameters)
void	SetwiseNodeConnectivity (int *d_nz, int *o_nz, Node *node, bool *flags, int *flagsindices, int set1_enum, int set2_enum)
void	ConstraintActivate (int *punstable)
void	ConstraintActivateHydrologyDCInefficient (int *punstable)
void	ConstraintActivateThermal (int *punstable)
ElementMatrix *	PenaltyCreateKMatrixHydrologyDCInefficient (IssmDouble kmax)
ElementMatrix *	PenaltyCreateKMatrixMelting (IssmDouble kmax)
ElementMatrix *	PenaltyCreateKMatrixThermal (IssmDouble kmax)
ElementVector *	PenaltyCreatePVectorHydrologyDCInefficient (IssmDouble kmax)
ElementVector *	PenaltyCreatePVectorMelting (IssmDouble kmax)
ElementVector *	PenaltyCreatePVectorThermal (IssmDouble kmax)
void	ResetConstraint (void)
void	ResetZigzagCounter (void)
Public Member Functions inherited from Load
virtual	~Load ()
Public Member Functions inherited from Object
virtual	~Object ()

Private Attributes
int	id
Hook *	hnode
Hook *	helement
Node *	node
Element *	element
Parameters *	parameters
int	active
int	zigzag_counter

Detailed Description

Definition at line 21 of file Pengrid.h.

Constructor & Destructor Documentation

Pengrid() [1/2]

Pengrid::Pengrid

(

)

Definition at line 22 of file Pengrid.cpp.

                {/*{{{*/
   this->parameters=NULL;
   this->hnode=NULL;
   this->node=NULL;
   this->helement=NULL;
   this->element=NULL;
 
   /*not active, not zigzagging: */
   active=0;
   zigzag_counter=0;
 
}

Pengrid() [2/2]

Pengrid::Pengrid	(	int	id,
		int	index,
		IoModel *	iomodel
	)

Definition at line 35 of file Pengrid.cpp.

                                                   {/*{{{*/
 
   int pengrid_node_id;
   int pengrid_element_id;
 
   /*Some checks if debugging activated*/
   _assert_(iomodel->singlenodetoelementconnectivity);
   _assert_(index>=0 && index<iomodel->numberofvertices);
   _assert_(id);
 
   /*id: */
   this->id=id;
 
   /*hooks: */
   pengrid_node_id=index+1;
   pengrid_element_id=iomodel->singlenodetoelementconnectivity[index];
   _assert_(pengrid_element_id);
 
   this->hnode=new Hook(&pengrid_node_id,1);
   this->helement=new Hook(&pengrid_element_id,1);
 
   //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
   this->parameters=NULL;
   this->node=NULL;
   this->element=NULL;
 
   //let's not forget internals
   this->active=0;
   this->zigzag_counter=0;
 
}

~Pengrid()

Pengrid::~Pengrid

(

)

Definition at line 67 of file Pengrid.cpp.

                 {/*{{{*/
   delete hnode;
   delete helement;
   return;
}

Member Function Documentation

copy()

Object * Pengrid::copy ( void  )

virtual

Implements Object.

Definition at line 75 of file Pengrid.cpp.

                      {/*{{{*/
 
   Pengrid* pengrid=NULL;
 
   pengrid=new Pengrid();
 
   /*copy fields: */
   pengrid->id=this->id;
 
   /*point parameters: */
   pengrid->parameters=this->parameters;
 
   /*now deal with hooks and objects: */
   pengrid->hnode=(Hook*)this->hnode->copy();
   pengrid->helement=(Hook*)this->helement->copy();
 
   /*corresponding fields*/
   pengrid->node  =(Node*)pengrid->hnode->delivers();
   pengrid->element=(Element*)pengrid->helement->delivers();
 
   //let's not forget internals
   pengrid->active=this->active=0;
   pengrid->zigzag_counter=this->zigzag_counter=0;
 
   return pengrid;
 
}

DeepEcho()

void Pengrid::DeepEcho ( void  )

virtual

Implements Object.

Definition at line 103 of file Pengrid.cpp.

                             {/*{{{*/
 
   _printf_("Pengrid:\n");
   _printf_("   id: " << id << "\n");
   hnode->DeepEcho();
   helement->DeepEcho();
   _printf_("   active " << this->active << "\n");
   _printf_("   zigzag_counter " << this->zigzag_counter << "\n");
   _printf_("   parameters\n");
   parameters->DeepEcho();
}

Echo()

void Pengrid::Echo ( void  )

virtual

Implements Object.

Definition at line 115 of file Pengrid.cpp.

                         {/*{{{*/
   this->DeepEcho();
}

Id()

int Pengrid::Id ( void  )

virtual

Implements Object.

Definition at line 119 of file Pengrid.cpp.

{ return id; }/*{{{*/

Marshall()

void Pengrid::Marshall ( char **  pmarshalled_data, int *  pmarshalled_data_size, int  marshall_direction  )

virtual

Implements Object.

Definition at line 121 of file Pengrid.cpp.

                                                                                                   { /*{{{*/
 
   _assert_(this);
 
   /*ok, marshall operations: */
   MARSHALLING_ENUM(PengridEnum);
   MARSHALLING(id);
 
   if(marshall_direction==MARSHALLING_BACKWARD){
      this->hnode      = new Hook();
      this->helement   = new Hook();
   }
 
   this->hnode->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
   this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
 
   /*corresponding fields*/
   node   =(Node*)this->hnode->delivers();
   element=(Element*)this->helement->delivers();
 
   MARSHALLING(active);
   MARSHALLING(zigzag_counter);
 
}

ObjectEnum()

int Pengrid::ObjectEnum ( void  )

virtual

Implements Object.

Definition at line 146 of file Pengrid.cpp.

                               {/*{{{*/
 
   return PengridEnum;
}

Configure()

void Pengrid::Configure ( Elements *  elements, Loads *  loads, Nodes *  nodes, Vertices *  vertices, Materials *  materials, Parameters *  parameters  )

virtual

Implements Load.

Definition at line 153 of file Pengrid.cpp.

                                                                                                                                               {/*{{{*/
 
   /*Take care of hooking up all objects for this load, ie links the objects in the hooks to their respective
    * datasets, using internal ids and offsets hidden in hooks: */
   hnode->configure(nodesin);
   helement->configure(elementsin);
 
   /*Get corresponding fields*/
   node=(Node*)hnode->delivers();
   element=(Element*)helement->delivers();
 
   /*point parameters to real dataset: */
   this->parameters=parametersin;
}

CreateJacobianMatrix()

void Pengrid::CreateJacobianMatrix ( Matrix< IssmDouble > *  Jff )

inlinevirtual

Implements Load.

Definition at line 58 of file Pengrid.h.

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

CreateKMatrix()

void Pengrid::CreateKMatrix ( Matrix< IssmDouble > *  Kff, Matrix< IssmDouble > *  Kfs  )

virtual

Implements Load.

Definition at line 168 of file Pengrid.cpp.

                                                                            {/*{{{*/
 
   /*No loads applied, do nothing: */
   return;
 
}

CreatePVector()

void Pengrid::CreatePVector ( Vector< IssmDouble > *  pf )

virtual

Implements Load.

Definition at line 175 of file Pengrid.cpp.

                                                  {/*{{{*/
   /*No loads applied, do nothing, originaly used for moulin input: */
   return;
 
}

GetNodesLidList()

void Pengrid::GetNodesLidList ( int *  lidlist )

virtual

Implements Load.

Definition at line 181 of file Pengrid.cpp.

                                          {/*{{{*/
 
   _assert_(lidlist);
   _assert_(node);
 
   lidlist[0]=node->Lid();
}

GetNodesSidList()

void Pengrid::GetNodesSidList ( int *  sidlist )

virtual

Implements Load.

Definition at line 189 of file Pengrid.cpp.

                                          {/*{{{*/
 
   _assert_(sidlist);
   _assert_(node);
 
   sidlist[0]=node->Sid();
}

GetNumberOfNodes()

int Pengrid::GetNumberOfNodes ( void  )

virtual

Implements Load.

Definition at line 197 of file Pengrid.cpp.

                                   {/*{{{*/
 
   return NUMVERTICES;
}

IsPenalty()

bool Pengrid::IsPenalty ( void  )

virtual

Implements Load.

Definition at line 202 of file Pengrid.cpp.

                            {/*{{{*/
   return true;
}

PenaltyCreateJacobianMatrix()

void Pengrid::PenaltyCreateJacobianMatrix ( Matrix< IssmDouble > *  Jff, IssmDouble  kmax  )

inlinevirtual

Implements Load.

Definition at line 65 of file Pengrid.h.

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

PenaltyCreateKMatrix()

void Pengrid::PenaltyCreateKMatrix ( Matrix< IssmDouble > *  Kff, Matrix< IssmDouble > *  kfs, IssmDouble  kmax  )

virtual

Implements Load.

Definition at line 206 of file Pengrid.cpp.

                                                                                                   {/*{{{*/
 
   /*Retrieve parameters: */
   ElementMatrix* Ke=NULL;
   int analysis_type;
   this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
 
   switch(analysis_type){
      case ThermalAnalysisEnum:
         Ke=PenaltyCreateKMatrixThermal(kmax);
         break;
      case MeltingAnalysisEnum:
         Ke=PenaltyCreateKMatrixMelting(kmax);
         break;
      case HydrologyDCInefficientAnalysisEnum:
         Ke=PenaltyCreateKMatrixHydrologyDCInefficient(kmax);
         break;
      default:
         _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
   }
 
   /*Add to global matrix*/
   if(Ke){
      Ke->AddToGlobal(Kff,Kfs);
      delete Ke;
   }
}

PenaltyCreatePVector()

void Pengrid::PenaltyCreatePVector ( Vector< IssmDouble > *  pf, IssmDouble  kmax  )

virtual

Implements Load.

Definition at line 234 of file Pengrid.cpp.

                                                                         {/*{{{*/
 
   /*Retrieve parameters: */
   ElementVector* pe=NULL;
   int analysis_type;
   this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
 
   switch(analysis_type){
      case ThermalAnalysisEnum:
         pe=PenaltyCreatePVectorThermal(kmax);
         break;
      case MeltingAnalysisEnum:
         pe=PenaltyCreatePVectorMelting(kmax);
         break;
      case StressbalanceAnalysisEnum: case AdjointHorizAnalysisEnum:
         break;
      case HydrologyDCInefficientAnalysisEnum:
         pe=PenaltyCreatePVectorHydrologyDCInefficient(kmax);
         break;
      default:
         _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
   }
 
   /*Add to global Vector*/
   if(pe){
      pe->AddToGlobal(pf);
      delete pe;
   }
}

ResetHooks()

void Pengrid::ResetHooks ( )

virtual

Implements Load.

Definition at line 264 of file Pengrid.cpp.

                         {/*{{{*/
 
   this->node=NULL;
   this->element=NULL;
   this->parameters=NULL;
 
   /*Get Element type*/
   this->hnode->reset();
   this->helement->reset();
 
}

SetCurrentConfiguration()

void Pengrid::SetCurrentConfiguration ( Elements *  elements, Loads *  loads, Nodes *  nodes, Vertices *  vertices, Materials *  materials, Parameters *  parameters  )

virtual

Implements Load.

Definition at line 276 of file Pengrid.cpp.

                                                                                                                                                             {/*{{{*/
 
}

SetwiseNodeConnectivity()

void Pengrid::SetwiseNodeConnectivity ( int *  d_nz, int *  o_nz, Node *  node, bool *  flags, int *  flagsindices, int  set1_enum, int  set2_enum  )

virtual

Implements Load.

Definition at line 280 of file Pengrid.cpp.

                                                                                                                                {/*{{{*/
 
   /*Output */
   int d_nz = 0;
   int o_nz = 0;
 
   if(!flags[this->node->Lid()]){
 
      /*flag current node so that no other element processes it*/
      flags[this->node->Lid()]=true;
 
      int counter=0;
      while(flagsindices[counter]>=0) counter++;
      flagsindices[counter]=this->node->Lid();
 
      /*if node is clone, we have an off-diagonal non-zero, else it is a diagonal non-zero*/
      switch(set2_enum){
         case FsetEnum:
            if(node->fsize){
               if(this->node->IsClone())
                o_nz += 1;
               else
                d_nz += 1;
            }
            break;
         case GsetEnum:
            if(node->gsize){
               if(this->node->IsClone())
                o_nz += 1;
               else
                d_nz += 1;
            }
            break;
         case SsetEnum:
            if(node->ssize){
               if(this->node->IsClone())
                o_nz += 1;
               else
                d_nz += 1;
            }
            break;
         default: _error_("not supported");
      }
   }
 
   /*Assign output pointers: */
   *pd_nz=d_nz;
   *po_nz=o_nz;
}

ConstraintActivate()

void Pengrid::ConstraintActivate

(

int *

punstable

)

Definition at line 332 of file Pengrid.cpp.

                                                        {/*{{{*/
 
   int analysis_type;
 
   /*Retrieve parameters: */
   this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
 
   switch(analysis_type){
   case StressbalanceAnalysisEnum:
      /*No penalty to check*/
      return;
   case ThermalAnalysisEnum:
      ConstraintActivateThermal(punstable);
      break;
   case MeltingAnalysisEnum:
      /*No penalty to check*/
      return;
   case HydrologyDCInefficientAnalysisEnum:
      ConstraintActivateHydrologyDCInefficient(punstable);
      break;
   default:
      _error_("analysis: " << EnumToStringx(analysis_type) << " not supported yet");
   }
}

ConstraintActivateHydrologyDCInefficient()

void Pengrid::ConstraintActivateHydrologyDCInefficient

(

int *

punstable

)

Definition at line 357 of file Pengrid.cpp.

                                                                              {/*{{{*/
 
   //   The penalty is stable if it doesn't change during two consecutive iterations.
   int        unstable=0;
   int        new_active;
   int        penalty_lock;
   IssmDouble pressure;
   IssmDouble h;
   IssmDouble h_max;
   HydrologyDCInefficientAnalysis* inefanalysis = NULL;
 
   /*check that pengrid is not a clone (penalty to be added only once)*/
   if(node->IsClone()){
      unstable=0;
      *punstable=unstable;
      return;
   }
   if(!element->IsOnBase()){
      unstable=0;
      active=0;
      *punstable=unstable;
      return;
   }
 
   /*Get sediment water head h*/
   inefanalysis = new HydrologyDCInefficientAnalysis();
   element->GetInputValue(&h,node,SedimentHeadSubstepEnum);
   inefanalysis->GetHydrologyDCInefficientHmax(&h_max,element,node);
   parameters->FindParam(&penalty_lock,HydrologydcPenaltyLockEnum);
 
   if (h>h_max){
    new_active=1;
   }
   else{
    new_active=0;
   }
 
   if(this->active==new_active){
      unstable=0;
   }
   else{
      unstable=1;
      if(penalty_lock)zigzag_counter++;
   }
 
   /*If penalty keeps zigzagging more than penalty_lock times: */
   if(penalty_lock){
      if(zigzag_counter>penalty_lock){
         unstable=0;
         active=1;
      }
   }
   /*Set penalty flag*/
   this->active=new_active;
 
   /*Assign output pointers:*/
   delete inefanalysis;
   *punstable=unstable;
}

ConstraintActivateThermal()

void Pengrid::ConstraintActivateThermal

(

int *

punstable

)

Definition at line 417 of file Pengrid.cpp.

                                                               {/*{{{*/
 
   //   The penalty is stable if it doesn't change during to successive iterations.
   IssmDouble pressure;
   IssmDouble temperature;
   IssmDouble t_pmp;
   int        new_active;
   int        unstable=0;
   int        penalty_lock;
 
   /*recover pointers: */
   Penta* penta=(Penta*)element;
 
   /*check that pengrid is not a clone (penalty to be added only once)*/
   if (node->IsClone()){
      unstable=0;
      *punstable=unstable;
      return;
   }
 
   //First recover pressure and temperature values, using the element: */
   penta->GetInputValue(&pressure,node,PressureEnum);
   penta->GetInputValue(&temperature,node,TemperaturePicardEnum);
 
   //Recover our data:
   parameters->FindParam(&penalty_lock,ThermalPenaltyLockEnum);
 
   //Compute pressure melting point
   t_pmp=element->TMeltingPoint(pressure);
 
   //Figure out if temperature is over melting_point, in which case, this penalty needs to be activated.
 
   if (temperature>t_pmp){
      new_active=1;
   }
   else{
      new_active=0;
   }
 
   //Figure out stability of this penalty
   if (active==new_active){
      unstable=0;
   }
   else{
      unstable=1;
      if(penalty_lock)zigzag_counter++;
   }
 
   /*If penalty keeps zigzagging more than 5 times: */
   if(penalty_lock){
      if(zigzag_counter>penalty_lock){
         unstable=0;
         active=1;
      }
   }
 
   //Set penalty flag
   active=new_active;
 
   //*Assign output pointers:*/
   *punstable=unstable;
}

PenaltyCreateKMatrixHydrologyDCInefficient()

ElementMatrix * Pengrid::PenaltyCreateKMatrixHydrologyDCInefficient

(

IssmDouble

kmax

)

Definition at line 480 of file Pengrid.cpp.

                                                                                 {/*{{{*/
   IssmDouble    penalty_factor;
 
   /*Retrieve parameters*/
   parameters->FindParam(&penalty_factor,HydrologydcPenaltyFactorEnum);
 
   /*Initialize Element matrix and return if necessary*/
   if(!this->active) return NULL;
   ElementMatrix* Ke=new ElementMatrix(&node,NUMVERTICES,this->parameters);
 
   Ke->values[0]=kmax*pow(10.,penalty_factor);
 
   /*Clean up and return*/
   return Ke;
}

PenaltyCreateKMatrixMelting()

ElementMatrix * Pengrid::PenaltyCreateKMatrixMelting

(

IssmDouble

kmax

)

Definition at line 496 of file Pengrid.cpp.

                                                                  {/*{{{*/
 
   IssmDouble pressure,temperature,t_pmp;
   IssmDouble penalty_factor;
 
   Penta* penta=(Penta*)element;
 
   /*check that pengrid is not a clone (penalty to be added only once)*/
   if (node->IsClone()) return NULL;
   ElementMatrix* Ke=new ElementMatrix(&node,1,this->parameters);
 
   /*Retrieve all parameters*/
   penta->GetInputValue(&pressure,node,PressureEnum);
   penta->GetInputValue(&temperature,node,TemperatureEnum);
   parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
 
   /*Compute pressure melting point*/
   t_pmp=parameters->FindParam(MaterialsMeltingpointEnum)-parameters->FindParam(MaterialsBetaEnum)*pressure;
 
   /*Add penalty load*/
   if (temperature<t_pmp){ //If T<Tpmp, there must be no melting. Therefore, melting should be  constrained to 0 when T<Tpmp, instead of using spcs, use penalties
      Ke->values[0]=kmax*pow(10.,penalty_factor);
   }
 
   /*Clean up and return*/
   return Ke;
}

PenaltyCreateKMatrixThermal()

ElementMatrix * Pengrid::PenaltyCreateKMatrixThermal

(

IssmDouble

kmax

)

Definition at line 524 of file Pengrid.cpp.

                                                                  {/*{{{*/
 
   IssmDouble    penalty_factor;
 
   /*Initialize Element matrix and return if necessary*/
   if(!this->active) return NULL;
   ElementMatrix* Ke=new ElementMatrix(&node,NUMVERTICES,this->parameters);
 
   /*recover parameters: */
   parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
 
   Ke->values[0]=kmax*pow(10.,penalty_factor);
 
   /*Clean up and return*/
   return Ke;
}

PenaltyCreatePVectorHydrologyDCInefficient()

ElementVector * Pengrid::PenaltyCreatePVectorHydrologyDCInefficient

(

IssmDouble

kmax

)

Definition at line 541 of file Pengrid.cpp.

                                                                                 {/*{{{*/
 
   IssmDouble h_max;
   IssmDouble penalty_factor;
   HydrologyDCInefficientAnalysis* inefanalysis = NULL;
 
   /*Initialize Element matrix and return if necessary*/
   if(!this->active) return NULL;
   ElementVector* pe=new ElementVector(&node,1,this->parameters);
   inefanalysis = new HydrologyDCInefficientAnalysis();
 
   /*Retrieve parameters*/
   parameters->FindParam(&penalty_factor,HydrologydcPenaltyFactorEnum);
 
   /*Get h_max and compute penalty*/
   inefanalysis->GetHydrologyDCInefficientHmax(&h_max,element,node);
 
   pe->values[0]=kmax*pow(10.,penalty_factor)*h_max;
 
   /*Clean up and return*/
   delete inefanalysis;
   return pe;
}

PenaltyCreatePVectorMelting()

ElementVector * Pengrid::PenaltyCreatePVectorMelting

(

IssmDouble

kmax

)

Definition at line 565 of file Pengrid.cpp.

                                                                  {/*{{{*/
 
   IssmDouble pressure;
   IssmDouble temperature;
   IssmDouble melting_offset;
   IssmDouble t_pmp;
   IssmDouble dt,penalty_factor;
 
   /*recover pointers: */
   Penta* penta=(Penta*)element;
 
   /*check that pengrid is not a clone (penalty to be added only once)*/
   if (node->IsClone()) return NULL;
   ElementVector* pe=new ElementVector(&node,NUMVERTICES,this->parameters);
 
   /*Retrieve all parameters*/
   penta->GetInputValue(&pressure,node,PressureEnum);
   penta->GetInputValue(&temperature,node,TemperatureEnum);
   parameters->FindParam(&melting_offset,MeltingOffsetEnum);
   parameters->FindParam(&dt,TimesteppingTimeStepEnum);
   parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
 
   /*Compute pressure melting point*/
   t_pmp=parameters->FindParam(MaterialsMeltingpointEnum)-parameters->FindParam(MaterialsBetaEnum)*pressure;
 
   /*Add penalty load
     This time, the penalty must have the same value as the one used for the thermal computation
     so that the corresponding melting can be computed correctly
     In the thermal computation, we used kmax=melting_offset, and the same penalty_factor*/
   if (temperature<t_pmp){ //%no melting
      pe->values[0]=0;
   }
   else{
      if (reCast<bool>(dt)) pe->values[0]=melting_offset*pow(10.,penalty_factor)*(temperature-t_pmp)/dt;
      else    pe->values[0]=melting_offset*pow(10.,penalty_factor)*(temperature-t_pmp);
   }
 
   /*Clean up and return*/
   return pe;
}

PenaltyCreatePVectorThermal()

ElementVector * Pengrid::PenaltyCreatePVectorThermal

(

IssmDouble

kmax

)

Definition at line 606 of file Pengrid.cpp.

                                                                  {/*{{{*/
 
   IssmDouble pressure;
   IssmDouble t_pmp;
   IssmDouble penalty_factor;
 
   Penta* penta=(Penta*)element;
 
   /*Initialize Element matrix and return if necessary*/
   if(!this->active) return NULL;
   ElementVector* pe=new ElementVector(&node,1,this->parameters);
 
   /*Retrieve all parameters*/
   penta->GetInputValue(&pressure,node,PressureEnum);
   parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
 
   /*Compute pressure melting point*/
   t_pmp=parameters->FindParam(MaterialsMeltingpointEnum)-parameters->FindParam(MaterialsBetaEnum)*pressure;
 
   pe->values[0]=kmax*pow(10.,penalty_factor)*t_pmp;
 
   /*Clean up and return*/
   return pe;
}

ResetConstraint()

void Pengrid::ResetConstraint

(

void

)

Definition at line 631 of file Pengrid.cpp.

                                           {/*{{{*/
   active         = 0;
   zigzag_counter = 0;
}

ResetZigzagCounter()

void Pengrid::ResetZigzagCounter

(

void

)

Definition at line 636 of file Pengrid.cpp.

                                          {/*{{{*/
 
   zigzag_counter=0;
}

Field Documentation

id

int Pengrid::id

private

Definition at line 25 of file Pengrid.h.

hnode

Hook* Pengrid::hnode

private

Definition at line 28 of file Pengrid.h.

helement

Hook* Pengrid::helement

private

Definition at line 29 of file Pengrid.h.

node

Node* Pengrid::node

private

Definition at line 32 of file Pengrid.h.

element

Element* Pengrid::element

private

Definition at line 33 of file Pengrid.h.

parameters

Parameters* Pengrid::parameters

private

Definition at line 35 of file Pengrid.h.

active

int Pengrid::active

private

Definition at line 38 of file Pengrid.h.

zigzag_counter

int Pengrid::zigzag_counter

private

Definition at line 39 of file Pengrid.h.

---

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

• src/c/classes/Loads/Pengrid.h
• src/c/classes/Loads/Pengrid.cpp