Ice Sheet System Model  4.18
Code documentation
Public Member Functions | Data Fields | Private Attributes | Friends
Node Class Reference

#include <Node.h>

Inheritance diagram for Node:
Object

Public Member Functions

 Node ()
 
 Node (int node_id, int node_sid, int io_index, bool isclone, IoModel *iomodel, int analysis_enum, int approximation_in, bool isamr)
 
 ~Node ()
 
Object * copy ()
 
void DeepEcho ()
 
void Echo ()
 
int Id ()
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
int ObjectEnum ()
 
void AllocateDofLists (int setenum)
 
void Activate (void)
 
void ApplyConstraint (int dof, IssmDouble value)
 
void CreateNodalConstraints (Vector< IssmDouble > *ys)
 
void Deactivate (void)
 
void DistributeLocalDofs (int *pdofcount, int setenum)
 
void DofInFSet (int dof)
 
void DofInSSet (int dof)
 
void FreezeDof (int dof)
 
int GetApproximation ()
 
void GetCoordinateSystem (IssmDouble *coord_system_out)
 
int GetDof (int dofindex, int setenum)
 
void GetDofList (int *poutdoflist, int approximation_enum, int setenum)
 
void GetDofListLocal (int *poutdoflist, int approximation_enum, int setenum)
 
void GetLocalDofList (int *poutdoflist, int approximation_enum, int setenum)
 
int GetNumberOfDofs (int approximation_enum, int setenum)
 
void HardDeactivate (void)
 
bool IsActive (void)
 
int IsClone ()
 
int IsFloating ()
 
int IsGrounded ()
 
int Lid (void)
 
void DistributeGlobalDofsMasters (int dofcount, int setenum)
 
void ReindexingDone (void)
 
void RelaxConstraint (int dof)
 
bool RequiresDofReindexing (void)
 
void SetCurrentConfiguration (DataSet *nodes, Vertices *vertices)
 
void ShowMasterDofs (int *truerows, int setenum)
 
int Sid (void)
 
int Pid (void)
 
void UpdateCloneDofs (int *alltruerows, int setenum)
 
void VecMerge (Vector< IssmDouble > *ug, IssmDouble *local_uf, int *indices_uf, IssmDouble *local_ys, int *indices_ys)
 
void VecReduce (Vector< IssmDouble > *uf, IssmDouble *local_ug, int *indices_ug)
 
void SetApproximation (int in_approximation)
 
- Public Member Functions inherited from Object
virtual ~Object ()
 

Data Fields

int analysis_enum
 
IssmDouble coord_system [3][3]
 
bool indexingupdate
 
int gsize
 
int fsize
 
int ssize
 
bool active
 
bool freeze
 
bool * f_set
 
bool * s_set
 
IssmDouble * svalues
 
int * doftype
 
int * gdoflist
 
int * fdoflist
 
int * sdoflist
 
int * gdoflist_local
 
int * fdoflist_local
 
int * sdoflist_local
 

Private Attributes

int approximation
 
bool clone
 
int id
 
int sid
 
int lid
 
int pid
 

Friends

class Nodes
 
class FemModel
 

Detailed Description

Definition at line 23 of file Node.h.

Constructor & Destructor Documentation

◆ Node() [1/2]

Node::Node ( )

Definition at line 19 of file Node.cpp.

19  {/*{{{*/
20  this->approximation = 0;
21  this->gsize = -1;
22  this->fsize = -1;
23  this->ssize = -1;
24  this->clone = false;
25  this->active = true;
26  this->freeze = false;
27  this->f_set = NULL;
28  this->s_set = NULL;
29  this->svalues = NULL;
30  this->doftype = NULL;
31  this->gdoflist = NULL;
32  this->fdoflist = NULL;
33  this->sdoflist = NULL;
34  this->gdoflist_local = NULL;
35  this->fdoflist_local = NULL;
36  this->sdoflist_local = NULL;
37 }

◆ Node() [2/2]

Node::Node ( int  node_id,
int  node_sid,
int  io_index,
bool  isclone,
IoModel *  iomodel,
int  analysis_enum,
int  approximation_in,
bool  isamr 
)

Definition at line 39 of file Node.cpp.

39  {/*{{{*/
40 
41  /*id: */
42  this->id = node_id;
43  this->sid = node_sid;
44  this->lid = -1; /*Assigned by Finalize*/
45  this->pid = -1; /*Assigned by Finalize*/
46  this->analysis_enum = node_analysis;
47  this->clone = node_clone;
48  this->active = true;
49  this->freeze = false;
50 
51  /*Initialize coord_system: Identity matrix by default*/
52  for(int k=0;k<3;k++) for(int l=0;l<3;l++) this->coord_system[k][l]=0.0;
53  for(int k=0;k<3;k++) this->coord_system[k][k]=1.0;
54 
55  this->approximation=0;
56  if(analysis_enum==StressbalanceAnalysisEnum) this->approximation=in_approximation;
57 
58  /*indexing:*/
59  this->indexingupdate = true;
60  this->doftype = NULL;
61  Analysis *analysis = EnumToAnalysis(analysis_enum);
62  this->gsize = analysis->DofsPerNode(&this->doftype,iomodel->domaintype,in_approximation);
63  delete analysis;
64 
65  if(this->gsize>0){
66  this->f_set = xNew<bool>(this->gsize);
67  this->s_set = xNew<bool>(this->gsize);
68  this->svalues = xNew<IssmDouble>(this->gsize);
69  this->gdoflist = xNew<int>(this->gsize);
70  this->gdoflist_local = xNew<int>(this->gsize);
71  this->fsize = -1;
72  this->ssize = -1;
73  this->fdoflist = NULL;
74  this->sdoflist = NULL;
75  this->fdoflist_local = NULL;
76  this->sdoflist_local = NULL;
77  }
78  else{
79  this->f_set = NULL;
80  this->s_set = NULL;
81  this->svalues = NULL;
82  this->gdoflist = NULL;
83  this->gdoflist_local = NULL;
84  this->fsize = -1;
85  this->ssize = -1;
86  this->fdoflist = NULL;
87  this->sdoflist = NULL;
88  this->fdoflist_local = NULL;
89  this->sdoflist_local = NULL;
90  }
91 
92  /*Assign values assuming no Dirichlet at this point*/
93  for(int i=0;i<this->gsize;i++){
94  this->f_set[i] = true;
95  this->s_set[i] = false;
96  this->svalues[i] = 0.;
97  this->gdoflist[i] = -1;
98  }
99 
100  /*Stop here if AMR*/
101  if(isamr) return;
102 
103  /*Stressbalance Horiz*/
104  if(analysis_enum==StressbalanceAnalysisEnum){
105 
106  /*Coordinate system provided, convert to coord_system matrix*/
107  _assert_(iomodel->Data("md.stressbalance.referential"));
108  XZvectorsToCoordinateSystem(&this->coord_system[0][0],&iomodel->Data("md.stressbalance.referential")[io_index*6]);
109  _assert_(sqrt( coord_system[0][0]*coord_system[0][0] + coord_system[1][0]*coord_system[1][0]) >1.e-4);
110 
111  if(iomodel->domaintype!=Domain2DhorizontalEnum && iomodel->domaintype!=Domain3DsurfaceEnum){
112  /*We have a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
113  _assert_(iomodel->Data("md.mesh.vertexonbase"));
114  _assert_(iomodel->Data("md.flowequation.vertex_equation"));
115  if(in_approximation==SSAApproximationEnum && !reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
116  this->HardDeactivate();
117  }
118  if(in_approximation==L1L2ApproximationEnum && !reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
119  this->HardDeactivate();
120  }
121  if(in_approximation==SSAHOApproximationEnum && reCast<int>(iomodel->Data("md.flowequation.borderSSA")[io_index])){
122  if(!reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
123  this->HardDeactivate();
124  }
125  }
126  if(in_approximation==SSAFSApproximationEnum && reCast<int>(iomodel->Data("md.flowequation.borderSSA")[io_index])){
127  if(!reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
128  for(int k=0;k<=1;k++) this->FreezeDof(k);
129  }
130  }
131  }
132  /*spc all nodes on SIA*/
133  if(in_approximation==SIAApproximationEnum){
134  this->HardDeactivate();
135  }
136  }
137 
138  /*2d solutions in 3d, we need to constrain all the nodes that are not on base*/
139  if(
140  analysis_enum==FreeSurfaceBaseAnalysisEnum ||
141  analysis_enum==MasstransportAnalysisEnum ||
142  analysis_enum==MeltingAnalysisEnum ||
143  analysis_enum==L2ProjectionBaseAnalysisEnum ||
144  analysis_enum==BalancethicknessAnalysisEnum ||
145  analysis_enum==HydrologyDCInefficientAnalysisEnum ||
146  analysis_enum==HydrologyDCEfficientAnalysisEnum ||
147  analysis_enum==GLheightadvectionAnalysisEnum ||
148  analysis_enum==LevelsetAnalysisEnum
149  ){
150  if(iomodel->domaintype!=Domain2DhorizontalEnum & iomodel->domaintype!=Domain3DsurfaceEnum){
151  /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
152  _assert_(iomodel->Data("md.mesh.vertexonbase"));
153  if(!(reCast<bool>(iomodel->Data("md.mesh.vertexonbase")[io_index]))){
154  this->HardDeactivate();
155  }
156  }
157  }
158  if(
159  analysis_enum==FreeSurfaceTopAnalysisEnum
160  ){
161  if(iomodel->domaintype!=Domain2DhorizontalEnum){
162  /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
163  _assert_(iomodel->Data("md.mesh.vertexonsurface"));
164  if(!(reCast<bool>(iomodel->Data("md.mesh.vertexonsurface")[io_index]))){
165  this->HardDeactivate();
166  }
167  }
168  }
169 
170 }

◆ ~Node()

Node::~Node ( )

Definition at line 172 of file Node.cpp.

172  {/*{{{*/
173 
174  if(this->f_set) xDelete<bool>(f_set);
175  if(this->s_set) xDelete<bool>(s_set);
176  if(this->svalues) xDelete<IssmDouble>(svalues);
177  if(this->doftype) xDelete<int>(doftype);
178  if(this->gdoflist) xDelete<int>(gdoflist);
179  if(this->fdoflist) xDelete<int>(fdoflist);
180  if(this->sdoflist) xDelete<int>(sdoflist);
181  if(this->gdoflist_local) xDelete<int>(gdoflist_local);
182  if(this->fdoflist_local) xDelete<int>(fdoflist_local);
183  if(this->sdoflist_local) xDelete<int>(sdoflist_local);
184  return;
185 }

Member Function Documentation

◆ copy()

Object * Node::copy ( void  )
virtual

Implements Object.

Definition at line 187 of file Node.cpp.

187  {/*{{{*/
188 
189  /*output: */
190  Node* output=NULL;
191 
192  /*initalize output: */
193  output=new Node();
194 
195  /*id: */
196  output->id = this->id;
197  output->sid = this->sid;
198  output->lid = this->lid;
199  output->pid = this->pid;
200  output->analysis_enum = this->analysis_enum;
201  output->approximation = this->approximation;
202 
203  /*Initialize coord_system: */
204  for(int k=0;k<3;k++) for(int l=0;l<3;l++) output->coord_system[k][l]=this->coord_system[k][l];
205 
206  /*indexing:*/
207  output->indexingupdate = this->indexingupdate;
208  output->gsize = this->gsize;
209  output->fsize = this->fsize;
210  output->ssize = this->ssize;
211  output->clone = this->clone;
212  output->active = this->active;
213  output->freeze = this->freeze;
214  if(output->gsize>0){
215  output->f_set=xNew<bool>(output->gsize);
216  output->s_set=xNew<bool>(output->gsize);
217  output->svalues=xNew<IssmDouble>(output->gsize);
218  if(this->doftype) output->doftype=xNew<int>(output->gsize);
219  output->gdoflist=xNew<int>(output->gsize);
220  output->gdoflist_local=xNew<int>(output->gsize);
221  }
222  if(output->fsize>0){
223  output->fdoflist=xNew<int>(output->fsize);
224  output->fdoflist_local=xNew<int>(output->fsize);
225  }
226  if(output->ssize>0){
227  output->sdoflist=xNew<int>(output->ssize);
228  output->sdoflist_local=xNew<int>(output->ssize);
229  }
230 
231  if(output->gsize>0){
232  memcpy(output->f_set,this->f_set,output->gsize*sizeof(bool));
233  memcpy(output->s_set,this->s_set,output->gsize*sizeof(bool));
234  xMemCpy<IssmDouble>(output->svalues,this->svalues,output->gsize);
235  if(output->doftype)memcpy(output->doftype,this->doftype,output->gsize*sizeof(int));
236  memcpy(output->gdoflist,this->gdoflist,output->gsize*sizeof(int));
237  memcpy(output->gdoflist_local,this->gdoflist_local,output->gsize*sizeof(int));
238  }
239  if(output->fsize>0){
240  memcpy(output->fdoflist,this->fdoflist,output->fsize*sizeof(int));
241  memcpy(output->fdoflist_local,this->fdoflist_local,output->fsize*sizeof(int));
242  }
243  if(output->ssize>0){
244  memcpy(output->sdoflist,this->sdoflist,output->ssize*sizeof(int));
245  memcpy(output->sdoflist_local,this->sdoflist_local,output->ssize*sizeof(int));
246  }
247 
248  return (Object*)output;
249 }

◆ DeepEcho()

void Node::DeepEcho ( void  )
virtual

Implements Object.

Definition at line 281 of file Node.cpp.

281  {/*{{{*/
282 
283  int i;
284  _printf_("Node:\n");
285  _printf_(" id: " << id << "\n");
286  _printf_(" sid: " << sid << "\n");
287  _printf_(" analysis_enum: " << EnumToStringx(analysis_enum) << "\n");
288  _printf_(" approximation: " << EnumToStringx(approximation) << "\n");
289  _printf_(" indexingupdate: " << indexingupdate << "\n");
290  _printf_(" gsize: " << gsize << "\n");
291  _printf_(" fsize: " << fsize << "\n");
292  _printf_(" ssize: " << ssize << "\n");
293  _printf_(" clone: " << clone << "\n");
294  _printf_(" active: " << active << "\n");
295  _printf_(" freeze: " << freeze << "\n");
296  _printf_(" f_set = [ ");
297  for(i=0;i<gsize;i++) _printf_((f_set[i]?1:0)<< " ");
298  _printf_("]\n");
299  _printf_(" s_set = [ ");
300  for(i=0;i<gsize;i++) _printf_((s_set[i]?1:0)<< " ");
301  _printf_("]\n");
302  _printf_(" svalues (" << this->ssize << "): |");
303  for(i=0;i<this->gsize;i++){
304  if(this->s_set[i])_printf_(" " << svalues[i] << " |");
305  }
306  _printf_("\n");
307  if(doftype){
308  _printf_(" doftype: |");
309  for(i=0;i<gsize;i++){
310  _printf_(" " << doftype[i] << " |");
311  }
312  _printf_("\n");
313  }
314  else _printf_(" doftype: NULL\n");
315 
316  _printf_(" g_doflist (" << this->gsize << "): |");
317  for(i=0;i<this->gsize;i++) _printf_(" " << gdoflist[i] << " |");
318  _printf_("\n");
319  _printf_(" g_doflist_local (" << this->gsize << "): |");
320  for(i=0;i<this->gsize;i++) _printf_(" " << gdoflist_local[i] << " |");
321  _printf_("\n");
322 
323  _printf_(" f_doflist (" << this->fsize << "): |");
324  for(i=0;i<this->fsize;i++) _printf_(" " << fdoflist[i] << " |");
325  _printf_("\n");
326  _printf_(" f_doflist_local (" << this->fsize << "): |");
327  for(i=0;i<this->fsize;i++) _printf_(" " << fdoflist_local[i] << " |");
328  _printf_("\n");
329 
330  _printf_(" s_doflist (" << this->ssize << "): |");
331  for(i=0;i<this->ssize;i++) _printf_(" " << sdoflist[i] << " |");
332  _printf_("\n");
333  _printf_(" s_doflist_local (" << this->ssize << "): |");
334  for(i=0;i<this->ssize;i++) _printf_(" " << sdoflist_local[i] << " |");
335  _printf_("\n");
336 
337 }

◆ Echo()

void Node::Echo ( void  )
virtual

Implements Object.

Definition at line 339 of file Node.cpp.

339  {/*{{{*/
340 
341  _printf_("Node:\n");
342  _printf_(" id : " << id << "\n");
343  _printf_(" sid: " << sid << "\n");
344  _printf_(" lid: " << lid << "\n");
345  _printf_(" pid: " << pid << "\n");
346  _printf_(" analysis_enum: " << EnumToStringx(analysis_enum) << "\n");
347  _printf_(" approximation: " << EnumToStringx(approximation) << "\n");
348  _printf_(" indexingupdate: " << indexingupdate << "\n");
349  _printf_(" gsize: " << gsize << "\n");
350  _printf_(" fsize: " << fsize << "\n");
351  _printf_(" ssize: " << ssize << "\n");
352  _printf_(" clone: " << clone << "\n");
353  _printf_(" active: " << active << "\n");
354  _printf_(" freeze: " << freeze << "\n");
355 }

◆ Id()

int Node::Id ( void  )
virtual

Implements Object.

Definition at line 357 of file Node.cpp.

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

◆ Marshall()

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

Implements Object.

Definition at line 251 of file Node.cpp.

251  { /*{{{*/
252 
253  MARSHALLING_ENUM(NodeEnum);
254  MARSHALLING(id);
255  MARSHALLING(sid);
256  MARSHALLING(lid);
257  MARSHALLING(pid);
258  MARSHALLING(indexingupdate);
259  MARSHALLING(analysis_enum);
260  MARSHALLING_ARRAY(coord_system,IssmDouble,9);
261 
262  MARSHALLING(gsize);
263  MARSHALLING(fsize);
264  MARSHALLING(ssize);
265  MARSHALLING(clone);
266  MARSHALLING(active);
267  MARSHALLING(freeze);
268  MARSHALLING_DYNAMIC(f_set,bool,gsize);
269  MARSHALLING_DYNAMIC(s_set,bool,gsize);
270  MARSHALLING_DYNAMIC(svalues,IssmDouble,gsize);
271  MARSHALLING_DYNAMIC(doftype,int,gsize);
272  MARSHALLING_DYNAMIC(gdoflist,int,gsize);
273  MARSHALLING_DYNAMIC(fdoflist,int,fsize);
274  MARSHALLING_DYNAMIC(sdoflist,int,ssize);
275  MARSHALLING_DYNAMIC(gdoflist_local,int,gsize);
276  MARSHALLING_DYNAMIC(fdoflist_local,int,fsize);
277  MARSHALLING_DYNAMIC(sdoflist_local,int,ssize);
278 } /*}}}*/

◆ ObjectEnum()

int Node::ObjectEnum ( void  )
virtual

Implements Object.

Definition at line 359 of file Node.cpp.

359  {/*{{{*/
360 
361  return NodeEnum;
362 
363 }

◆ AllocateDofLists()

void Node::AllocateDofLists ( int  setenum)

Definition at line 905 of file Node.cpp.

905  {/*{{{*/
906 
907  /*Initialize: */
908  int size=0;
909 
910  if(setenum==FsetEnum){
911  for(int i=0;i<this->gsize;i++) if(f_set[i])size++;
912  this->fsize=size;
913  xDelete<int>(this->fdoflist);
914  xDelete<int>(this->fdoflist_local);
915 
916  if(this->fsize){
917  this->fdoflist=xNew<int>(size);
918  this->fdoflist_local=xNew<int>(size);
919  }
920  else{
921  this->fdoflist=NULL;
922  this->fdoflist_local=NULL;
923  }
924  }
925  else if(setenum==SsetEnum){
926  for(int i=0;i<this->gsize;i++) if(s_set[i])size++;
927  this->ssize=size;
928  xDelete<int>(this->sdoflist);
929  xDelete<int>(this->sdoflist_local);
930 
931  if(this->ssize){
932  this->sdoflist=xNew<int>(size);
933  this->sdoflist_local=xNew<int>(size);
934  }
935  else{
936  this->sdoflist=NULL;
937  this->sdoflist_local=NULL;
938  }
939  }
940  /*TODO, we should never be here for GSET! add an assert and track down whether this happens*/
941 }

◆ Activate()

void Node::Activate ( void  )

Definition at line 632 of file Node.cpp.

632  {/*{{{*/
633 
634  if(!IsActive() && !this->freeze){
635  this->indexingupdate = true;
636  this->active = true;
637  for(int i=0;i<this->gsize;i++){
638  this->f_set[i] = true;
639  this->s_set[i] = false;
640  this->svalues[i] = 0.;
641  }
642  }
643 
644 }

◆ ApplyConstraint()

void Node::ApplyConstraint ( int  dof,
IssmDouble  value 
)

Definition at line 646 of file Node.cpp.

646  {/*{{{*/
647 
648  /*Dof should be added in the s set, describing which
649  * dofs are constrained to a certain value (dirichlet boundary condition*/
650  DofInSSet(dof);
651  this->svalues[dof]=value;
652 }

◆ CreateNodalConstraints()

void Node::CreateNodalConstraints ( Vector< IssmDouble > *  ys)

Definition at line 654 of file Node.cpp.

654  {/*{{{*/
655 
656  int i;
657  IssmDouble* values=NULL;
658  int count;
659 
660  /*Recover values for s set and plug them in constraints vector: */
661  if(this->ssize){
662  values=xNew<IssmDouble>(this->ssize);
663  count=0;
664  for(i=0;i<this->gsize;i++){
665  if(this->s_set[i]){
666  values[count]=this->svalues[i];
667  _assert_(!xIsNan<IssmDouble>(values[count]));
668  count++;
669  }
670  }
671 
672  /*Add values into constraint vector: */
673  ys->SetValues(this->ssize,this->sdoflist,values,INS_VAL);
674  }
675 
676  /*Free ressources:*/
677  xDelete<IssmDouble>(values);
678 
679 }

◆ Deactivate()

void Node::Deactivate ( void  )

Definition at line 681 of file Node.cpp.

681  {/*{{{*/
682 
683  if(IsActive() && !this->freeze){
684  this->indexingupdate = true;
685  this->active = false;
686  /*Constrain to 0. at this point*/
687  for(int i=0;i<this->gsize;i++){
688  this->f_set[i] = false;
689  this->s_set[i] = true;
690  this->svalues[i] = 0.;
691  }
692  }
693 } /*}}}*/

◆ DistributeLocalDofs()

void Node::DistributeLocalDofs ( int *  pdofcount,
int  setenum 
)

Definition at line 943 of file Node.cpp.

943  {/*{{{*/
944 
945  /*Get current count*/
946  int dofcount=*pdofcount;
947 
948  /*This node should distribute dofs for setenum set (eg, f_set or s_set), go ahead: */
949  if(setenum==GsetEnum){
950  _assert_(this->gsize==0 || this->gdoflist_local);
951  for(int i=0;i<this->gsize;i++) gdoflist_local[i]=dofcount+i;
952  dofcount+=this->gsize;
953  }
954  else if(setenum==FsetEnum){
955  _assert_(this->fsize==0 || this->fdoflist_local);
956  for(int i=0;i<this->fsize;i++) fdoflist_local[i]=dofcount+i;
957  dofcount+=this->fsize;
958  }
959  else if(setenum==SsetEnum){
960  _assert_(this->ssize==0 || this->sdoflist_local);
961  for(int i=0;i<this->ssize;i++) sdoflist_local[i]=dofcount+i;
962  dofcount+=this->ssize;
963  }
964  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
965 
966  /*Assign output pointers: */
967  *pdofcount=dofcount;
968 }

◆ DofInFSet()

void Node::DofInFSet ( int  dof)

Definition at line 694 of file Node.cpp.

694  {/*{{{*/
695 
696  /*Put dof for this node into the f set (ie, this dof will NOT be constrained
697  * to a fixed value during computations. Only do this for active nodes. */
698  _assert_(dof<this->gsize);
699  _assert_(this->active);
700 
701  if(this->f_set[dof] == 0){
702  if(this->freeze) _error_("Cannot change dof of frozen node");
703  this->indexingupdate = true;
704  this->f_set[dof]=1;
705  this->s_set[dof]=0;
706  }
707 }

◆ DofInSSet()

void Node::DofInSSet ( int  dof)

Definition at line 709 of file Node.cpp.

709  {/*{{{*/
710 
711  /*Put dof for this node into the s set (ie, this dof will be constrained
712  * to a fixed value during computations. */
713  _assert_(dof<this->gsize);
714 
715  if(this->f_set[dof] == 1){
716  //if(this->freeze) _error_("Cannot change dof of frozen node");
717  this->indexingupdate = true;
718  this->f_set[dof]=0; //n splits into f (for which we solve) and s (single point constraints)
719  this->s_set[dof]=1;
720  }
721 }

◆ FreezeDof()

void Node::FreezeDof ( int  dof)

Definition at line 723 of file Node.cpp.

723  {/*{{{*/
724 
725  DofInSSet(dof); //with 0 displacement for this dof.
726  //FIXME: for now we don't want this element to change so we use freeze
727  this->freeze =true;
728 
729 }

◆ GetApproximation()

int Node::GetApproximation ( )

Definition at line 731 of file Node.cpp.

731  {/*{{{*/
732 
733  return approximation;
734 }

◆ GetCoordinateSystem()

void Node::GetCoordinateSystem ( IssmDouble *  coord_system_out)

Definition at line 367 of file Node.cpp.

367  {/*{{{*/
368 
369  /*Copy coord_system*/
370  for(int k=0;k<3;k++) for(int l=0;l<3;l++) coord_system_out[3*k+l]=this->coord_system[k][l];
371 
372 }

◆ GetDof()

int Node::GetDof ( int  dofindex,
int  setenum 
)

Definition at line 374 of file Node.cpp.

374  {/*{{{*/
375 
376  _assert_(!this->indexingupdate);
377  if(setenum==GsetEnum){
378  _assert_(dofindex>=0 && dofindex<gsize);
379  return gdoflist[dofindex];
380  }
381  else if(setenum==FsetEnum){
382  _assert_(dofindex>=0 && dofindex<fsize);
383  return fdoflist[dofindex];
384  }
385  else if(setenum==SsetEnum){
386  _assert_(dofindex>=0 && dofindex<ssize);
387  return sdoflist[dofindex];
388  }
389  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
390 
391 } /*}}}*/

◆ GetDofList()

void Node::GetDofList ( int *  poutdoflist,
int  approximation_enum,
int  setenum 
)

Definition at line 392 of file Node.cpp.

392  {/*{{{*/
393  int i;
394  int count=0;
395  int count2=0;
396 
397  _assert_(!this->indexingupdate);
398 
399  if(approximation_enum==NoneApproximationEnum){
400  if(setenum==GsetEnum)for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist[i];
401  if(setenum==FsetEnum)for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist[i];
402  if(setenum==SsetEnum)for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist[i];
403  }
404  else{
405 
406  if(setenum==GsetEnum){
407  if(doftype){
408  count=0;
409  for(i=0;i<this->gsize;i++){
410  if(doftype[i]==approximation_enum){
411  outdoflist[count]=gdoflist[i];
412  count++;
413  }
414  }
415  _assert_(count); //at least one dof should be the approximation requested
416  }
417  else for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist[i];
418  }
419  else if(setenum==FsetEnum){
420  if(doftype){
421  count=0;
422  count2=0;
423  for(i=0;i<this->gsize;i++){
424  if(f_set[i]){
425  if(doftype[i]==approximation_enum){
426  outdoflist[count]=fdoflist[count2];
427  count++;
428  }
429  count2++;
430  }
431  }
432  }
433  else for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist[i];
434  }
435  else if(setenum==SsetEnum){
436  if(doftype){
437  count=0;
438  count2=0;
439  for(i=0;i<this->gsize;i++){
440  if(s_set[i]){
441  if(doftype[i]==approximation_enum){
442  outdoflist[count]=sdoflist[count2];
443  count++;
444  }
445  count2++;
446  }
447  }
448  }
449  else for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist[i];
450  }
451  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
452  }
453 }

◆ GetDofListLocal()

void Node::GetDofListLocal ( int *  poutdoflist,
int  approximation_enum,
int  setenum 
)

Definition at line 455 of file Node.cpp.

455  {/*{{{*/
456  int i;
457  int count=0;
458  int count2=0;
459 
460  _assert_(!this->indexingupdate);
461 
462  if(approximation_enum==NoneApproximationEnum){
463  if(setenum==GsetEnum)for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist_local[i];
464  if(setenum==FsetEnum)for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist_local[i];
465  if(setenum==SsetEnum)for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist_local[i];
466  }
467  else{
468 
469  if(setenum==GsetEnum){
470  if(doftype){
471  count=0;
472  for(i=0;i<this->gsize;i++){
473  if(doftype[i]==approximation_enum){
474  outdoflist[count]=gdoflist_local[i];
475  count++;
476  }
477  }
478  _assert_(count); //at least one dof should be the approximation requested
479  }
480  else for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist_local[i];
481  }
482  else if(setenum==FsetEnum){
483  if(doftype){
484  count=0;
485  count2=0;
486  for(i=0;i<this->gsize;i++){
487  if(f_set[i]){
488  if(doftype[i]==approximation_enum){
489  outdoflist[count]=fdoflist_local[count2];
490  count++;
491  }
492  count2++;
493  }
494  }
495  }
496  else for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist_local[i];
497  }
498  else if(setenum==SsetEnum){
499  if(doftype){
500  count=0;
501  count2=0;
502  for(i=0;i<this->gsize;i++){
503  if(s_set[i]){
504  if(doftype[i]==approximation_enum){
505  outdoflist[count]=sdoflist_local[count2];
506  count++;
507  }
508  count2++;
509  }
510  }
511  }
512  else for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist_local[i];
513  }
514  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
515  }
516 }

◆ GetLocalDofList()

void Node::GetLocalDofList ( int *  poutdoflist,
int  approximation_enum,
int  setenum 
)

Definition at line 518 of file Node.cpp.

518  {/*{{{*/
519  int i;
520  int count=0;
521  int count2=0;
522 
523  _assert_(!this->indexingupdate);
524 
525  if(approximation_enum==NoneApproximationEnum){
526  if(setenum==GsetEnum)for(i=0;i<this->gsize;i++) outdoflist[i]=i;
527  else if(setenum==FsetEnum){
528  count=0;
529  for(i=0;i<this->gsize;i++){
530  if(f_set[i]){
531  outdoflist[count]=i;
532  count++;
533  }
534  }
535  }
536  else if(setenum==SsetEnum){
537  count=0;
538  for(i=0;i<this->gsize;i++){
539  if(s_set[i]){
540  outdoflist[count]=i;
541  count++;
542  }
543  }
544  }
545  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
546  }
547  else{
548 
549  if(setenum==GsetEnum){
550  if(doftype){
551  count=0;
552  for(i=0;i<this->gsize;i++){
553  if(doftype[i]==approximation_enum){
554  outdoflist[count]=count;
555  count++;
556  }
557  }
558  _assert_(count);
559  }
560  else for(i=0;i<this->gsize;i++) outdoflist[i]=i;
561  }
562  else if(setenum==FsetEnum){
563 
564  if(doftype){
565  count=0;
566  count2=0;
567  for(i=0;i<this->gsize;i++){
568  if(doftype[i]==approximation_enum){
569  if(f_set[i]){
570  outdoflist[count]=count2;
571  count++;
572  }
573  count2++;
574  }
575  }
576  _assert_(count2);
577  }
578  else{
579 
580  count=0;
581  for(i=0;i<this->gsize;i++){
582  if(f_set[i]){
583  outdoflist[count]=i;
584  count++;
585  }
586  }
587  }
588  }
589  else if(setenum==SsetEnum){
590  if(doftype){
591  count=0;
592  count2=0;
593  for(i=0;i<this->gsize;i++){
594  if(doftype[i]==approximation_enum){
595  if(s_set[i]){
596  outdoflist[count]=count2;
597  count++;
598  }
599  count2++;
600  }
601  }
602  _assert_(count2);
603  }
604  else{
605  count=0;
606  for(i=0;i<this->gsize;i++){
607  if(s_set[i]){
608  outdoflist[count]=i;
609  count++;
610  }
611  }
612  }
613  }
614  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
615  }
616 }

◆ GetNumberOfDofs()

int Node::GetNumberOfDofs ( int  approximation_enum,
int  setenum 
)

Definition at line 741 of file Node.cpp.

741  {/*{{{*/
742 
743  /*Get number of degrees of freedom in a node, for a certain set (g,f or s-set)
744  *and for a certain approximation type: */
745 
746  int i;
747  int numdofs=0;
748 
749  if(approximation_enum==NoneApproximationEnum){
750  if (setenum==GsetEnum) numdofs=this->gsize;
751  else if (setenum==FsetEnum) numdofs=this->fsize;
752  else if (setenum==SsetEnum) numdofs=this->ssize;
753  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
754  }
755  else{
756  if(setenum==GsetEnum){
757  if(this->doftype){
758  numdofs=0;
759  for(i=0;i<this->gsize;i++){
760  if(this->doftype[i]==approximation_enum) numdofs++;
761  }
762  }
763  else numdofs=this->gsize;
764  }
765  else if (setenum==FsetEnum){
766  if(this->doftype){
767  numdofs=0;
768  for(i=0;i<this->gsize;i++){
769  if((this->doftype[i]==approximation_enum) && (this->f_set[i])) numdofs++;
770  }
771  }
772  else numdofs=this->fsize;
773  }
774  else if (setenum==SsetEnum){
775  if(this->doftype){
776  numdofs=0;
777  for(i=0;i<this->gsize;i++){
778  if((this->doftype[i]==approximation_enum) && (this->s_set[i])) numdofs++;
779  }
780  }
781  else numdofs=this->ssize;
782  }
783  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
784  }
785  return numdofs;
786 }

◆ HardDeactivate()

void Node::HardDeactivate ( void  )

Definition at line 788 of file Node.cpp.

788  {/*{{{*/
789 
790  this->Deactivate();
791  this->freeze =true;
792 
793 }

◆ IsActive()

bool Node::IsActive ( void  )

Definition at line 795 of file Node.cpp.

795  {/*{{{*/
796 
797  return active;
798 
799 }

◆ IsClone()

int Node::IsClone ( )

Definition at line 801 of file Node.cpp.

801  {/*{{{*/
802 
803  return clone;
804 
805 }

◆ IsFloating()

int Node::IsFloating ( )

◆ IsGrounded()

int Node::IsGrounded ( )

◆ Lid()

int Node::Lid ( void  )

Definition at line 618 of file Node.cpp.

618  {/*{{{*/
619  return lid;
620 }

◆ DistributeGlobalDofsMasters()

void Node::DistributeGlobalDofsMasters ( int  dofcount,
int  setenum 
)

Definition at line 970 of file Node.cpp.

970  {/*{{{*/
971 
972  /*This node is a clone, don't offset the dofs!: */
973  if(clone) return;
974 
975  /*This node should off_set the dofs, go ahead: */
976  if(setenum==GsetEnum){
977  _assert_(this->gsize==0 || this->gdoflist);
978  for(int i=0;i<this->gsize;i++) this->gdoflist[i]=this->gdoflist_local[i]+dofcount;
979  }
980  else if(setenum==FsetEnum){
981  _assert_(this->fsize==0 || this->fdoflist);
982  for(int i=0;i<this->fsize;i++) this->fdoflist[i]=this->fdoflist_local[i]+dofcount;
983  }
984  else if(setenum==SsetEnum){
985  _assert_(this->ssize==0 || this->sdoflist);
986  for(int i=0;i<this->ssize;i++) this->sdoflist[i]=this->sdoflist_local[i]+dofcount;
987  }
988  else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
989 }

◆ ReindexingDone()

void Node::ReindexingDone ( void  )

Definition at line 807 of file Node.cpp.

807  {/*{{{*/
808 
809  this->indexingupdate = false;
810 
811 }

◆ RelaxConstraint()

void Node::RelaxConstraint ( int  dof)

Definition at line 813 of file Node.cpp.

813  {/*{{{*/
814 
815  /*Dof should be added to the f-set, and taken out of the s-set:*/
816  if(this->active){
817  DofInFSet(dof);
818  this->svalues[dof]=0.;
819  }
820 }

◆ RequiresDofReindexing()

bool Node::RequiresDofReindexing ( void  )

Definition at line 822 of file Node.cpp.

822  {/*{{{*/
823 
824  return this->indexingupdate;
825 
826 }

◆ SetCurrentConfiguration()

void Node::SetCurrentConfiguration ( DataSet *  nodes,
Vertices *  vertices 
)

◆ ShowMasterDofs()

void Node::ShowMasterDofs ( int *  truerows,
int  setenum 
)

Definition at line 991 of file Node.cpp.

991  {/*{{{*/
992 
993  _assert_(!this->clone);
994 
995  /*Ok, we are not a clone, just plug our dofs into truedofs: */
996  switch(setenum){
997  case GsetEnum:
998  for(int j=0;j<this->gsize;j++) truedofs[j]=gdoflist[j];
999  break;
1000  case FsetEnum:
1001  for(int j=0;j<this->fsize;j++) truedofs[j]=fdoflist[j];
1002  break;
1003  case SsetEnum:
1004  for(int j=0;j<this->ssize;j++) truedofs[j]=sdoflist[j];
1005  break;
1006  default:
1007  _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
1008  }
1009 
1010 }

◆ Sid()

int Node::Sid ( void  )

Definition at line 622 of file Node.cpp.

622  {/*{{{*/
623  return sid;
624 }

◆ Pid()

int Node::Pid ( void  )

Definition at line 626 of file Node.cpp.

626  {/*{{{*/
627  return this->pid;
628 }

◆ UpdateCloneDofs()

void Node::UpdateCloneDofs ( int *  alltruerows,
int  setenum 
)

Definition at line 1012 of file Node.cpp.

1012  {/*{{{*/
1013 
1014  _assert_(this->clone);
1015 
1016  /*Ok, we are a clone node, but we did not create the dofs for this node.
1017  *Therefore, our doflist is garbage right now. Go pick it up in the alltruedofs: */
1018  switch(setenum){
1019  case GsetEnum:
1020  for(int j=0;j<this->gsize;j++) gdoflist[j]=alltruedofs[j];
1021  break;
1022  case FsetEnum:
1023  for(int j=0;j<this->fsize;j++) fdoflist[j]=alltruedofs[j];
1024  break;
1025  case SsetEnum:
1026  for(int j=0;j<this->ssize;j++) sdoflist[j]=alltruedofs[j];
1027  break;
1028  default:
1029  _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
1030  }
1031 }

◆ VecMerge()

void Node::VecMerge ( Vector< IssmDouble > *  ug,
IssmDouble *  local_uf,
int *  indices_uf,
IssmDouble *  local_ys,
int *  indices_ys 
)

Definition at line 828 of file Node.cpp.

828  {/*{{{*/
829 
830  /*Only perform operation if not clone*/
831  if(this->IsClone()) return;
832 
833  if(this->fsize){
834  int* indices = xNew<int>(this->fsize);
835  IssmDouble* values = xNew<IssmDouble>(this->fsize);
836 
837  int count = 0;
838  for(int i=0;i<this->gsize;i++){
839  if(this->f_set[i]){
840  _assert_(local_uf);
841  _assert_(this->fdoflist[count]==indices_uf[this->fdoflist_local[count]]);
842 
843  values[count] =local_uf[this->fdoflist_local[count]];
844  indices[count]=this->gdoflist[i];
845  count++;
846  }
847  }
848  ug->SetValues(this->fsize,indices,values,INS_VAL);
849 
850  xDelete<IssmDouble>(values);
851  xDelete<int>(indices);
852  }
853  if(this->ssize){
854  int* indices = xNew<int>(this->ssize);
855  IssmDouble* values = xNew<IssmDouble>(this->ssize);
856 
857  int count = 0;
858  for(int i=0;i<this->gsize;i++){
859  if(this->s_set[i]){
860  _assert_(local_ys);
861  _assert_(this->sdoflist[count]==indices_ys[this->sdoflist_local[count]]);
862 
863  values[count] =local_ys[this->sdoflist_local[count]];
864  indices[count]=this->gdoflist[i];
865  count++;
866  }
867  }
868  ug->SetValues(this->ssize,indices,values,INS_VAL);
869 
870  xDelete<IssmDouble>(values);
871  xDelete<int>(indices);
872  }
873 }

◆ VecReduce()

void Node::VecReduce ( Vector< IssmDouble > *  uf,
IssmDouble *  local_ug,
int *  indices_ug 
)

Definition at line 875 of file Node.cpp.

875  {/*{{{*/
876 
877 
878  /*Only perform operation if not clone*/
879  if(this->IsClone()) return;
880 
881  if(this->fsize){
882  int* indices = xNew<int>(this->fsize);
883  IssmDouble* values = xNew<IssmDouble>(this->fsize);
884 
885  int count = 0;
886  for(int i=0;i<this->gsize;i++){
887  if(this->f_set[i]){
888  _assert_(local_ug);
889  _assert_(this->gdoflist[i]==indices_ug[this->gdoflist_local[i]]);
890 
891  values[count] =local_ug[this->gdoflist_local[i]];
892  indices[count]=this->fdoflist[count];
893  count++;
894  }
895  }
896  uf->SetValues(this->fsize,indices,values,INS_VAL);
897 
898  xDelete<IssmDouble>(values);
899  xDelete<int>(indices);
900  }
901 }

◆ SetApproximation()

void Node::SetApproximation ( int  in_approximation)

Definition at line 736 of file Node.cpp.

736  {/*{{{*/
737 
738  this->approximation = in_approximation;
739 }

Friends And Related Function Documentation

◆ Nodes

friend class Nodes
friend

Definition at line 35 of file Node.h.

◆ FemModel

friend class FemModel
friend

Definition at line 36 of file Node.h.

Field Documentation

◆ approximation

int Node::approximation
private

Definition at line 26 of file Node.h.

◆ clone

bool Node::clone
private

Definition at line 27 of file Node.h.

◆ id

int Node::id
private

Definition at line 28 of file Node.h.

◆ sid

int Node::sid
private

Definition at line 29 of file Node.h.

◆ lid

int Node::lid
private

Definition at line 30 of file Node.h.

◆ pid

int Node::pid
private

Definition at line 31 of file Node.h.

◆ analysis_enum

int Node::analysis_enum

Definition at line 39 of file Node.h.

◆ coord_system

IssmDouble Node::coord_system[3][3]

Definition at line 40 of file Node.h.

◆ indexingupdate

bool Node::indexingupdate

Definition at line 41 of file Node.h.

◆ gsize

int Node::gsize

Definition at line 44 of file Node.h.

◆ fsize

int Node::fsize

Definition at line 45 of file Node.h.

◆ ssize

int Node::ssize

Definition at line 46 of file Node.h.

◆ active

bool Node::active

Definition at line 49 of file Node.h.

◆ freeze

bool Node::freeze

Definition at line 50 of file Node.h.

◆ f_set

bool* Node::f_set

Definition at line 53 of file Node.h.

◆ s_set

bool* Node::s_set

Definition at line 54 of file Node.h.

◆ svalues

IssmDouble* Node::svalues

Definition at line 55 of file Node.h.

◆ doftype

int* Node::doftype

Definition at line 58 of file Node.h.

◆ gdoflist

int* Node::gdoflist

Definition at line 61 of file Node.h.

◆ fdoflist

int* Node::fdoflist

Definition at line 62 of file Node.h.

◆ sdoflist

int* Node::sdoflist

Definition at line 63 of file Node.h.

◆ gdoflist_local

int* Node::gdoflist_local

Definition at line 64 of file Node.h.

◆ fdoflist_local

int* Node::fdoflist_local

Definition at line 65 of file Node.h.

◆ sdoflist_local

int* Node::sdoflist_local

Definition at line 66 of file Node.h.

The documentation for this class was generated from the following files:
FreeSurfaceTopAnalysisEnum
@ FreeSurfaceTopAnalysisEnum
Definition: EnumDefinitions.h:1072
BalancethicknessAnalysisEnum
@ BalancethicknessAnalysisEnum
Definition: EnumDefinitions.h:981
Node::id
int id
Definition: Node.h:28
Node::IsActive
bool IsActive(void)
Definition: Node.cpp:795
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
MasstransportAnalysisEnum
@ MasstransportAnalysisEnum
Definition: EnumDefinitions.h:1163
Node::sdoflist_local
int * sdoflist_local
Definition: Node.h:66
StressbalanceAnalysisEnum
@ StressbalanceAnalysisEnum
Definition: EnumDefinitions.h:1285
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
SSAHOApproximationEnum
@ SSAHOApproximationEnum
Definition: EnumDefinitions.h:1257
MARSHALLING_ENUM
#define MARSHALLING_ENUM(EN)
Definition: Marshalling.h:14
Node::svalues
IssmDouble * svalues
Definition: Node.h:55
SsetEnum
@ SsetEnum
Definition: EnumDefinitions.h:1282
NodeEnum
@ NodeEnum
Definition: EnumDefinitions.h:659
Node::indexingupdate
bool indexingupdate
Definition: Node.h:41
Node::clone
bool clone
Definition: Node.h:27
FreeSurfaceBaseAnalysisEnum
@ FreeSurfaceBaseAnalysisEnum
Definition: EnumDefinitions.h:1071
Node::freeze
bool freeze
Definition: Node.h:50
Node::sid
int sid
Definition: Node.h:29
Node::active
bool active
Definition: Node.h:49
L1L2ApproximationEnum
@ L1L2ApproximationEnum
Definition: EnumDefinitions.h:1135
HydrologyDCInefficientAnalysisEnum
@ HydrologyDCInefficientAnalysisEnum
Definition: EnumDefinitions.h:1099
MARSHALLING_DYNAMIC
#define MARSHALLING_DYNAMIC(FIELD, TYPE, SIZE)
Definition: Marshalling.h:61
Node::ssize
int ssize
Definition: Node.h:46
Node::s_set
bool * s_set
Definition: Node.h:54
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
MeltingAnalysisEnum
@ MeltingAnalysisEnum
Definition: EnumDefinitions.h:1182
Object
Definition: Object.h:13
L2ProjectionBaseAnalysisEnum
@ L2ProjectionBaseAnalysisEnum
Definition: EnumDefinitions.h:1136
NoneApproximationEnum
@ NoneApproximationEnum
Definition: EnumDefinitions.h:1201
Node::analysis_enum
int analysis_enum
Definition: Node.h:39
MARSHALLING_ARRAY
#define MARSHALLING_ARRAY(FIELD, TYPE, SIZE)
Definition: Marshalling.h:45
Vector::SetValues
void SetValues(int ssize, int *list, doubletype *values, InsMode mode)
Definition: Vector.h:153
Node::doftype
int * doftype
Definition: Node.h:58
Node::HardDeactivate
void HardDeactivate(void)
Definition: Node.cpp:788
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
LevelsetAnalysisEnum
@ LevelsetAnalysisEnum
Definition: EnumDefinitions.h:1141
Node::pid
int pid
Definition: Node.h:31
Node::sdoflist
int * sdoflist
Definition: Node.h:63
GsetEnum
@ GsetEnum
Definition: EnumDefinitions.h:1093
Analysis::DofsPerNode
virtual int DofsPerNode(int **doflist, int domaintype, int approximation)=0
Domain3DsurfaceEnum
@ Domain3DsurfaceEnum
Definition: EnumDefinitions.h:1039
MARSHALLING
#define MARSHALLING(FIELD)
Definition: Marshalling.h:29
INS_VAL
@ INS_VAL
Definition: toolkitsenums.h:14
Node::IsClone
int IsClone()
Definition: Node.cpp:801
HydrologyDCEfficientAnalysisEnum
@ HydrologyDCEfficientAnalysisEnum
Definition: EnumDefinitions.h:1098
SSAFSApproximationEnum
@ SSAFSApproximationEnum
Definition: EnumDefinitions.h:1256
EnumToAnalysis
Analysis * EnumToAnalysis(int analysis_enum)
Definition: EnumToAnalysis.cpp:13
Node::coord_system
IssmDouble coord_system[3][3]
Definition: Node.h:40
IoModel::Data
IssmDouble * Data(const char *data_name)
Definition: IoModel.cpp:437
Node
Definition: Node.h:23
Node::approximation
int approximation
Definition: Node.h:26
GLheightadvectionAnalysisEnum
@ GLheightadvectionAnalysisEnum
Definition: EnumDefinitions.h:1077
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Node::Deactivate
void Deactivate(void)
Definition: Node.cpp:681
Node::DofInFSet
void DofInFSet(int dof)
Definition: Node.cpp:694
XZvectorsToCoordinateSystem
void XZvectorsToCoordinateSystem(IssmDouble *T, IssmDouble *xzvectors)
Definition: XZvectorsToCoordinateSystem.cpp:8
Node::DofInSSet
void DofInSSet(int dof)
Definition: Node.cpp:709
Node::Node
Node()
Definition: Node.cpp:19
Node::f_set
bool * f_set
Definition: Node.h:53
Node::lid
int lid
Definition: Node.h:30
SSAApproximationEnum
@ SSAApproximationEnum
Definition: EnumDefinitions.h:1255
Node::gsize
int gsize
Definition: Node.h:44
Node::gdoflist_local
int * gdoflist_local
Definition: Node.h:64
Node::FreezeDof
void FreezeDof(int dof)
Definition: Node.cpp:723
FsetEnum
@ FsetEnum
Definition: EnumDefinitions.h:1075
Node::fdoflist_local
int * fdoflist_local
Definition: Node.h:65
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
Node::fdoflist
int * fdoflist
Definition: Node.h:62
Node::gdoflist
int * gdoflist
Definition: Node.h:61
SIAApproximationEnum
@ SIAApproximationEnum
Definition: EnumDefinitions.h:1241
Analysis
Definition: Analysis.h:30
Node::fsize
int fsize
Definition: Node.h:45
Generated on Thu Jul 2 2020 08:09:29 for Ice Sheet System Model by   doxygen 1.8.19