Ice Sheet System Model  4.18
Code documentation
Macros | Functions
CreateElementsVerticesAndMaterials.cpp File Reference
#include "../../toolkits/toolkits.h"
#include "../../classes/classes.h"
#include "../../shared/shared.h"
#include "./ModelProcessorx.h"

Go to the source code of this file.

Macros

#define MAXCONNECTIVITY   5
 

Functions

bool IsVertexInRank (int *vertices_ranks, int *vertices_proc_count, int vid, int rank)
 
int VertexMasterRank (int *vertices_ranks, int vid)
 
void AddVertexToRank (int *vertices_ranks, int *vertices_proc_count, int vid, int rank)
 
void CreateElements (Elements *elements, IoModel *iomodel, const int nummodels)
 
void CreateMaterials (Elements *elements, Inputs2 *inputs2, Materials *materials, IoModel *iomodel, const int nummodels)
 
void CreateVertices (Elements *elements, Vertices *vertices, IoModel *iomodel, int solution_type, bool isamr)
 

Macro Definition Documentation

◆ MAXCONNECTIVITY

#define MAXCONNECTIVITY   5

Definition at line 10 of file CreateElementsVerticesAndMaterials.cpp.

Function Documentation

◆ IsVertexInRank()

bool IsVertexInRank ( int *  vertices_ranks,
int *  vertices_proc_count,
int  vid,
int  rank 
)

Definition at line 12 of file CreateElementsVerticesAndMaterials.cpp.

12  {/*{{{*/
13 
14  /*See if node is already in partition*/
15  for(int k=0;k<vertices_proc_count[vid];k++){
16  if(vertices_ranks[MAXCONNECTIVITY*vid+k] == rank) return true;
17  }
18 
19  return false;
20 }/*}}}*/

◆ VertexMasterRank()

int VertexMasterRank ( int *  vertices_ranks,
int  vid 
)

Definition at line 21 of file CreateElementsVerticesAndMaterials.cpp.

21  {/*{{{*/
22  return vertices_ranks[MAXCONNECTIVITY*vid+0];
23 }/*}}}*/

◆ AddVertexToRank()

void AddVertexToRank ( int *  vertices_ranks,
int *  vertices_proc_count,
int  vid,
int  rank 
)

Definition at line 24 of file CreateElementsVerticesAndMaterials.cpp.

24  {/*{{{*/
25 
26  /*See if node is already in partition, return if this is the case*/
27  if(IsVertexInRank(vertices_ranks,vertices_proc_count,vid,rank)) return;
28 
29  /*This rank has not been marked for this node just yet so go ahead and add it*/
30  if(vertices_proc_count[vid]==MAXCONNECTIVITY) _error_("This vertex is connected to more than "<<MAXCONNECTIVITY<<" partition. Either reduce the number of processors, or increase MAXCONNECTIVITY");
31  vertices_ranks[MAXCONNECTIVITY*vid+vertices_proc_count[vid]] = rank;
32  vertices_proc_count[vid]++;
33 }/*}}}*/

◆ CreateElements()

void CreateElements ( Elements elements,
IoModel iomodel,
const int  nummodels 
)

Definition at line 35 of file CreateElementsVerticesAndMaterials.cpp.

35  {/*{{{*/
36 
37  /*Intermediary*/
38  bool control_analysis;
39  bool adolc_analysis;
40 
41  /*Fetch parameters: */
42  iomodel->FindConstant(&control_analysis,"md.inversion.iscontrol");
43  iomodel->FindConstant(&adolc_analysis,"md.autodiff.isautodiff");
44 
45  /*Did we already create the elements? : */
46  _assert_(elements->Size()==0);
47 
48  /*Create elements*/
49  if(control_analysis && !adolc_analysis)iomodel->FetchData(2,"md.inversion.min_parameters","md.inversion.max_parameters");
50  if(iomodel->domaintype==Domain2DverticalEnum || iomodel->domaindim==3) iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
51 
52  int count = 0;
53  switch(iomodel->meshelementtype){
54  case TriaEnum:
55  for(int i=0;i<iomodel->numberofelements;i++){
56  if(iomodel->my_elements[i]){
57  elements->AddObject(new Tria(i+1,i,count,iomodel,nummodels));
58  count++;
59  }
60  }
61  break;
62  case TetraEnum:
63  for(int i=0;i<iomodel->numberofelements;i++){
64  if(iomodel->my_elements[i]){
65  elements->AddObject(new Tetra(i+1,i,count,iomodel,nummodels));
66  count++;
67  }
68  }
69  break;
70  case PentaEnum:
71  iomodel->FetchData(2,"md.mesh.upperelements","md.mesh.lowerelements");
72  for(int i=0;i<iomodel->numberofelements;i++){
73  if(iomodel->my_elements[i]){
74  elements->AddObject(new Penta(i+1,i,count,iomodel,nummodels));
75  count++;
76  }
77  }
78  break;
79  default:
80  _error_("Mesh not supported yet");
81  }
82 
83  /*Free data: */
84  iomodel->DeleteData(6,"md.mesh.upperelements","md.mesh.lowerelements","md.inversion.min_parameters","md.inversion.max_parameters","md.mesh.vertexonbase","md.mesh.vertexonsurface");
85 
86 }/*}}}*/

◆ CreateMaterials()

void CreateMaterials ( Elements elements,
Inputs2 inputs2,
Materials materials,
IoModel iomodel,
const int  nummodels 
)

Definition at line 87 of file CreateElementsVerticesAndMaterials.cpp.

87  {/*{{{*/
88 
89  /*Intermediary*/
90  int i;
91  int nnat,dummy;
92  int* nature=NULL;
93 
94  /*Fetch parameters: */
95  int materials_type;
96  iomodel->FindConstant(&materials_type,"md.materials.type");
97 
98  /*Did we already create the materials? : */
99  _assert_(materials->Size()==0);
100 
101  /*Create materials*/
102  switch(materials_type){
103  case MaticeEnum:
104  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
105  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
106  for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
107  switch(iomodel->domaindim){
108  case 2:
110  break;
111  case 3:
112  break;
113  default:
114  _error_("Mesh not supported yet");
115  }
116  break;
117  case MatenhancediceEnum:
118  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
119  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
120  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
121  for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
122  switch(iomodel->domaindim){
123  case 2:
126  break;
127  case 3:
128  break;
129  default:
130  _error_("Mesh not supported yet");
131  }
132  break;
133  case MatdamageiceEnum:
134  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
135  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
136  iomodel->FetchDataToInput(inputs2,elements,"md.damage.D",DamageDEnum);
137  for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
138  switch(iomodel->domaindim){
139  case 2:
142  break;
143  case 3:
144  break;
145  default:
146  _error_("Mesh not supported yet");
147  }
148  break;
149  case MatestarEnum:
150  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
151  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
152  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
153  for(i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matestar(i+1,i,iomodel));
154  switch(iomodel->domaindim){
155  case 2:
159  break;
160  case 3:
161  break;
162  default:
163  _error_("Mesh not supported yet");
164  }
165  break;
166  case MaterialsEnum:
167 
168  //we have several types of materials. Retrieve this info first:
169  iomodel->FetchData(&nature,&nnat,&dummy,"md.materials.nature");
170 
171  //make sure materials that are not tied to elements come last: for now, only Matlitho qualifies.
172  for(int i=0;i<nnat;i++){
173  if (IoCodeToEnumNature(nature[i])==MatlithoEnum){
174  int temp=nature[nnat-1];
175  nature[nnat-1]=nature[i];
176  nature[i]=temp;
177  }
178  }
179 
180  //go through list of materials, and create them:
181  for(int i=0;i<nnat;i++){
182  switch(IoCodeToEnumNature(nature[i])){ //{{{
183  case MaticeEnum:
184  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
185  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
186  for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
187  switch(iomodel->domaindim){
188  case 2:
190  break;
191  case 3:
192  break;
193  default:
194  _error_("Mesh not supported yet");
195  }
196  break;
197  case MatlithoEnum:
198  iomodel->FetchData(9,"md.materials.radius","md.materials.viscosity","md.materials.lame_lambda","md.materials.lame_mu","md.materials.burgers_viscosity","md.materials.burgers_mu","md.materials.isburgers","md.materials.issolid","md.materials.density");
199  materials->AddObject(new Matlitho(materials->Size()+1,iomodel));
200  iomodel->DeleteData(9,"md.materials.radius","md.materials.viscosity","md.materials.lame_lambda","md.materials.lame_mu","md.materials.burgers_viscosity","md.materials.burgers_mu","md.materials.isburgers","md.materials.issolid","md.materials.density");
201  break;
202 
203  case MathydroEnum:
204  {
205  /*If we don't have any materials pointed to by elements (meaning, if we are running only litho or hydro),
206  * then we need to zero out the hmaterial pointers inside the elements dataset so that it won't error out
207  * during configuration: */
208  bool isice=false;
209  for (int j=0;j<nnat;j++){
210  if((IoCodeToEnumNature(nature[i])==MaticeEnum)||
211  (IoCodeToEnumNature(nature[i])==MatenhancediceEnum)||
212  (IoCodeToEnumNature(nature[i])==MatestarEnum)||
213  (IoCodeToEnumNature(nature[i])==MatdamageiceEnum)){
214  isice=true; break; }
215  }
216  if (!isice){
217  /*go through elements, and zero the hmaterials pointers: */
218  for(int j=0;j<elements->Size();j++){
219  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
220  switch(element->ObjectEnum()){
221  case TriaEnum:
222  {
223  Tria* tria= xDynamicCast<Tria*>(element);
224  tria->hmaterial=NULL;
225  }
226  break;
227  default:
228  _error_("Not implemented yet");
229  }
230  }
231  }
232  }
233  break;
234 
235  case MatenhancediceEnum:
236  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
237  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
238  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
239  for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
240  switch(iomodel->domaindim){
241  case 2:
244  break;
245  case 3:
246  break;
247  default:
248  _error_("Mesh not supported yet");
249  }
250  break;
251  case MatdamageiceEnum:
252  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
253  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
254  iomodel->FetchDataToInput(inputs2,elements,"md.damage.D",DamageDEnum);
255  for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
256  switch(iomodel->domaindim){
257  case 2:
260  break;
261  case 3:
262  break;
263  default:
264  _error_("Mesh not supported yet");
265  }
266  break;
267  case MatestarEnum:
268  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
269  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
270  iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
271  for(i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matestar(i+1,i,iomodel));
272  switch(iomodel->domaindim){
273  case 2:
277  break;
278  case 3:
279  break;
280  default:
281  _error_("Mesh not supported yet");
282  }
283  break;
284 
285  default:
286  _error_("Materials nature type "<<EnumToStringx(IoCodeToEnumNature(nature[i]))<<" not supported");
287 
288  } //}}}
289  }
290  //Free ressources:
291  xDelete<int>(nature);
292  break;
293 
294  default:
295  _error_("Materials "<<EnumToStringx(materials_type)<<" not supported");
296  }
297 
298  /*Free data: */
299  iomodel->DeleteData(3,"md.material.rheology_B","md.material.rheology_n","md.damage.D");
300 }/*}}}*/

◆ CreateVertices()

void CreateVertices ( Elements elements,
Vertices vertices,
IoModel iomodel,
int  solution_type,
bool  isamr 
)

Definition at line 301 of file CreateElementsVerticesAndMaterials.cpp.

301  {/*{{{*/
302 
303  /*Get element partitionning*/
304  int* epart = iomodel->epart;
305 
306  /*Determine element width*/
307  int elements_width;
308  switch(iomodel->meshelementtype){
309  case TriaEnum: elements_width=3; break;
310  case TetraEnum: elements_width=4; break;
311  case PentaEnum: elements_width=6; break;
312  default: _error_("mesh elements "<< EnumToStringx(iomodel->meshelementtype) <<" not supported yet");
313  }
314 
315  /*Get my_rank:*/
316  int my_rank = IssmComm::GetRank();
317  int num_procs = IssmComm::GetSize();
318 
319  /*create matrix that keeps track of all ranks that have vertex i, and initialize as -1 (Common to all CPUs)*/
320  int* vertices_ranks = xNew<int>(MAXCONNECTIVITY*iomodel->numberofvertices);
321  for(int i=0;i<MAXCONNECTIVITY*iomodel->numberofvertices;i++) vertices_ranks[i] = -1;
322 
323  /*For all vertices, count how many cpus hold vertex i (initialize with 0)*/
324  int* vertices_proc_count = xNewZeroInit<int>(iomodel->numberofvertices);
325 
326  /*Go through all elements and mark all vertices for all partitions*/
327  for(int i=0;i<iomodel->numberofelements;i++){
328  for(int j=0;j<elements_width;j++){
329  /*Get current vertex sid*/
330  int vid = iomodel->elements[elements_width*i+j]-1;
331  AddVertexToRank(vertices_ranks,vertices_proc_count,vid,epart[i]);
332  }
333  }
334 
335  /*Take care of penalties (only in non-AMR for now)*/
336  if(!isamr){
337  int numvertex_pairing;
338  int *vertex_pairing = NULL;
339  iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,"md.stressbalance.vertex_pairing");
340  for(int i=0;i<numvertex_pairing;i++){
341  int id1 = vertex_pairing[2*i+0]-1;
342  int id2 = vertex_pairing[2*i+1]-1;
343  for(int e=0;e<num_procs;e++){
344  if(IsVertexInRank(vertices_ranks,vertices_proc_count,id1,e)){
345  AddVertexToRank(vertices_ranks,vertices_proc_count,id2,e);
346  }
347  }
348  }
349  xDelete<int>(vertex_pairing);
350  iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,"md.masstransport.vertex_pairing");
351  for(int i=0;i<numvertex_pairing;i++){
352  int id1 = vertex_pairing[2*i+0]-1;
353  int id2 = vertex_pairing[2*i+1]-1;
354  for(int e=0;e<num_procs;e++){
355  if(IsVertexInRank(vertices_ranks,vertices_proc_count,id1,e)){
356  AddVertexToRank(vertices_ranks,vertices_proc_count,id2,e);
357  }
358  }
359  }
360  xDelete<int>(vertex_pairing);
361  }
362 
363  /*Create vector of size total numnodes, initialized with -1, that will keep track of local ids*/
364  int offset = 0;
365  int* vertices_offsets = xNew<int>(iomodel->numberofvertices);
366  for(int i=0;i<iomodel->numberofvertices;i++){
367  if(IsVertexInRank(vertices_ranks,vertices_proc_count,i,my_rank)){
368  vertices_offsets[i] = offset++;
369  }
370  else{
371  vertices_offsets[i] = -1;
372  }
373  }
374 
375  /*Now, Count how many clones we have with other partitions*/
376  int* common_send = xNew<int>(num_procs);
377  int* common_recv = xNew<int>(num_procs);
378  int** common_send_ids = xNew<int*>(num_procs);
379  int** common_recv_ids = xNew<int*>(num_procs);
380 
381  /*First step: allocate, Step 2: populate*/
382  for(int step=0;step<2;step++){
383 
384  if(step==1){
385  /*Allocate send and receive arrays of ids now*/
386  for(int i=0;i<num_procs;i++){
387  _assert_(common_send[i]>=0 && common_recv[i]>=0);
388  common_send_ids[i] = xNew<int>(common_send[i]);
389  common_recv_ids[i] = xNew<int>(common_recv[i]);
390  }
391  }
392 
393  /*Re/Initialize counters to 0*/
394  for(int i=0;i<num_procs;i++){
395  common_recv[i]=0;
396  common_send[i]=0;
397  }
398 
399  /*Go through table and find clones/masters etc*/
400  for(int i=0;i<iomodel->numberofvertices;i++){
401 
402  /*If we did not find this vertex in our current partition, go to next vertex*/
403  if(vertices_offsets[i] == -1) continue;
404 
405  /*Find in what column this rank belongs*/
406  int col = -1;
407  for(int j=0;j<MAXCONNECTIVITY;j++){
408  if(vertices_ranks[MAXCONNECTIVITY*i+j] == my_rank){
409  col = j;
410  break;
411  }
412  }
413  _assert_(col!=-1);
414 
415  /*If col==0, it is either not on boundary, or a master*/
416  if(col==0){
417  /*1. is this vertex on the boundary? Skip if not*/
418  if(vertices_ranks[MAXCONNECTIVITY*i+col+1]==-1){
419  continue;
420  }
421  else{
422  for(int j=1;j<vertices_proc_count[i];j++){
423  _assert_(vertices_ranks[MAXCONNECTIVITY*i+j]>=0);
424  int rank = vertices_ranks[MAXCONNECTIVITY*i+j];
425  if(step==1){
426  common_send_ids[rank][common_send[rank]] = vertices_offsets[i];
427  }
428  common_send[rank]++;
429  }
430  }
431  }
432  else{
433  /*3. It is a slave, record that we need to receive for this cpu*/
434  int rank = vertices_ranks[MAXCONNECTIVITY*i+0];
435  if(step==1){
436  common_recv_ids[rank][common_recv[rank]] = vertices_offsets[i];
437  }
438  common_recv[rank]++;
439  }
440  }
441  }
442 
443  /*Create Vertices, depending on the constructor type: */
444  if(solution_type!=LoveSolutionEnum) CreateNumberNodeToElementConnectivity(iomodel);
445  if(!isamr){
446  bool isoceancoupling;
447  iomodel->FindConstant(&isoceancoupling,"md.transient.isoceancoupling");
448 
449  iomodel->FetchData(6,"md.mesh.x","md.mesh.y","md.mesh.z","md.geometry.base","md.geometry.thickness","md.mask.ice_levelset");
450  if (iomodel->domaintype == Domain3DsurfaceEnum) iomodel->FetchData(3,"md.mesh.lat","md.mesh.long","md.mesh.r");
451  if (isoceancoupling) iomodel->FetchData(2,"md.mesh.lat","md.mesh.long");
452 
453  for(int i=0;i<iomodel->numberofvertices;i++){
454  if(vertices_offsets[i]!=-1){
455  bool isclone = (vertices_ranks[MAXCONNECTIVITY*i+0]!=my_rank);
456  vertices->AddObject(new Vertex(i+1,i,isclone,iomodel,isamr));
457  }
458  }
459 
460  /*Free data: */
461  iomodel->DeleteData(6,"md.mesh.x","md.mesh.y","md.mesh.z","md.geometry.base","md.geometry.thickness","md.mask.ice_levelset");
462  if (iomodel->domaintype == Domain3DsurfaceEnum) iomodel->DeleteData(3,"md.mesh.lat","md.mesh.long","md.mesh.r");
463  if (isoceancoupling) iomodel->DeleteData(2,"md.mesh.lat","md.mesh.long");
464  }
465  else{
466  for(int i=0;i<iomodel->numberofvertices;i++){
467  if(vertices_offsets[i]!=-1){
468  bool isclone = (vertices_ranks[MAXCONNECTIVITY*i+0]!=my_rank);
469  vertices->AddObject(new Vertex(i+1,i,isclone,iomodel,isamr));
470  }
471  }
472  }
473  xDelete<int>(vertices_offsets);
474 
475  /*Final step, create my_vertices*/
476  _assert_(!iomodel->my_vertices);
477  iomodel->my_vertices = xNew<bool>(iomodel->numberofvertices);
478  for(int i=0;i<iomodel->numberofvertices;i++){
479  if(IsVertexInRank(vertices_ranks,vertices_proc_count,i,my_rank)){
480  iomodel->my_vertices[i] = true;
481  }
482  else{
483  iomodel->my_vertices[i] = false;
484  }
485  }
486 
487  /*Free data: */
488  xDelete<int>(vertices_ranks);
489  xDelete<int>(vertices_proc_count);
490 
491  /*Assign communicators*/
492  vertices->common_send=common_send;
493  vertices->common_recv=common_recv;
494  vertices->common_send_ids=common_send_ids;
495  vertices->common_recv_ids=common_recv_ids;
496 
497  /*Finalize Initialization*/
498  vertices->Finalize(iomodel);
499 }/*}}}*/
DataSet::Size
int Size()
Definition: DataSet.cpp:399
Vertices::common_recv
int * common_recv
Definition: Vertices.h:22
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
MaterialsRheologyEsbarEnum
@ MaterialsRheologyEsbarEnum
Definition: EnumDefinitions.h:650
TetraEnum
@ TetraEnum
Definition: EnumDefinitions.h:1300
Vertices::common_send
int * common_send
Definition: Vertices.h:24
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
MaterialsRheologyEcEnum
@ MaterialsRheologyEcEnum
Definition: EnumDefinitions.h:647
MathydroEnum
@ MathydroEnum
Definition: EnumDefinitions.h:1171
MaterialsRheologyEbarEnum
@ MaterialsRheologyEbarEnum
Definition: EnumDefinitions.h:646
Matestar
Definition: Matestar.h:24
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
MaterialsRheologyNEnum
@ MaterialsRheologyNEnum
Definition: EnumDefinitions.h:651
IsVertexInRank
bool IsVertexInRank(int *vertices_ranks, int *vertices_proc_count, int vid, int rank)
Definition: CreateElementsVerticesAndMaterials.cpp:12
Vertices::common_recv_ids
int ** common_recv_ids
Definition: Vertices.h:23
Penta
Definition: Penta.h:29
IoModel::my_vertices
bool * my_vertices
Definition: IoModel.h:72
ElementHook::hmaterial
Hook * hmaterial
Definition: ElementHook.h:17
MaterialsRheologyBbarEnum
@ MaterialsRheologyBbarEnum
Definition: EnumDefinitions.h:644
Element
Definition: Element.h:41
IoModel::numberofvertices
int numberofvertices
Definition: IoModel.h:99
IoModel::DeleteData
void DeleteData(int num,...)
Definition: IoModel.cpp:500
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
Tetra
Definition: Tetra.h:27
IoCodeToEnumNature
int IoCodeToEnumNature(int enum_in)
Definition: IoCodeConversions.cpp:270
MatestarEnum
@ MatestarEnum
Definition: EnumDefinitions.h:1168
MAXCONNECTIVITY
#define MAXCONNECTIVITY
Definition: CreateElementsVerticesAndMaterials.cpp:10
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
CreateNumberNodeToElementConnectivity
void CreateNumberNodeToElementConnectivity(IoModel *iomodel)
Definition: CreateNumberNodeToElementConnectivity.cpp:16
IssmComm::GetSize
static int GetSize(void)
Definition: IssmComm.cpp:46
MatdamageiceEnum
@ MatdamageiceEnum
Definition: EnumDefinitions.h:1165
Domain3DsurfaceEnum
@ Domain3DsurfaceEnum
Definition: EnumDefinitions.h:1039
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
DamageDEnum
@ DamageDEnum
Definition: EnumDefinitions.h:516
MaterialsRheologyEEnum
@ MaterialsRheologyEEnum
Definition: EnumDefinitions.h:645
IoModel::FetchData
void FetchData(bool *pboolean, const char *data_name)
Definition: IoModel.cpp:933
MaterialsRheologyEsEnum
@ MaterialsRheologyEsEnum
Definition: EnumDefinitions.h:649
IoModel::domaindim
int domaindim
Definition: IoModel.h:77
DamageDbarEnum
@ DamageDbarEnum
Definition: EnumDefinitions.h:518
Object::ObjectEnum
virtual int ObjectEnum()=0
MaterialsEnum
@ MaterialsEnum
Definition: EnumDefinitions.h:1167
LoveSolutionEnum
@ LoveSolutionEnum
Definition: EnumDefinitions.h:1155
MatlithoEnum
@ MatlithoEnum
Definition: EnumDefinitions.h:1170
Matice
Definition: Matice.h:24
IssmComm::GetRank
static int GetRank(void)
Definition: IssmComm.cpp:34
Vertices::Finalize
void Finalize(IoModel *iomodel)
Definition: Vertices.cpp:173
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Tria
Definition: Tria.h:29
MaterialsRheologyBEnum
@ MaterialsRheologyBEnum
Definition: EnumDefinitions.h:643
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
PentaEnum
@ PentaEnum
Definition: EnumDefinitions.h:1231
Matlitho
Definition: Matlitho.h:14
IoModel::FetchDataToInput
void FetchDataToInput(Inputs2 *inputs2, Elements *elements, const char *vector_name, int input_enum)
Definition: IoModel.cpp:1651
MatenhancediceEnum
@ MatenhancediceEnum
Definition: EnumDefinitions.h:1166
IoModel::epart
int * epart
Definition: IoModel.h:74
IoModel::elements
int * elements
Definition: IoModel.h:79
MaticeEnum
@ MaticeEnum
Definition: EnumDefinitions.h:1169
Vertex
Definition: Vertex.h:19
IoModel::meshelementtype
int meshelementtype
Definition: IoModel.h:91
MaterialsRheologyEcbarEnum
@ MaterialsRheologyEcbarEnum
Definition: EnumDefinitions.h:648
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
AddVertexToRank
void AddVertexToRank(int *vertices_ranks, int *vertices_proc_count, int vid, int rank)
Definition: CreateElementsVerticesAndMaterials.cpp:24
TriaEnum
@ TriaEnum
Definition: EnumDefinitions.h:1318
Vertices::common_send_ids
int ** common_send_ids
Definition: Vertices.h:25
Inputs2::DuplicateInput
void DuplicateInput(int original_enum, int new_enum)
Definition: Inputs2.cpp:206