Changeset 17674
- Timestamp:
- 04/08/14 14:59:42 (11 years ago)
- Location:
- issm/trunk-jpl/src
- Files:
-
- 2 added
- 164 edited
Legend:
- Unmodified
- Added
- Removed
-
issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp
r17585 r17674 6 6 7 7 /*Model processor*/ 8 int AdjointBalancethicknessAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int AdjointBalancethicknessAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 49 49 50 50 /*Intermediaries*/ 51 int mesh type;51 int meshxdim; 52 52 Element* basalelement; 53 53 54 54 /*Get basal element*/ 55 element->FindParam(&mesh type,MeshTypeEnum);56 switch(mesh type){55 element->FindParam(&meshxdim,MeshXDimEnum); 56 switch(meshxdim){ 57 57 case Mesh2DhorizontalEnum: 58 58 basalelement = element; … … 62 62 basalelement = element->SpawnBasalElement(); 63 63 break; 64 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");64 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 65 65 } 66 66 … … 143 143 xDelete<IssmDouble>(basis); 144 144 xDelete<IssmDouble>(dbasis); 145 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};145 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 146 146 delete gauss; 147 147 return pe; … … 152 152 void AdjointBalancethicknessAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 153 153 154 int mesh type;155 element->FindParam(&mesh type,MeshTypeEnum);156 switch(mesh type){154 int meshxdim; 155 element->FindParam(&meshxdim,MeshXDimEnum); 156 switch(meshxdim){ 157 157 case Mesh2DhorizontalEnum: 158 158 element->InputUpdateFromSolutionOneDof(solution,AdjointEnum); … … 161 161 element->InputUpdateFromSolutionOneDofCollapsed(solution,AdjointEnum); 162 162 break; 163 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");163 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 164 164 } 165 165 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp
r17609 r17674 6 6 7 7 /*Model processing*/ 8 int AdjointHorizAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int AdjointHorizAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 _error_("not implemented"); 10 10 }/*}}}*/ … … 55 55 56 56 /*Intermediaries*/ 57 int mesh type;57 int meshxdim; 58 58 Element* basalelement; 59 59 60 60 /*Get basal element*/ 61 element->FindParam(&mesh type,MeshTypeEnum);62 switch(mesh type){61 element->FindParam(&meshxdim,MeshXDimEnum); 62 switch(meshxdim){ 63 63 case Mesh2DhorizontalEnum: 64 64 basalelement = element; … … 68 68 basalelement = element->SpawnBasalElement(); 69 69 break; 70 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");70 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 71 71 } 72 72 … … 87 87 delete analysis; 88 88 if(incomplete_adjoint){ 89 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};89 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 90 90 return Ke; 91 91 } … … 136 136 xDelete<IssmDouble>(dbasis); 137 137 xDelete<IssmDouble>(xyz_list); 138 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};138 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 139 139 return Ke; 140 140 }/*}}}*/ … … 304 304 305 305 /*Intermediaries */ 306 int num_responses,i,mesh type,dim;306 int num_responses,i,meshxdim,dim; 307 307 IssmDouble Jdet,obs_velocity_mag,velocity_mag; 308 308 IssmDouble vx,vy,vxobs,vyobs,dux,duy,weight; … … 312 312 313 313 /*Get problem dimension*/ 314 element->FindParam(&mesh type,MeshTypeEnum);315 switch(mesh type){314 element->FindParam(&meshxdim,MeshXDimEnum); 315 switch(meshxdim){ 316 316 case Mesh2DverticalEnum: dim = 2; break; 317 317 case Mesh3DEnum: dim = 3; break; 318 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");318 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 319 319 } 320 320 … … 684 684 685 685 /*Intermediaries*/ 686 int mesh type;686 int meshxdim; 687 687 Element* basalelement; 688 688 689 689 /*Get basal element*/ 690 element->FindParam(&mesh type,MeshTypeEnum);691 switch(mesh type){690 element->FindParam(&meshxdim,MeshXDimEnum); 691 switch(meshxdim){ 692 692 case Mesh2DhorizontalEnum: 693 693 basalelement = element; … … 697 697 basalelement = element->SpawnBasalElement(); 698 698 break; 699 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");699 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 700 700 } 701 701 … … 875 875 xDelete<IssmDouble>(xyz_list); 876 876 xDelete<IssmDouble>(basis); 877 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};877 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 878 878 delete gauss; 879 879 return pe; -
issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/Analysis.h
r17212 r17674 25 25 26 26 /*Model processing*/ 27 virtual int DofsPerNode(int** doflist,int mesh type,int approximation)=0;27 virtual int DofsPerNode(int** doflist,int meshxdim,int approximation)=0; 28 28 virtual void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum)=0; 29 29 virtual void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type)=0; -
issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int BalancethicknessAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int BalancethicknessAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 44 44 iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum); 45 45 46 if(iomodel->mesh type==Mesh3DEnum){46 if(iomodel->meshxdim==Mesh3DEnum){ 47 47 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 48 48 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); … … 55 55 56 56 /*Check in 3d*/ 57 if(stabilization==3 && iomodel->mesh type==Mesh3DEnum) _error_("DG 3d not implemented yet");57 if(stabilization==3 && iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet"); 58 58 59 59 /*First fetch data: */ 60 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);60 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 61 61 if(stabilization!=3){ 62 62 ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1Enum); … … 141 141 } 142 142 143 int mesh type;144 element->FindParam(&mesh type,MeshTypeEnum);145 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};143 int meshxdim; 144 element->FindParam(&meshxdim,MeshXDimEnum); 145 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 146 146 return Ke; 147 147 }/*}}}*/ … … 150 150 /*Intermediaries */ 151 151 int stabilization; 152 int mesh type;152 int meshxdim; 153 153 IssmDouble Jdet,D_scalar,h; 154 154 IssmDouble vel,vx,vy,dvxdx,dvydy; … … 167 167 /*Retrieve all inputs and parameters*/ 168 168 element->GetVerticesCoordinates(&xyz_list); 169 element->FindParam(&mesh type,MeshTypeEnum);169 element->FindParam(&meshxdim,MeshXDimEnum); 170 170 element->FindParam(&stabilization,BalancethicknessStabilizationEnum); 171 171 Input* vxaverage_input=NULL; 172 172 Input* vyaverage_input=NULL; 173 if(mesh type==Mesh2DhorizontalEnum){173 if(meshxdim==Mesh2DhorizontalEnum){ 174 174 vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); 175 175 vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); … … 253 253 254 254 /*Intermediaries */ 255 int mesh type;255 int meshxdim; 256 256 IssmDouble Jdet,D_scalar,vx,vy,dvxdx,dvydy,vel; 257 257 IssmDouble dvx[2],dvy[2]; … … 269 269 /*Retrieve all inputs and parameters*/ 270 270 element->GetVerticesCoordinates(&xyz_list); 271 element->FindParam(&mesh type,MeshTypeEnum);271 element->FindParam(&meshxdim,MeshXDimEnum); 272 272 Input* vxaverage_input=NULL; 273 273 Input* vyaverage_input=NULL; 274 if(mesh type==Mesh2DhorizontalEnum){274 if(meshxdim==Mesh2DhorizontalEnum){ 275 275 vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); 276 276 vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); … … 333 333 } 334 334 335 int mesh type;336 element->FindParam(&mesh type,MeshTypeEnum);337 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};335 int meshxdim; 336 element->FindParam(&meshxdim,MeshXDimEnum); 337 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 338 338 return pe; 339 339 }/*}}}*/ … … 480 480 void BalancethicknessAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 481 481 482 int mesh type;483 element->FindParam(&mesh type,MeshTypeEnum);484 switch(mesh type){482 int meshxdim; 483 element->FindParam(&meshxdim,MeshXDimEnum); 484 switch(meshxdim){ 485 485 case Mesh2DhorizontalEnum: 486 486 element->InputUpdateFromSolutionOneDof(solution,ThicknessEnum); … … 489 489 element->InputUpdateFromSolutionOneDofCollapsed(solution,ThicknessEnum); 490 490 break; 491 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");491 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 492 492 } 493 493 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/BalancethicknessSoftAnalysis.cpp
r17212 r17674 6 6 7 7 /*Model processing*/ 8 int BalancethicknessSoftAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int BalancethicknessSoftAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 _error_("not implemented"); 10 10 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/BalancethicknessSoftAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int BalancevelocityAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int BalancevelocityAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 33 33 iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum); 34 34 35 if(iomodel->mesh type==Mesh3DEnum){35 if(iomodel->meshxdim==Mesh3DEnum){ 36 36 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 37 37 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); … … 41 41 42 42 /*Check in 3d*/ 43 if(iomodel->mesh type==Mesh3DEnum) _error_("DG 3d not implemented yet");43 if(iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet"); 44 44 45 45 /*First fetch data: */ … … 148 148 149 149 /*Intermediaries*/ 150 int mesh type;150 int meshxdim; 151 151 Element* basalelement; 152 152 153 153 /*Get basal element*/ 154 element->FindParam(&mesh type,MeshTypeEnum);155 switch(mesh type){154 element->FindParam(&meshxdim,MeshXDimEnum); 155 switch(meshxdim){ 156 156 case Mesh2DhorizontalEnum: 157 157 basalelement = element; … … 161 161 basalelement = element->SpawnBasalElement(); 162 162 break; 163 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");163 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 164 164 } 165 165 … … 235 235 xDelete<IssmDouble>(Ny); 236 236 delete gauss; 237 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};237 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 238 238 return pe; 239 239 }/*}}}*/ … … 243 243 void BalancevelocityAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 244 244 245 int mesh type;246 element->FindParam(&mesh type,MeshTypeEnum);247 switch(mesh type){245 int meshxdim; 246 element->FindParam(&meshxdim,MeshXDimEnum); 247 switch(meshxdim){ 248 248 case Mesh2DhorizontalEnum: 249 249 element->InputUpdateFromSolutionOneDof(solution,VelEnum); … … 252 252 element->InputUpdateFromSolutionOneDofCollapsed(solution,VelEnum); 253 253 break; 254 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");254 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 255 255 } 256 256 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp
r17646 r17674 6 6 7 7 /*Model processing*/ 8 int DamageEvolutionAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int DamageEvolutionAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 60 60 iomodel->FetchDataToInput(elements,VxEnum); 61 61 iomodel->FetchDataToInput(elements,VyEnum); 62 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum);62 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum); 63 63 iomodel->FetchDataToInput(elements,DamageDEnum); 64 64 iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); … … 73 73 void DamageEvolutionAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 74 74 75 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);75 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); 76 76 ::CreateNodes(nodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum); 77 77 iomodel->DeleteData(1,MeshVertexonbaseEnum); … … 109 109 /*Intermediaries*/ 110 110 Element* basalelement; 111 int mesh type,dim;111 int meshxdim,dim; 112 112 int stabilization; 113 113 IssmDouble Jdet,dt,D_scalar,h; … … 116 116 117 117 /*Get problem dimension and basal element*/ 118 element->FindParam(&mesh type,MeshTypeEnum);119 switch(mesh type){118 element->FindParam(&meshxdim,MeshXDimEnum); 119 switch(meshxdim){ 120 120 case Mesh2DhorizontalEnum: 121 121 basalelement = element; … … 127 127 dim = 2; 128 128 break; 129 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");129 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 130 130 } 131 131 … … 146 146 Input* vxaverage_input=NULL; 147 147 Input* vyaverage_input=NULL; 148 if(mesh type==Mesh2DhorizontalEnum){148 if(meshxdim==Mesh2DhorizontalEnum){ 149 149 vxaverage_input=basalelement->GetInput(VxEnum); _assert_(vxaverage_input); 150 150 vyaverage_input=basalelement->GetInput(VyEnum); _assert_(vyaverage_input); … … 249 249 xDelete<IssmDouble>(D); 250 250 delete gauss; 251 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};251 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 252 252 return Ke; 253 253 }/*}}}*/ … … 258 258 259 259 /*Intermediaries*/ 260 int mesh type;260 int meshxdim; 261 261 Element* basalelement; 262 262 IssmDouble Jdet,dt; … … 265 265 266 266 /*Get basal element*/ 267 element->FindParam(&mesh type,MeshTypeEnum);268 switch(mesh type){267 element->FindParam(&meshxdim,MeshXDimEnum); 268 switch(meshxdim){ 269 269 case Mesh2DhorizontalEnum: 270 270 basalelement = element; … … 274 274 basalelement = element->SpawnBasalElement(); 275 275 break; 276 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");276 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 277 277 } 278 278 … … 311 311 xDelete<IssmDouble>(xyz_list); 312 312 xDelete<IssmDouble>(basis); 313 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};313 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 314 314 delete gauss; 315 315 return pe; … … 377 377 void DamageEvolutionAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 378 378 379 int mesh type;379 int meshxdim; 380 380 IssmDouble max_damage; 381 381 int *doflist = NULL; 382 382 Element* basalelement=NULL; 383 383 384 element->FindParam(&mesh type,MeshTypeEnum);385 if(mesh type!=Mesh2DhorizontalEnum){384 element->FindParam(&meshxdim,MeshXDimEnum); 385 if(meshxdim!=Mesh2DhorizontalEnum){ 386 386 if(!element->IsOnBase()) return; 387 387 basalelement=element->SpawnBasalElement(); … … 416 416 xDelete<IssmDouble>(newdamage); 417 417 xDelete<int>(doflist); 418 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};418 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 419 419 }/*}}}*/ 420 420 void DamageEvolutionAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ -
issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.h
r17391 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int DepthAverageAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int DepthAverageAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 22 22 } 23 23 24 if(iomodel->mesh type==Mesh2DverticalEnum){24 if(iomodel->meshxdim==Mesh2DverticalEnum){ 25 25 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 26 26 } … … 54 54 55 55 /*Get dimension*/ 56 int dim,mesh type;57 element->FindParam(&mesh type,MeshTypeEnum);58 switch(mesh type){56 int dim,meshxdim; 57 element->FindParam(&meshxdim,MeshXDimEnum); 58 switch(meshxdim){ 59 59 case Mesh2DverticalEnum: dim = 2; break; 60 60 case Mesh3DEnum: dim = 3; break; 61 61 case Mesh3DtetrasEnum: dim = 3; break; 62 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");62 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 63 63 } 64 64 -
issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.h
r17494 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int EnthalpyAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int EnthalpyAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 29 29 30 30 /*Now, is the model 3d? otherwise, do nothing: */ 31 if(iomodel->mesh type==Mesh2DhorizontalEnum)return;31 if(iomodel->meshxdim==Mesh2DhorizontalEnum)return; 32 32 33 33 /*Is enthalpy requested?*/ … … 94 94 void EnthalpyAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 95 95 96 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);96 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 97 97 ::CreateNodes(nodes,iomodel,EnthalpyAnalysisEnum,P1Enum); 98 98 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 117 117 118 118 /*return if 2d mesh*/ 119 if(iomodel->mesh type==Mesh2DhorizontalEnum) return;119 if(iomodel->meshxdim==Mesh2DhorizontalEnum) return; 120 120 121 121 /*Fetch data: */ -
issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/EnumToAnalysis.h
r17212 r17674 8 8 #endif 9 9 /*Model processing*/ 10 int DofsPerNode(int** doflist,int mesh type,int approximation);10 int DofsPerNode(int** doflist,int meshxdim,int approximation); 11 11 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 12 12 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp
r17610 r17674 6 6 #include "../solutionsequences/solutionsequences.h" 7 7 8 int ExtrapolationAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int ExtrapolationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 } … … 30 30 } 31 31 } 32 if(iomodel->mesh type==Mesh3DEnum){32 if(iomodel->meshxdim==Mesh3DEnum){ 33 33 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 34 34 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); … … 38 38 void ExtrapolationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 39 39 int finiteelement=P1Enum; 40 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);40 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 41 41 ::CreateNodes(nodes,iomodel,ExtrapolationAnalysisEnum,finiteelement); 42 42 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 88 88 89 89 /*Intermediaries */ 90 int mesh type,dim;90 int meshxdim,dim; 91 91 int i,row,col,stabilization; 92 92 bool extrapolatebydiffusion = true; … … 97 97 98 98 /*Get problem dimension*/ 99 basalelement->FindParam(&mesh type,MeshTypeEnum);100 switch(mesh type){99 basalelement->FindParam(&meshxdim,MeshXDimEnum); 100 switch(meshxdim){ 101 101 case Mesh2DverticalEnum: dim = 1; break; 102 102 case Mesh2DhorizontalEnum: dim = 2; break; 103 103 case Mesh3DEnum: dim = 2; break; 104 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");104 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 105 105 } 106 106 … … 213 213 xDelete<IssmDouble>(normal); 214 214 delete gauss; 215 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};215 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 216 216 return Ke; 217 217 … … 223 223 224 224 /*Intermediaries */ 225 int i, mesh type;225 int i, meshxdim; 226 226 227 227 /*Fetch number of nodes */ … … 233 233 pe->values[i]=0.; 234 234 235 basalelement->FindParam(&mesh type,MeshTypeEnum);236 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};235 basalelement->FindParam(&meshxdim,MeshXDimEnum); 236 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 237 237 return pe; 238 238 }/*}}}*/ … … 242 242 void ExtrapolationAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 243 243 244 int mesh type, extrapolationvariable;245 element->FindParam(&mesh type,MeshTypeEnum);244 int meshxdim, extrapolationvariable; 245 element->FindParam(&meshxdim,MeshXDimEnum); 246 246 element->FindParam(&extrapolationvariable, ExtrapolationVariableEnum); 247 switch(mesh type){247 switch(meshxdim){ 248 248 case Mesh2DhorizontalEnum: 249 249 element->InputUpdateFromSolutionOneDof(solution,extrapolationvariable); … … 252 252 element->InputUpdateFromSolutionOneDofCollapsed(solution,extrapolationvariable); 253 253 break; 254 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");254 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 255 255 } 256 256 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int ExtrudeFromBaseAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int ExtrudeFromBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 22 22 } 23 23 24 if(iomodel->mesh type==Mesh2DverticalEnum){24 if(iomodel->meshxdim==Mesh2DverticalEnum){ 25 25 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 26 26 } … … 68 68 69 69 /*Get dimension*/ 70 int dim,mesh type;71 element->FindParam(&mesh type,MeshTypeEnum);72 switch(mesh type){70 int dim,meshxdim; 71 element->FindParam(&meshxdim,MeshXDimEnum); 72 switch(meshxdim){ 73 73 case Mesh2DverticalEnum: dim = 2; break; 74 74 case Mesh3DEnum: dim = 3; break; 75 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");75 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 76 76 } 77 77 … … 120 120 121 121 /*Get dimension*/ 122 int dim,mesh type;123 element->FindParam(&mesh type,MeshTypeEnum);124 switch(mesh type){122 int dim,meshxdim; 123 element->FindParam(&meshxdim,MeshXDimEnum); 124 switch(meshxdim){ 125 125 case Mesh2DverticalEnum: dim = 2; break; 126 126 case Mesh3DEnum: dim = 3; break; 127 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");127 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 128 128 } 129 129 … … 170 170 171 171 /*Get dimension*/ 172 int dim,mesh type;173 element->FindParam(&mesh type,MeshTypeEnum);174 switch(mesh type){172 int dim,meshxdim; 173 element->FindParam(&meshxdim,MeshXDimEnum); 174 switch(meshxdim){ 175 175 case Mesh2DverticalEnum: dim = 2; break; 176 176 case Mesh3DEnum: dim = 3; break; 177 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");177 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 178 178 } 179 179 -
issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int ExtrudeFromTopAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int ExtrudeFromTopAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 22 22 } 23 23 24 if(iomodel->mesh type==Mesh2DverticalEnum){24 if(iomodel->meshxdim==Mesh2DverticalEnum){ 25 25 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 26 26 } … … 64 64 65 65 /*Intermediaries */ 66 int mesh type,dim;66 int meshxdim,dim; 67 67 IssmDouble Jdet,D; 68 68 IssmDouble *xyz_list = NULL; 69 69 70 70 /*Get dimension*/ 71 element->FindParam(&mesh type,MeshTypeEnum);72 switch(mesh type){71 element->FindParam(&meshxdim,MeshXDimEnum); 72 switch(meshxdim){ 73 73 case Mesh2DverticalEnum: dim = 2; break; 74 74 case Mesh3DEnum: dim = 3; break; 75 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");75 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 76 76 } 77 77 … … 120 120 121 121 /*Get dimension*/ 122 int dim,mesh type;123 element->FindParam(&mesh type,MeshTypeEnum);124 switch(mesh type){122 int dim,meshxdim; 123 element->FindParam(&meshxdim,MeshXDimEnum); 124 switch(meshxdim){ 125 125 case Mesh2DverticalEnum: dim = 2; break; 126 126 case Mesh3DEnum: dim = 3; break; 127 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");127 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 128 128 } 129 129 … … 170 170 171 171 /*Get dimension*/ 172 int dim,mesh type;173 element->FindParam(&mesh type,MeshTypeEnum);174 switch(mesh type){172 int dim,meshxdim; 173 element->FindParam(&meshxdim,MeshXDimEnum); 174 switch(meshxdim){ 175 175 case Mesh2DverticalEnum: dim = 2; break; 176 176 case Mesh3DEnum: dim = 3; break; 177 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");177 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 178 178 } 179 179 -
issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int FreeSurfaceBaseAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int FreeSurfaceBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 14 14 15 15 /*Now, is the model 3d? otherwise, do nothing: */ 16 if (iomodel->mesh type==Mesh2DhorizontalEnum)return;16 if (iomodel->meshxdim==Mesh2DhorizontalEnum)return; 17 17 18 18 /*Finite element type*/ … … 35 35 iomodel->FetchDataToInput(elements,VxEnum); 36 36 iomodel->FetchDataToInput(elements,VyEnum); 37 if(iomodel->mesh type==Mesh3DEnum){37 if(iomodel->meshxdim==Mesh3DEnum){ 38 38 iomodel->FetchDataToInput(elements,VzEnum); 39 39 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); … … 43 43 void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 44 44 45 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);45 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 46 46 ::CreateNodes(nodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum); 47 47 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 60 60 IssmDouble *nodeonbase=NULL; 61 61 iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); 62 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);62 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); 63 63 for(int i=0;i<numvertex_pairing;i++){ 64 64 … … 69 69 70 70 /*Skip if one of the two is not on the bed*/ 71 if(iomodel->mesh type!=Mesh2DhorizontalEnum){71 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 72 72 if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue; 73 73 } … … 105 105 106 106 /*Intermediaries*/ 107 int mesh type,dim,stabilization;107 int meshxdim,dim,stabilization; 108 108 Element* basalelement = NULL; 109 109 IssmDouble *xyz_list = NULL; … … 112 112 113 113 /*Get basal element*/ 114 element->FindParam(&mesh type,MeshTypeEnum);115 switch(mesh type){114 element->FindParam(&meshxdim,MeshXDimEnum); 115 switch(meshxdim){ 116 116 case Mesh2DhorizontalEnum: 117 117 basalelement = element; … … 128 128 dim = 2; 129 129 break; 130 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");130 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 131 131 } 132 132 … … 223 223 xDelete<IssmDouble>(D); 224 224 delete gauss; 225 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};225 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 226 226 return Ke; 227 227 }/*}}}*/ 228 228 ElementVector* FreeSurfaceBaseAnalysis::CreatePVector(Element* element){/*{{{*/ 229 229 /*Intermediaries*/ 230 int mesh type,dim;230 int meshxdim,dim; 231 231 IssmDouble Jdet,dt; 232 232 IssmDouble mb,mb_correction,bed,vz; … … 235 235 236 236 /*Get basal element*/ 237 element->FindParam(&mesh type,MeshTypeEnum);238 switch(mesh type){237 element->FindParam(&meshxdim,MeshXDimEnum); 238 switch(meshxdim){ 239 239 case Mesh2DhorizontalEnum: 240 240 basalelement = element; … … 251 251 dim = 2; 252 252 break; 253 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");253 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 254 254 } 255 255 … … 298 298 xDelete<IssmDouble>(basis); 299 299 delete gauss; 300 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};300 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 301 301 return pe; 302 302 -
issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 14 14 15 15 /*Now, is the model 3d? otherwise, do nothing: */ 16 if (iomodel->mesh type==Mesh2DhorizontalEnum)return;16 if (iomodel->meshxdim==Mesh2DhorizontalEnum)return; 17 17 18 18 int smb_model; … … 35 35 iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); 36 36 iomodel->FetchDataToInput(elements,VxEnum); 37 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);38 if(iomodel->mesh type==Mesh3DEnum){37 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); 38 if(iomodel->meshxdim==Mesh3DEnum){ 39 39 iomodel->FetchDataToInput(elements,VzEnum); 40 40 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); … … 52 52 void FreeSurfaceTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 53 53 54 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);54 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 55 55 ::CreateNodes(nodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum); 56 56 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 69 69 IssmDouble *nodeonsurface=NULL; 70 70 iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); 71 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum);71 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum); 72 72 for(int i=0;i<numvertex_pairing;i++){ 73 73 … … 78 78 79 79 /*Skip if one of the two is not on the bed*/ 80 if(iomodel->mesh type!=Mesh2DhorizontalEnum){80 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 81 81 if(!(reCast<bool>(nodeonsurface[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonsurface[reCast<int>(vertex_pairing[2*i+1])-1]))) continue; 82 82 } … … 114 114 115 115 /*Intermediaries*/ 116 int mesh type,dim,stabilization;116 int meshxdim,dim,stabilization; 117 117 Element* topelement = NULL; 118 118 IssmDouble *xyz_list = NULL; … … 121 121 122 122 /*Get top element*/ 123 element->FindParam(&mesh type,MeshTypeEnum);124 switch(mesh type){123 element->FindParam(&meshxdim,MeshXDimEnum); 124 switch(meshxdim){ 125 125 case Mesh2DhorizontalEnum: 126 126 topelement = element; … … 137 137 dim = 2; 138 138 break; 139 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");139 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 140 140 } 141 141 … … 232 232 xDelete<IssmDouble>(D); 233 233 delete gauss; 234 if(mesh type!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};234 if(meshxdim!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;}; 235 235 return Ke; 236 236 }/*}}}*/ 237 237 ElementVector* FreeSurfaceTopAnalysis::CreatePVector(Element* element){/*{{{*/ 238 238 /*Intermediaries*/ 239 int mesh type,dim;239 int meshxdim,dim; 240 240 IssmDouble Jdet,dt; 241 241 IssmDouble ms,surface,vz; … … 244 244 245 245 /*Get top element*/ 246 element->FindParam(&mesh type,MeshTypeEnum);247 switch(mesh type){246 element->FindParam(&meshxdim,MeshXDimEnum); 247 switch(meshxdim){ 248 248 case Mesh2DhorizontalEnum: 249 249 topelement = element; … … 260 260 dim = 2; 261 261 break; 262 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");262 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 263 263 } 264 264 … … 302 302 xDelete<IssmDouble>(basis); 303 303 delete gauss; 304 if(mesh type!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};304 if(meshxdim!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;}; 305 305 return pe; 306 306 -
issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/GiaAnalysis.cpp
r17212 r17674 6 6 7 7 /*Model processing*/ 8 int GiaAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int GiaAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/GiaAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int HydrologyDCEfficientAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int HydrologyDCEfficientAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 56 56 iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum); 57 57 iomodel->FetchDataToInput(elements,HydrologydcEplThicknessEnum); 58 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);58 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 59 59 60 60 // elements->InputDuplicate(HydrologydcEplInitialThicknessEnum,HydrologydcEplThicknessEnum); … … 73 73 if(!isefficientlayer) return; 74 74 75 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);75 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 76 76 ::CreateNodes(nodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum); 77 77 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 111 111 /*Intermediaries*/ 112 112 bool active_element; 113 int mesh type;113 int meshxdim; 114 114 Element* basalelement; 115 115 116 116 /*Get basal element*/ 117 element->FindParam(&mesh type,MeshTypeEnum);118 switch(mesh type){117 element->FindParam(&meshxdim,MeshXDimEnum); 118 switch(meshxdim){ 119 119 case Mesh2DhorizontalEnum: 120 120 basalelement = element; … … 124 124 basalelement = element->SpawnBasalElement(); 125 125 break; 126 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");126 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 127 127 } 128 128 … … 132 132 /*Check that all nodes are active, else return empty matrix*/ 133 133 if(!active_element) { 134 if(mesh type!=Mesh2DhorizontalEnum){134 if(meshxdim!=Mesh2DhorizontalEnum){ 135 135 basalelement->DeleteMaterials(); 136 136 delete basalelement; … … 207 207 xDelete<IssmDouble>(B); 208 208 delete gauss; 209 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};209 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 210 210 return Ke; 211 211 … … 215 215 /*Intermediaries*/ 216 216 bool active_element; 217 int mesh type;217 int meshxdim; 218 218 Element* basalelement; 219 219 220 220 /*Get basal element*/ 221 element->FindParam(&mesh type,MeshTypeEnum);222 switch(mesh type){221 element->FindParam(&meshxdim,MeshXDimEnum); 222 switch(meshxdim){ 223 223 case Mesh2DhorizontalEnum: 224 224 basalelement = element; … … 228 228 basalelement = element->SpawnBasalElement(); 229 229 break; 230 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");230 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 231 231 } 232 232 … … 236 236 /*Check that all nodes are active, else return empty matrix*/ 237 237 if(!active_element) { 238 if(mesh type!=Mesh2DhorizontalEnum){238 if(meshxdim!=Mesh2DhorizontalEnum){ 239 239 basalelement->DeleteMaterials(); 240 240 delete basalelement; … … 309 309 xDelete<IssmDouble>(basis); 310 310 delete gauss; 311 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};311 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 312 312 return pe; 313 313 }/*}}}*/ … … 317 317 void HydrologyDCEfficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 318 318 319 int mesh type,i;319 int meshxdim,i; 320 320 Element* basalelement=NULL; 321 321 322 element->FindParam(&mesh type,MeshTypeEnum);323 324 if(mesh type!=Mesh2DhorizontalEnum){322 element->FindParam(&meshxdim,MeshXDimEnum); 323 324 if(meshxdim!=Mesh2DhorizontalEnum){ 325 325 if(!element->IsOnBase()) return; 326 326 basalelement=element->SpawnBasalElement(); … … 351 351 xDelete<IssmDouble>(eplHeads); 352 352 xDelete<int>(doflist); 353 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};353 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 354 354 } /*}}}*/ 355 355 void HydrologyDCEfficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ … … 481 481 482 482 bool active_element; 483 int mesh type;483 int meshxdim; 484 484 IssmDouble dt,A,B; 485 485 IssmDouble EPLgrad2; 486 486 IssmDouble EPL_N; 487 487 488 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);488 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 489 489 490 490 for(int j=0;j<femmodel->elements->Size();j++){ … … 492 492 Element* element=(Element*)femmodel->elements->GetObjectByOffset(j); 493 493 494 switch(mesh type){494 switch(meshxdim){ 495 495 case Mesh2DhorizontalEnum: 496 496 if(!element->IsOnBase()) return; … … 602 602 bool active_element; 603 603 int i,j; 604 int mesh type;604 int meshxdim; 605 605 IssmDouble h_max; 606 606 IssmDouble sedheadmin; … … 608 608 609 609 /*Get basal element*/ 610 element->FindParam(&mesh type,MeshTypeEnum);611 switch(mesh type){610 element->FindParam(&meshxdim,MeshXDimEnum); 611 switch(meshxdim){ 612 612 case Mesh2DhorizontalEnum: 613 613 basalelement = element; … … 617 617 basalelement = element->SpawnBasalElement(); 618 618 break; 619 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");619 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 620 620 } 621 621 … … 673 673 } 674 674 } 675 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};675 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 676 676 xDelete<IssmDouble>(epl_thickness); 677 677 xDelete<IssmDouble>(old_active); … … 684 684 /*Constants*/ 685 685 686 int mesh type;686 int meshxdim; 687 687 Element* basalelement=NULL; 688 688 689 689 /*Get basal element*/ 690 element->FindParam(&mesh type,MeshTypeEnum);691 switch(mesh type){690 element->FindParam(&meshxdim,MeshXDimEnum); 691 switch(meshxdim){ 692 692 case Mesh2DhorizontalEnum: 693 693 basalelement = element; … … 697 697 basalelement = element->SpawnBasalElement(); 698 698 break; 699 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");699 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 700 700 } 701 701 … … 716 716 /*Do not do anything: at least one node is active for this element but this element is not solved for*/ 717 717 } 718 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};718 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 719 719 xDelete<IssmDouble>(active); 720 720 } -
issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.h
r17375 r17674 14 14 public: 15 15 /*Model processing*/ 16 int DofsPerNode(int** doflist,int mesh type,int approximation);16 int DofsPerNode(int** doflist,int meshxdim,int approximation); 17 17 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 18 18 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp
r17610 r17674 7 7 8 8 /*Model processing*/ 9 int HydrologyDCInefficientAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/9 int HydrologyDCInefficientAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 10 10 return 1; 11 11 }/*}}}*/ … … 88 88 iomodel->FetchDataToInput(elements,SedimentHeadEnum); 89 89 iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum); 90 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);90 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 91 91 92 92 if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveNodeEnum); … … 101 101 if(hydrology_model!=HydrologydcEnum) return; 102 102 103 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);103 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 104 104 ::CreateNodes(nodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum); 105 105 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 121 121 if(hydrology_model!=HydrologydcEnum) return; 122 122 123 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);123 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); 124 124 125 125 //create penalties for nodes: no node can have water above the max 126 126 CreateSingleNodeToElementConnectivity(iomodel); 127 127 for(int i=0;i<iomodel->numberofvertices;i++){ 128 if (iomodel->mesh type!=Mesh3DEnum){128 if (iomodel->meshxdim!=Mesh3DEnum){ 129 129 /*keep only this partition's nodes:*/ 130 130 if(iomodel->my_vertices[i]){ … … 155 155 156 156 /*Intermediaries*/ 157 int mesh type;157 int meshxdim; 158 158 Element* basalelement; 159 159 160 160 /*Get basal element*/ 161 element->FindParam(&mesh type,MeshTypeEnum);162 switch(mesh type){161 element->FindParam(&meshxdim,MeshXDimEnum); 162 switch(meshxdim){ 163 163 case Mesh2DhorizontalEnum: 164 164 basalelement = element; … … 168 168 basalelement = element->SpawnBasalElement(); 169 169 break; 170 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");170 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 171 171 } 172 172 … … 254 254 xDelete<IssmDouble>(basis); 255 255 delete gauss; 256 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};256 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 257 257 return Ke; 258 258 }/*}}}*/ … … 260 260 261 261 /*Intermediaries*/ 262 int mesh type;262 int meshxdim; 263 263 Element* basalelement; 264 264 265 265 /*Get basal element*/ 266 element->FindParam(&mesh type,MeshTypeEnum);267 switch(mesh type){266 element->FindParam(&meshxdim,MeshXDimEnum); 267 switch(meshxdim){ 268 268 case Mesh2DhorizontalEnum: 269 269 basalelement = element; … … 273 273 basalelement = element->SpawnBasalElement(); 274 274 break; 275 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");275 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 276 276 } 277 277 … … 357 357 xDelete<IssmDouble>(basis); 358 358 delete gauss; 359 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};359 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 360 360 return pe; 361 361 }/*}}}*/ … … 392 392 void HydrologyDCInefficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 393 393 394 int mesh type;394 int meshxdim; 395 395 bool converged; 396 396 int* doflist=NULL; 397 397 Element* basalelement=NULL; 398 398 399 element->FindParam(&mesh type,MeshTypeEnum);400 if(mesh type!=Mesh2DhorizontalEnum){399 element->FindParam(&meshxdim,MeshXDimEnum); 400 if(meshxdim!=Mesh2DhorizontalEnum){ 401 401 if(!element->IsOnBase()) return; 402 402 basalelement=element->SpawnBasalElement(); … … 446 446 xDelete<IssmDouble>(residual); 447 447 xDelete<int>(doflist); 448 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};448 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 449 449 }/*}}}*/ 450 450 void HydrologyDCInefficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ -
issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.h
r17555 r17674 14 14 public: 15 15 /*Model processing*/ 16 int DofsPerNode(int** doflist,int mesh type,int approximation);16 int DofsPerNode(int** doflist,int meshxdim,int approximation); 17 17 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 18 18 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int HydrologyShreveAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int HydrologyShreveAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 62 62 if(hydrology_model!=HydrologyshreveEnum) return; 63 63 64 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);64 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 65 65 ::CreateNodes(nodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum); 66 66 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); -
issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int L2ProjectionBaseAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int L2ProjectionBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 26 26 iomodel->FetchDataToInput(elements,BaseEnum); 27 27 iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); 28 if(iomodel->mesh type==Mesh3DEnum){28 if(iomodel->meshxdim==Mesh3DEnum){ 29 29 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 30 30 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); 31 31 } 32 if(iomodel->mesh type==Mesh2DverticalEnum){32 if(iomodel->meshxdim==Mesh2DverticalEnum){ 33 33 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 34 34 } … … 36 36 void L2ProjectionBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 37 37 38 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){38 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){ 39 39 iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 40 40 } 41 else if(iomodel->mesh type==Mesh2DverticalEnum){41 else if(iomodel->meshxdim==Mesh2DverticalEnum){ 42 42 iomodel->FetchData(1,MeshVertexonbaseEnum); 43 43 } … … 68 68 69 69 /*Intermediaries*/ 70 int mesh type;70 int meshxdim; 71 71 Element* basalelement; 72 72 73 73 /*Get basal element*/ 74 element->FindParam(&mesh type,MeshTypeEnum);75 switch(mesh type){74 element->FindParam(&meshxdim,MeshXDimEnum); 75 switch(meshxdim){ 76 76 case Mesh2DhorizontalEnum: 77 77 basalelement = element; … … 89 89 basalelement = element->SpawnBasalElement(); 90 90 break; 91 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");91 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 92 92 } 93 93 … … 125 125 xDelete<IssmDouble>(basis); 126 126 delete gauss; 127 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};127 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 128 128 return Ke; 129 129 }/*}}}*/ … … 131 131 132 132 /*Intermediaries*/ 133 int mesh type;133 int meshxdim; 134 134 Element* basalelement; 135 135 136 136 /*Get basal element*/ 137 element->FindParam(&mesh type,MeshTypeEnum);138 switch(mesh type){137 element->FindParam(&meshxdim,MeshXDimEnum); 138 switch(meshxdim){ 139 139 case Mesh2DhorizontalEnum: 140 140 basalelement = element; … … 152 152 basalelement = element->SpawnBasalElement(); 153 153 break; 154 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");154 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 155 155 } 156 156 … … 204 204 xDelete<IssmDouble>(basis); 205 205 delete gauss; 206 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};206 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 207 207 return pe; 208 208 }/*}}}*/ … … 212 212 void L2ProjectionBaseAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 213 213 214 int inputenum,mesh type;214 int inputenum,meshxdim; 215 215 216 216 element->FindParam(&inputenum,InputToL2ProjectEnum); 217 element->FindParam(&mesh type,MeshTypeEnum);218 switch(mesh type){217 element->FindParam(&meshxdim,MeshXDimEnum); 218 switch(meshxdim){ 219 219 case Mesh2DhorizontalEnum: 220 220 element->InputUpdateFromSolutionOneDof(solution,inputenum); … … 227 227 element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum); 228 228 break; 229 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");229 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 230 230 } 231 231 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int L2ProjectionEPLAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int L2ProjectionEPLAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 36 36 iomodel->FetchDataToInput(elements,EplHeadEnum); 37 37 iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); 38 if(iomodel->mesh type==Mesh3DEnum){38 if(iomodel->meshxdim==Mesh3DEnum){ 39 39 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 40 40 } … … 51 51 if(!isefficientlayer) return; 52 52 53 if(iomodel->mesh type==Mesh3DEnum){53 if(iomodel->meshxdim==Mesh3DEnum){ 54 54 iomodel->FetchData(1,MeshVertexonbaseEnum); 55 55 } 56 else if(iomodel->mesh type==Mesh2DverticalEnum){56 else if(iomodel->meshxdim==Mesh2DverticalEnum){ 57 57 iomodel->FetchData(1,MeshVertexonbaseEnum); 58 58 } … … 83 83 84 84 /*Intermediaries*/ 85 int mesh type;85 int meshxdim; 86 86 bool active_element; 87 87 Element* basalelement; 88 88 89 89 /*Get basal element*/ 90 element->FindParam(&mesh type,MeshTypeEnum);91 switch(mesh type){90 element->FindParam(&meshxdim,MeshXDimEnum); 91 switch(meshxdim){ 92 92 case Mesh2DhorizontalEnum: 93 93 basalelement = element; … … 101 101 basalelement = element->SpawnBasalElement(); 102 102 break; 103 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");103 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 104 104 } 105 105 … … 109 109 /* Check that all nodes are active, else return empty matrix */ 110 110 if(!active_element){ 111 if(mesh type!=Mesh2DhorizontalEnum){111 if(meshxdim!=Mesh2DhorizontalEnum){ 112 112 basalelement->DeleteMaterials(); 113 113 delete basalelement; … … 149 149 xDelete<IssmDouble>(basis); 150 150 delete gauss; 151 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};151 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 152 152 return Ke; 153 153 }/*}}}*/ … … 155 155 156 156 /*Intermediaries*/ 157 int mesh type;157 int meshxdim; 158 158 bool active_element; 159 159 Element* basalelement; 160 160 161 161 /*Get basal element*/ 162 element->FindParam(&mesh type,MeshTypeEnum);163 switch(mesh type){162 element->FindParam(&meshxdim,MeshXDimEnum); 163 switch(meshxdim){ 164 164 case Mesh2DhorizontalEnum: 165 165 basalelement = element; … … 169 169 basalelement = element->SpawnBasalElement(); 170 170 break; 171 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");171 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 172 172 } 173 173 … … 177 177 /*Check that all nodes are active, else return empty matrix*/ 178 178 if(!active_element) { 179 if(mesh type!=Mesh2DhorizontalEnum){179 if(meshxdim!=Mesh2DhorizontalEnum){ 180 180 basalelement->DeleteMaterials(); 181 181 delete basalelement; … … 222 222 xDelete<IssmDouble>(basis); 223 223 delete gauss; 224 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};224 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 225 225 return pe; 226 226 }/*}}}*/ … … 229 229 }/*}}}*/ 230 230 void L2ProjectionEPLAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 231 int inputenum,mesh type;231 int inputenum,meshxdim; 232 232 233 233 element->FindParam(&inputenum,InputToL2ProjectEnum); 234 element->FindParam(&mesh type,MeshTypeEnum);235 switch(mesh type){234 element->FindParam(&meshxdim,MeshXDimEnum); 235 switch(meshxdim){ 236 236 case Mesh2DhorizontalEnum: 237 237 element->InputUpdateFromSolutionOneDof(solution,inputenum); … … 243 243 element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum); 244 244 break; 245 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");245 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 246 246 } 247 247 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp
r17626 r17674 11 11 #include "../solutionsequences/solutionsequences.h" 12 12 13 int LevelsetAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/13 int LevelsetAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 14 14 return 1; 15 15 } … … 43 43 void LevelsetAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 44 44 int finiteelement=P1Enum; 45 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);45 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 46 46 ::CreateNodes(nodes,iomodel,LevelsetAnalysisEnum,finiteelement); 47 47 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 93 93 94 94 /*Intermediaries */ 95 int dim, mesh type;95 int dim, meshxdim; 96 96 int i, row, col; 97 97 IssmDouble kappa; … … 103 103 104 104 /*Get problem dimension*/ 105 basalelement->FindParam(&mesh type,MeshTypeEnum);106 switch(mesh type){105 basalelement->FindParam(&meshxdim,MeshXDimEnum); 106 switch(meshxdim){ 107 107 case Mesh2DverticalEnum: dim = 1; break; 108 108 case Mesh2DhorizontalEnum: dim = 2; break; 109 109 case Mesh3DEnum: dim = 2; break; 110 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");110 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 111 111 } 112 112 … … 130 130 Input* vx_input=NULL; 131 131 Input* vy_input=NULL; 132 if(mesh type==Mesh2DhorizontalEnum){132 if(meshxdim==Mesh2DhorizontalEnum){ 133 133 vx_input=basalelement->GetInput(VxEnum); _assert_(vx_input); 134 134 vy_input=basalelement->GetInput(VyEnum); _assert_(vy_input); … … 253 253 xDelete<IssmDouble>(dlsf); 254 254 delete gauss; 255 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};255 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 256 256 return Ke; 257 257 }/*}}}*/ … … 262 262 263 263 /*Intermediaries */ 264 int i, ig, mesh type;264 int i, ig, meshxdim; 265 265 IssmDouble Jdet,dt; 266 266 IssmDouble lsf; … … 298 298 xDelete<IssmDouble>(xyz_list); 299 299 xDelete<IssmDouble>(basis); 300 basalelement->FindParam(&mesh type,MeshTypeEnum);301 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};300 basalelement->FindParam(&meshxdim,MeshXDimEnum); 301 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 302 302 delete gauss; 303 303 } … … 310 310 void LevelsetAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 311 311 312 int mesh type;313 element->FindParam(&mesh type,MeshTypeEnum);314 switch(mesh type){312 int meshxdim; 313 element->FindParam(&meshxdim,MeshXDimEnum); 314 switch(meshxdim){ 315 315 case Mesh2DhorizontalEnum: 316 316 element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum); … … 319 319 element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum); 320 320 break; 321 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");321 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 322 322 } 323 323 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.h
r17626 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/LsfReinitializationAnalysis.cpp
r17610 r17674 10 10 11 11 /*Model processing*/ 12 int LsfReinitializationAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/12 int LsfReinitializationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 13 13 return 1; 14 14 }/*}}}*/ … … 36 36 void LsfReinitializationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 37 37 int finiteelement=P1Enum; 38 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);38 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 39 39 ::CreateNodes(nodes,iomodel,LsfReinitializationAnalysisEnum,finiteelement); 40 40 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 252 252 253 253 IssmDouble lsf; 254 int mesh type,dim,dofpernode;254 int meshxdim,dim,dofpernode; 255 255 int* doflist = NULL; 256 256 257 257 /*Get some parameters*/ 258 element->FindParam(&mesh type,MeshTypeEnum);259 switch(mesh type){258 element->FindParam(&meshxdim,MeshXDimEnum); 259 switch(meshxdim){ 260 260 case Mesh2DhorizontalEnum: dim = 2; dofpernode = 1; break; 261 261 case Mesh2DverticalEnum: dim = 2; dofpernode = 1; break; 262 262 case Mesh3DEnum: dim = 3; dofpernode = 1; break; 263 263 case Mesh3DtetrasEnum: dim = 3; dofpernode = 1; break; 264 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");264 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 265 265 } 266 266 … … 294 294 void LsfReinitializationAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 295 295 296 int mesh type;297 element->FindParam(&mesh type,MeshTypeEnum);298 switch(mesh type){296 int meshxdim; 297 element->FindParam(&meshxdim,MeshXDimEnum); 298 switch(meshxdim){ 299 299 case Mesh2DhorizontalEnum: 300 300 element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum); … … 303 303 element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum); 304 304 break; 305 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");305 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 306 306 } 307 307 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/LsfReinitializationAnalysis.h
r17503 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int MasstransportAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int MasstransportAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 83 83 } 84 84 85 if(iomodel->mesh type==Mesh3DEnum){85 if(iomodel->meshxdim==Mesh3DEnum){ 86 86 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 87 87 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); … … 90 90 if(islevelset){ 91 91 iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum); 92 if(iomodel->mesh type!=Mesh2DhorizontalEnum)92 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) 93 93 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes 94 94 } … … 132 132 133 133 /*Check in 3d*/ 134 if(stabilization==3 && iomodel->mesh type==Mesh3DEnum) _error_("DG 3d not implemented yet");134 if(stabilization==3 && iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet"); 135 135 136 136 /*Create Nodes either DG or CG depending on stabilization*/ 137 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);137 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 138 138 if(stabilization!=3){ 139 139 ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1Enum); … … 195 195 IssmDouble *nodeonbase=NULL; 196 196 iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); 197 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);197 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); 198 198 199 199 for(int i=0;i<numvertex_pairing;i++){ … … 205 205 206 206 /*Skip if one of the two is not on the bed*/ 207 if(iomodel->mesh type!=Mesh2DhorizontalEnum){207 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 208 208 if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue; 209 209 } … … 259 259 } 260 260 261 int mesh type;262 element->FindParam(&mesh type,MeshTypeEnum);263 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};261 int meshxdim; 262 element->FindParam(&meshxdim,MeshXDimEnum); 263 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 264 264 return Ke; 265 265 }/*}}}*/ … … 271 271 /*Intermediaries */ 272 272 int stabilization; 273 int mesh type,dim;273 int meshxdim,dim; 274 274 IssmDouble Jdet,D_scalar,dt,h; 275 275 IssmDouble vel,vx,vy,dvxdx,dvydy; … … 278 278 279 279 /*Get problem dimension*/ 280 element->FindParam(&mesh type,MeshTypeEnum);281 switch(mesh type){280 element->FindParam(&meshxdim,MeshXDimEnum); 281 switch(meshxdim){ 282 282 case Mesh2DverticalEnum: dim = 1; break; 283 283 case Mesh2DhorizontalEnum: dim = 2; break; 284 284 case Mesh3DEnum: dim = 2; break; 285 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");285 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 286 286 } 287 287 … … 299 299 element->GetVerticesCoordinates(&xyz_list); 300 300 element->FindParam(&dt,TimesteppingTimeStepEnum); 301 element->FindParam(&mesh type,MeshTypeEnum);301 element->FindParam(&meshxdim,MeshXDimEnum); 302 302 element->FindParam(&stabilization,MasstransportStabilizationEnum); 303 303 Input* vxaverage_input=NULL; 304 304 Input* vyaverage_input=NULL; 305 if(mesh type==Mesh2DhorizontalEnum){305 if(meshxdim==Mesh2DhorizontalEnum){ 306 306 vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); 307 307 vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); … … 415 415 416 416 /*Intermediaries */ 417 int mesh type;417 int meshxdim; 418 418 IssmDouble Jdet,D_scalar,dt,vx,vy; 419 419 IssmDouble* xyz_list = NULL; … … 432 432 element->GetVerticesCoordinates(&xyz_list); 433 433 element->FindParam(&dt,TimesteppingTimeStepEnum); 434 element->FindParam(&mesh type,MeshTypeEnum);434 element->FindParam(&meshxdim,MeshXDimEnum); 435 435 Input* vxaverage_input=NULL; 436 436 Input* vyaverage_input=NULL; 437 if(mesh type==Mesh2DhorizontalEnum){437 if(meshxdim==Mesh2DhorizontalEnum){ 438 438 vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); 439 439 vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); … … 505 505 } 506 506 507 int mesh type;508 element->FindParam(&mesh type,MeshTypeEnum);509 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};507 int meshxdim; 508 element->FindParam(&meshxdim,MeshXDimEnum); 509 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 510 510 return pe; 511 511 }/*}}}*/ … … 670 670 void MasstransportAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 671 671 672 int i,hydroadjustment,mesh type;672 int i,hydroadjustment,meshxdim; 673 673 int* doflist=NULL; 674 674 IssmDouble rho_ice,rho_water,minthickness; 675 675 Element* basalelement=NULL; 676 676 677 element->FindParam(&mesh type,MeshTypeEnum);678 if(mesh type!=Mesh2DhorizontalEnum){677 element->FindParam(&meshxdim,MeshXDimEnum); 678 if(meshxdim!=Mesh2DhorizontalEnum){ 679 679 if(!element->IsOnBase()) return; 680 680 basalelement=element->SpawnBasalElement(); … … 750 750 xDelete<IssmDouble>(phi); 751 751 xDelete<int>(doflist); 752 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};752 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 753 753 }/*}}}*/ 754 754 void MasstransportAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ -
issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.h
r17331 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int MeltingAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int MeltingAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 14 14 15 15 /*Now, is the model 3d? otherwise, do nothing: */ 16 if(iomodel->mesh type==Mesh2DhorizontalEnum)return;16 if(iomodel->meshxdim==Mesh2DhorizontalEnum)return; 17 17 18 18 /*Update elements: */ … … 44 44 void MeltingAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 45 45 46 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);46 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 47 47 ::CreateNodes(nodes,iomodel,MeltingAnalysisEnum,P1Enum); 48 48 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 54 54 55 55 /*if 2d: Error*/ 56 if(iomodel->mesh type==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");56 if(iomodel->meshxdim==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet"); 57 57 58 58 //create penalties for nodes: no node can have a temperature over the melting point -
issm/trunk-jpl/src/c/analyses/MeltingAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.cpp
r17212 r17674 6 6 7 7 /*Model processing*/ 8 int MeshdeformationAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int MeshdeformationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 _error_("not implemented"); 10 10 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int SmoothedSurfaceSlopeXAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int SmoothedSurfaceSlopeXAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 26 26 iomodel->FetchDataToInput(elements,BaseEnum); 27 27 iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); 28 if(iomodel->mesh type==Mesh3DEnum){28 if(iomodel->meshxdim==Mesh3DEnum){ 29 29 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 30 30 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); 31 31 } 32 if(iomodel->mesh type==Mesh2DverticalEnum){32 if(iomodel->meshxdim==Mesh2DverticalEnum){ 33 33 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 34 34 } 35 35 }/*}}}*/ 36 36 void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 37 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);37 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); 38 38 ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum); 39 if(iomodel->mesh type==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);39 if(iomodel->meshxdim==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum); 40 40 }/*}}}*/ 41 41 void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ … … 105 105 106 106 /*Intermediaries*/ 107 int mesh type;107 int meshxdim; 108 108 Element* basalelement; 109 109 110 110 /*Get basal element*/ 111 element->FindParam(&mesh type,MeshTypeEnum);112 switch(mesh type){111 element->FindParam(&meshxdim,MeshXDimEnum); 112 switch(meshxdim){ 113 113 case Mesh2DhorizontalEnum: 114 114 basalelement = element; … … 118 118 basalelement = element->SpawnBasalElement(); 119 119 break; 120 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");120 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 121 121 } 122 122 … … 169 169 xDelete<IssmDouble>(basis); 170 170 delete gauss; 171 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};171 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 172 172 return pe; 173 173 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int SmoothedSurfaceSlopeYAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int SmoothedSurfaceSlopeYAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 26 26 iomodel->FetchDataToInput(elements,BaseEnum); 27 27 iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); 28 if(iomodel->mesh type==Mesh3DEnum){28 if(iomodel->meshxdim==Mesh3DEnum){ 29 29 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 30 30 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); 31 31 } 32 if(iomodel->mesh type==Mesh2DverticalEnum){32 if(iomodel->meshxdim==Mesh2DverticalEnum){ 33 33 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 34 34 } 35 35 }/*}}}*/ 36 36 void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 37 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);37 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); 38 38 ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum); 39 if(iomodel->mesh type==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);39 if(iomodel->meshxdim==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum); 40 40 }/*}}}*/ 41 41 void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ … … 105 105 106 106 /*Intermediaries*/ 107 int mesh type;107 int meshxdim; 108 108 Element* basalelement; 109 109 110 110 /*Get basal element*/ 111 element->FindParam(&mesh type,MeshTypeEnum);112 switch(mesh type){111 element->FindParam(&meshxdim,MeshXDimEnum); 112 switch(meshxdim){ 113 113 case Mesh2DhorizontalEnum: 114 114 basalelement = element; … … 118 118 basalelement = element->SpawnBasalElement(); 119 119 break; 120 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");120 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 121 121 } 122 122 … … 169 169 xDelete<IssmDouble>(basis); 170 170 delete gauss; 171 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};171 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 172 172 return pe; 173 173 }/*}}}*/ -
issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp
r17659 r17674 10 10 11 11 /*Model processing*/ 12 int StressbalanceAnalysis::DofsPerNode(int** pdoftype,int mesh type,int approximation){/*{{{*/12 int StressbalanceAnalysis::DofsPerNode(int** pdoftype,int meshxdim,int approximation){/*{{{*/ 13 13 14 14 /*output*/ … … 18 18 switch(approximation){ 19 19 case SSAApproximationEnum: 20 switch(mesh type){20 switch(meshxdim){ 21 21 case Mesh3DEnum: numdofs=2; break; 22 22 case Mesh3DtetrasEnum: numdofs=2; break; … … 28 28 case L1L2ApproximationEnum: numdofs =2; break; 29 29 case HOApproximationEnum: 30 switch(mesh type){30 switch(meshxdim){ 31 31 case Mesh3DEnum: numdofs=2; break; 32 32 case Mesh3DtetrasEnum: numdofs=2; break; … … 37 37 case SIAApproximationEnum: numdofs =2; break; 38 38 case FSvelocityEnum: 39 switch(mesh type){39 switch(meshxdim){ 40 40 case Mesh3DEnum: numdofs=3; break; 41 41 case Mesh3DtetrasEnum: numdofs=3; break; … … 46 46 case FSpressureEnum: numdofs=1; break; 47 47 case NoneApproximationEnum: 48 switch(mesh type){48 switch(meshxdim){ 49 49 case Mesh3DEnum: numdofs=4; break; 50 50 case Mesh3DtetrasEnum: numdofs=4; break; … … 218 218 iomodel->FetchDataToInput(elements,DamageDEnum); 219 219 220 if(iomodel->mesh type==Mesh3DEnum){220 if(iomodel->meshxdim==Mesh3DEnum){ 221 221 iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); 222 222 iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); … … 227 227 if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum); 228 228 } 229 if(iomodel->mesh type==Mesh3DtetrasEnum){229 if(iomodel->meshxdim==Mesh3DtetrasEnum){ 230 230 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); 231 231 iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); … … 235 235 if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum); 236 236 } 237 if(iomodel->mesh type==Mesh2DverticalEnum){237 if(iomodel->meshxdim==Mesh2DverticalEnum){ 238 238 iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); 239 239 } … … 245 245 if(islevelset){ 246 246 iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum); 247 if(iomodel->mesh type!=Mesh2DhorizontalEnum)247 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) 248 248 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes 249 249 } … … 299 299 } 300 300 iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); 301 if(iomodel->mesh type!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);301 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum); 302 302 ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation); 303 303 iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, … … 431 431 iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); 432 432 iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum); 433 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){433 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){ 434 434 iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum); 435 435 } 436 else if (iomodel->mesh type==Mesh2DverticalEnum){436 else if (iomodel->meshxdim==Mesh2DverticalEnum){ 437 437 iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvyEnum); 438 438 } … … 440 440 _error_("not supported yet"); 441 441 } 442 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){442 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){ 443 443 IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0); 444 444 IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1); … … 446 446 iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum); 447 447 } 448 else if (iomodel->mesh type==Mesh2DverticalEnum){448 else if (iomodel->meshxdim==Mesh2DverticalEnum){ 449 449 IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0); 450 450 IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,finiteelement,1); … … 507 507 else{ 508 508 IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0); 509 if(iomodel->mesh type!=Mesh2DverticalEnum){509 if(iomodel->meshxdim!=Mesh2DverticalEnum){ 510 510 IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1); 511 511 } … … 520 520 iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum); 521 521 iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum); 522 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);523 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);524 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);525 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);522 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum); 523 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum); 524 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); 525 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum); 526 526 iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum); 527 527 iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum); … … 750 750 iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum); 751 751 iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum); 752 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);753 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);754 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);755 if(iomodel->mesh type==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);752 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum); 753 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum); 754 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum); 755 if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum); 756 756 iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum); 757 757 iomodel->DeleteData(surface,SurfaceEnum); … … 835 835 bool isSSA,isL1L2,isHO,isFS; 836 836 bool conserve_loads = true; 837 int newton,mesh type,fe_FS;837 int newton,meshxdim,fe_FS; 838 838 839 839 /* recover parameters:*/ … … 843 843 femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum); 844 844 femmodel->parameters->FindParam(&fe_FS,FlowequationFeFSEnum); 845 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);845 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 846 846 femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum); 847 847 … … 866 866 solutionsequence_nonlinear(femmodel,conserve_loads); 867 867 868 if(mesh type==Mesh2DverticalEnum && isSSA){868 if(meshxdim==Mesh2DverticalEnum && isSSA){ 869 869 femmodel->parameters->SetParam(VxEnum,InputToExtrudeEnum); 870 870 extrudefrombase_core(femmodel); … … 989 989 990 990 IssmDouble vx,vy; 991 int mesh type,dim,approximation,dofpernode;991 int meshxdim,dim,approximation,dofpernode; 992 992 int* doflist = NULL; 993 993 994 994 /*Get some parameters*/ 995 element->FindParam(&mesh type,MeshTypeEnum);996 switch(mesh type){995 element->FindParam(&meshxdim,MeshXDimEnum); 996 switch(meshxdim){ 997 997 case Mesh2DhorizontalEnum: dim = 2; dofpernode = 2; break; 998 998 case Mesh2DverticalEnum: dim = 2; dofpernode = 1; break; 999 999 case Mesh3DEnum: dim = 3; dofpernode = 2; break; 1000 1000 case Mesh3DtetrasEnum: dim = 3; dofpernode = 2; break; 1001 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1001 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1002 1002 } 1003 1003 … … 1014 1014 Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input); 1015 1015 Input* vy_input=NULL; 1016 if(mesh type!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);}1016 if(meshxdim!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);} 1017 1017 1018 1018 /*Ok, we have vx and vy in values, fill in vx and vy arrays: */ … … 1083 1083 1084 1084 /*Intermediaries*/ 1085 int mesh type;1085 int meshxdim; 1086 1086 Element* basalelement; 1087 1087 1088 1088 /*Get basal element*/ 1089 element->FindParam(&mesh type,MeshTypeEnum);1090 switch(mesh type){1089 element->FindParam(&meshxdim,MeshXDimEnum); 1090 switch(meshxdim){ 1091 1091 case Mesh2DhorizontalEnum: 1092 1092 basalelement = element; … … 1096 1096 basalelement = element->SpawnBasalElement(); 1097 1097 break; 1098 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1098 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1099 1099 } 1100 1100 … … 1159 1159 1160 1160 /*clean-up and return*/ 1161 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};1161 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 1162 1162 return Ke; 1163 1163 … … 1169 1169 1170 1170 /*Intermediaries*/ 1171 int mesh type;1171 int meshxdim; 1172 1172 Element* basalelement; 1173 1173 1174 1174 /*Get basal element*/ 1175 element->FindParam(&mesh type,MeshTypeEnum);1176 switch(mesh type){1175 element->FindParam(&meshxdim,MeshXDimEnum); 1176 switch(meshxdim){ 1177 1177 case Mesh2DhorizontalEnum: 1178 1178 basalelement = element; … … 1182 1182 basalelement = element->SpawnBasalElement(); 1183 1183 break; 1184 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1184 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1185 1185 } 1186 1186 … … 1191 1191 1192 1192 /*clean-up and return*/ 1193 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};1193 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 1194 1194 delete Ke1; 1195 1195 delete Ke2; … … 1202 1202 1203 1203 /*Intermediaries*/ 1204 int dim,mesh type;1204 int dim,meshxdim; 1205 1205 bool mainlyfloating; 1206 1206 int migration_style,point1; … … 1211 1211 1212 1212 /*Get problem dimension*/ 1213 element->FindParam(&mesh type,MeshTypeEnum);1214 switch(mesh type){1213 element->FindParam(&meshxdim,MeshXDimEnum); 1214 switch(meshxdim){ 1215 1215 case Mesh2DverticalEnum: dim = 1;break; 1216 1216 case Mesh2DhorizontalEnum: dim = 2;break; 1217 1217 case Mesh3DEnum: dim = 2;break; 1218 1218 case Mesh3DtetrasEnum: dim = 2;break; 1219 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1219 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1220 1220 } 1221 1221 … … 1290 1290 1291 1291 /*Intermediaries*/ 1292 int dim,mesh type,bsize;1292 int dim,meshxdim,bsize; 1293 1293 IssmDouble viscosity,newviscosity,oldviscosity; 1294 1294 IssmDouble viscosity_overshoot,thickness,Jdet; … … 1297 1297 1298 1298 /*Get problem dimension*/ 1299 element->FindParam(&mesh type,MeshTypeEnum);1300 switch(mesh type){1299 element->FindParam(&meshxdim,MeshXDimEnum); 1300 switch(meshxdim){ 1301 1301 case Mesh2DverticalEnum: dim = 1; bsize = 1; break; 1302 1302 case Mesh2DhorizontalEnum: dim = 2; bsize = 3; break; 1303 1303 case Mesh3DEnum: dim = 2; bsize = 3; break; 1304 1304 case Mesh3DtetrasEnum: dim = 2; bsize = 3; break; 1305 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1305 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1306 1306 } 1307 1307 … … 1372 1372 1373 1373 /*Intermediaries*/ 1374 int mesh type;1374 int meshxdim; 1375 1375 Element* basalelement; 1376 1376 1377 1377 /*Get basal element*/ 1378 element->FindParam(&mesh type,MeshTypeEnum);1379 switch(mesh type){1378 element->FindParam(&meshxdim,MeshXDimEnum); 1379 switch(meshxdim){ 1380 1380 case Mesh2DhorizontalEnum: 1381 1381 basalelement = element; … … 1385 1385 basalelement = element->SpawnBasalElement(); 1386 1386 break; 1387 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1387 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1388 1388 } 1389 1389 … … 1394 1394 1395 1395 /*clean-up and return*/ 1396 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};1396 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 1397 1397 delete pe1; 1398 1398 delete pe2; … … 1405 1405 1406 1406 /*Intermediaries */ 1407 int dim,mesh type;1407 int dim,meshxdim; 1408 1408 IssmDouble thickness,Jdet,slope[2]; 1409 1409 IssmDouble* xyz_list = NULL; 1410 1410 1411 1411 /*Get problem dimension*/ 1412 element->FindParam(&mesh type,MeshTypeEnum);1413 switch(mesh type){1412 element->FindParam(&meshxdim,MeshXDimEnum); 1413 switch(meshxdim){ 1414 1414 case Mesh2DverticalEnum: dim = 1;break; 1415 1415 case Mesh2DhorizontalEnum: dim = 2;break; 1416 1416 case Mesh3DEnum: dim = 2;break; 1417 1417 case Mesh3DtetrasEnum: dim = 2;break; 1418 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1418 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1419 1419 } 1420 1420 … … 1468 1468 1469 1469 /*Intermediaries*/ 1470 int dim,mesh type;1470 int dim,meshxdim; 1471 1471 IssmDouble Jdet,thickness,bed,water_pressure,ice_pressure; 1472 1472 IssmDouble surface_under_water,base_under_water,pressure; … … 1476 1476 1477 1477 /*Get problem dimension*/ 1478 element->FindParam(&mesh type,MeshTypeEnum);1479 switch(mesh type){1478 element->FindParam(&meshxdim,MeshXDimEnum); 1479 switch(meshxdim){ 1480 1480 case Mesh2DverticalEnum: dim = 1;break; 1481 1481 case Mesh2DhorizontalEnum: dim = 2;break; 1482 1482 case Mesh3DEnum: dim = 2;break; 1483 1483 case Mesh3DtetrasEnum: dim = 2;break; 1484 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1484 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1485 1485 } 1486 1486 … … 1654 1654 void StressbalanceAnalysis::InputUpdateFromSolutionSSA(IssmDouble* solution,Element* element){/*{{{*/ 1655 1655 1656 int i,dim,mesh type;1656 int i,dim,meshxdim; 1657 1657 IssmDouble rho_ice,g; 1658 1658 int* doflist=NULL; … … 1666 1666 IssmDouble* surface = xNew<IssmDouble>(numvertices); 1667 1667 1668 element->FindParam(&mesh type,MeshTypeEnum);1668 element->FindParam(&meshxdim,MeshXDimEnum); 1669 1669 rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum); 1670 1670 g =element->GetMaterialParameter(ConstantsGEnum); 1671 switch(mesh type){1671 switch(meshxdim){ 1672 1672 case Mesh2DhorizontalEnum: 1673 1673 element->GetInputListOnVertices(thickness,ThicknessEnum); … … 1687 1687 dim=1; 1688 1688 break; 1689 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1689 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1690 1690 } 1691 1691 element->AddInput(PressureEnum,pressure,P1Enum); … … 1695 1695 1696 1696 /*Get basal element*/ 1697 switch(mesh type){1697 switch(meshxdim){ 1698 1698 case Mesh2DhorizontalEnum: 1699 1699 basalelement = element; … … 1703 1703 basalelement=element->SpawnBasalElement(); 1704 1704 break; 1705 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1705 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1706 1706 } 1707 1707 … … 1763 1763 xDelete<IssmDouble>(xyz_list); 1764 1764 xDelete<int>(doflist); 1765 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};1765 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 1766 1766 }/*}}}*/ 1767 1767 … … 1852 1852 1853 1853 /*Intermediaries*/ 1854 int mesh type;1854 int meshxdim; 1855 1855 Element* basalelement; 1856 1856 1857 1857 /*Get basal element*/ 1858 element->FindParam(&mesh type,MeshTypeEnum);1859 switch(mesh type){1858 element->FindParam(&meshxdim,MeshXDimEnum); 1859 switch(meshxdim){ 1860 1860 case Mesh2DhorizontalEnum: 1861 1861 basalelement = element; … … 1865 1865 basalelement = element->SpawnBasalElement(); 1866 1866 break; 1867 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1867 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1868 1868 } 1869 1869 … … 1874 1874 1875 1875 /*clean-up and return*/ 1876 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};1876 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 1877 1877 delete pe1; 1878 1878 delete pe2; … … 1988 1988 void StressbalanceAnalysis::InputUpdateFromSolutionL1L2(IssmDouble* solution,Element* element){/*{{{*/ 1989 1989 1990 int i,mesh type;1990 int i,meshxdim; 1991 1991 IssmDouble rho_ice,g; 1992 1992 int* doflist=NULL; … … 2000 2000 IssmDouble* surface = xNew<IssmDouble>(numvertices); 2001 2001 2002 element->FindParam(&mesh type,MeshTypeEnum);2002 element->FindParam(&meshxdim,MeshXDimEnum); 2003 2003 rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum); 2004 2004 g =element->GetMaterialParameter(ConstantsGEnum); 2005 switch(mesh type){2005 switch(meshxdim){ 2006 2006 case Mesh2DhorizontalEnum: 2007 2007 element->GetInputListOnVertices(thickness,ThicknessEnum); … … 2013 2013 for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]); 2014 2014 break; 2015 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2015 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2016 2016 } 2017 2017 element->AddInput(PressureEnum,pressure,P1Enum); … … 2021 2021 2022 2022 /*Get basal element*/ 2023 switch(mesh type){2023 switch(meshxdim){ 2024 2024 case Mesh2DhorizontalEnum: 2025 2025 basalelement = element; … … 2029 2029 basalelement=element->SpawnBasalElement(); 2030 2030 break; 2031 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2031 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2032 2032 } 2033 2033 … … 2049 2049 /*Transform solution in Cartesian Space*/ 2050 2050 basalelement->TransformSolutionCoord(&values[0],XYEnum); 2051 basalelement->FindParam(&mesh type,MeshTypeEnum);2051 basalelement->FindParam(&meshxdim,MeshXDimEnum); 2052 2052 2053 2053 /*Ok, we have vx and vy in values, fill in vx and vy arrays: */ … … 2083 2083 xDelete<IssmDouble>(xyz_list); 2084 2084 xDelete<int>(doflist); 2085 if(mesh type!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};2085 if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; 2086 2086 }/*}}}*/ 2087 2087 … … 2169 2169 2170 2170 /*Intermediaries*/ 2171 int dim,mesh type,bsize;2171 int dim,meshxdim,bsize; 2172 2172 IssmDouble viscosity,newviscosity,oldviscosity; 2173 2173 IssmDouble viscosity_overshoot,thickness,Jdet; … … 2176 2176 2177 2177 /*Get problem dimension*/ 2178 element->FindParam(&mesh type,MeshTypeEnum);2179 switch(mesh type){2178 element->FindParam(&meshxdim,MeshXDimEnum); 2179 switch(meshxdim){ 2180 2180 case Mesh2DverticalEnum: dim = 2; bsize = 2; break; 2181 2181 case Mesh3DEnum: dim = 3; bsize = 5; break; 2182 2182 case Mesh3DtetrasEnum: dim = 3; bsize = 5; break; 2183 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2183 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2184 2184 } 2185 2185 … … 2247 2247 2248 2248 /*Intermediaries*/ 2249 int dim,mesh type;2249 int dim,meshxdim; 2250 2250 bool mainlyfloating; 2251 2251 int migration_style,point1; … … 2256 2256 2257 2257 /*Get problem dimension*/ 2258 element->FindParam(&mesh type,MeshTypeEnum);2259 switch(mesh type){2258 element->FindParam(&meshxdim,MeshXDimEnum); 2259 switch(meshxdim){ 2260 2260 case Mesh2DverticalEnum: dim = 2; break; 2261 2261 case Mesh3DEnum: dim = 3; break; 2262 2262 case Mesh3DtetrasEnum: dim = 3; break; 2263 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2263 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2264 2264 } 2265 2265 … … 2336 2336 2337 2337 /*Intermediaries */ 2338 int dim,mesh type;2338 int dim,meshxdim; 2339 2339 IssmDouble x_coord,y_coord,z_coord; 2340 2340 IssmDouble Jdet,forcex,forcey,forcez; … … 2342 2342 2343 2343 /*Get problem dimension*/ 2344 element->FindParam(&mesh type,MeshTypeEnum);2345 switch(mesh type){2344 element->FindParam(&meshxdim,MeshXDimEnum); 2345 switch(meshxdim){ 2346 2346 case Mesh2DverticalEnum: dim = 2; break; 2347 2347 case Mesh3DEnum: dim = 3; break; 2348 2348 case Mesh3DtetrasEnum: dim = 3; break; 2349 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2349 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2350 2350 } 2351 2351 … … 2414 2414 2415 2415 /*Intermediaries */ 2416 int dim,mesh type;2416 int dim,meshxdim; 2417 2417 IssmDouble Jdet,slope[3]; 2418 2418 IssmDouble* xyz_list = NULL; 2419 2419 2420 2420 /*Get problem dimension*/ 2421 element->FindParam(&mesh type,MeshTypeEnum);2422 switch(mesh type){2421 element->FindParam(&meshxdim,MeshXDimEnum); 2422 switch(meshxdim){ 2423 2423 case Mesh2DverticalEnum: dim = 2; break; 2424 2424 case Mesh3DEnum: dim = 3; break; 2425 2425 case Mesh3DtetrasEnum: dim = 3; break; 2426 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2426 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2427 2427 } 2428 2428 … … 2472 2472 2473 2473 /*Intermediaries*/ 2474 int dim,mesh type;2474 int dim,meshxdim; 2475 2475 IssmDouble Jdet,surface,z,water_pressure,ice_pressure; 2476 2476 IssmDouble surface_under_water,base_under_water,pressure; … … 2481 2481 2482 2482 /*Get problem dimension*/ 2483 element->FindParam(&mesh type,MeshTypeEnum);2484 switch(mesh type){2483 element->FindParam(&meshxdim,MeshXDimEnum); 2484 switch(meshxdim){ 2485 2485 case Mesh2DverticalEnum: dim = 2; break; 2486 2486 case Mesh3DEnum: dim = 3; break; 2487 2487 case Mesh3DtetrasEnum: dim = 3; break; 2488 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2488 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2489 2489 } 2490 2490 … … 2675 2675 void StressbalanceAnalysis::InputUpdateFromSolutionHO(IssmDouble* solution,Element* element){/*{{{*/ 2676 2676 2677 int i,dim,mesh type;2677 int i,dim,meshxdim; 2678 2678 int* doflist=NULL; 2679 2679 IssmDouble* xyz_list=NULL; 2680 2680 2681 2681 /*Get mesh dimension*/ 2682 element->FindParam(&mesh type,MeshTypeEnum);2683 switch(mesh type){2682 element->FindParam(&meshxdim,MeshXDimEnum); 2683 switch(meshxdim){ 2684 2684 case Mesh2DverticalEnum: dim = 2; break; 2685 2685 case Mesh3DEnum: dim = 3; break; 2686 2686 case Mesh3DtetrasEnum: dim = 3; break; 2687 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2687 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2688 2688 } 2689 2689 … … 2765 2765 ElementVector* StressbalanceAnalysis::CreateDVectorFS(Element* element){/*{{{*/ 2766 2766 2767 int mesh type,dim;2767 int meshxdim,dim; 2768 2768 2769 2769 /*Get problem dimension*/ 2770 element->FindParam(&mesh type,MeshTypeEnum);2771 switch(mesh type){2770 element->FindParam(&meshxdim,MeshXDimEnum); 2771 switch(meshxdim){ 2772 2772 case Mesh2DverticalEnum: dim = 2; break; 2773 2773 case Mesh3DEnum: dim = 3; break; 2774 2774 case Mesh3DtetrasEnum: dim = 3; break; 2775 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2775 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2776 2776 } 2777 2777 … … 2904 2904 2905 2905 /*Intermediaries*/ 2906 int i,mesh type,dim,epssize;2906 int i,meshxdim,dim,epssize; 2907 2907 IssmDouble r,FSreconditioning,Jdet; 2908 2908 IssmDouble *xyz_list = NULL; 2909 2909 2910 2910 /*Get problem dimension*/ 2911 element->FindParam(&mesh type,MeshTypeEnum);2911 element->FindParam(&meshxdim,MeshXDimEnum); 2912 2912 element->FindParam(&r,AugmentedLagrangianREnum); 2913 switch(mesh type){2913 switch(meshxdim){ 2914 2914 case Mesh2DverticalEnum: dim = 2; epssize = 3; break; 2915 2915 case Mesh3DEnum: dim = 3; epssize = 6; break; 2916 2916 case Mesh3DtetrasEnum: dim = 3; epssize = 6; break; 2917 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2917 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2918 2918 } 2919 2919 … … 2977 2977 2978 2978 /*Intermediaries*/ 2979 int i,mesh type,dim,epssize;2979 int i,meshxdim,dim,epssize; 2980 2980 IssmDouble viscosity,FSreconditioning,Jdet; 2981 2981 IssmDouble *xyz_list = NULL; 2982 2982 2983 2983 /*Get problem dimension*/ 2984 element->FindParam(&mesh type,MeshTypeEnum);2985 switch(mesh type){2984 element->FindParam(&meshxdim,MeshXDimEnum); 2985 switch(meshxdim){ 2986 2986 case Mesh2DverticalEnum: dim = 2; epssize = 3; break; 2987 2987 case Mesh3DEnum: dim = 3; epssize = 6; break; 2988 2988 case Mesh3DtetrasEnum: dim = 3; epssize = 6; break; 2989 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");2989 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 2990 2990 } 2991 2991 … … 3060 3060 /*Intermediaries*/ 3061 3061 bool mainlyfloating; 3062 int j,i,mesh type,dim;3062 int j,i,meshxdim,dim; 3063 3063 IssmDouble Jdet,slope2,scalar,dt; 3064 3064 IssmDouble slope[3]; … … 3068 3068 3069 3069 /*Get problem dimension*/ 3070 element->FindParam(&mesh type,MeshTypeEnum);3071 switch(mesh type){3070 element->FindParam(&meshxdim,MeshXDimEnum); 3071 switch(meshxdim){ 3072 3072 case Mesh2DverticalEnum: dim = 2;break; 3073 3073 case Mesh3DEnum: dim = 3;break; 3074 3074 case Mesh3DtetrasEnum: dim = 3;break; 3075 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3075 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3076 3076 } 3077 3077 … … 3132 3132 3133 3133 /*Intermediaries*/ 3134 int i,mesh type,dim;3134 int i,meshxdim,dim; 3135 3135 IssmDouble alpha2,Jdet; 3136 3136 IssmDouble x_coord,y_coord,z_coord; … … 3139 3139 3140 3140 /*Get problem dimension*/ 3141 element->FindParam(&mesh type,MeshTypeEnum);3142 switch(mesh type){3141 element->FindParam(&meshxdim,MeshXDimEnum); 3142 switch(meshxdim){ 3143 3143 case Mesh2DverticalEnum: dim = 2;break; 3144 3144 case Mesh3DEnum: dim = 3;break; 3145 3145 case Mesh3DtetrasEnum: dim = 3;break; 3146 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3146 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3147 3147 } 3148 3148 … … 3197 3197 ElementVector* StressbalanceAnalysis::CreatePVectorFS(Element* element){/*{{{*/ 3198 3198 3199 int i,mesh type,dim,fe_FS;3199 int i,meshxdim,dim,fe_FS; 3200 3200 IssmDouble x_coord,y_coord,z_coord; 3201 3201 IssmDouble Jdet,forcex,forcey,forcez; … … 3203 3203 3204 3204 element->FindParam(&fe_FS,FlowequationFeFSEnum); 3205 element->FindParam(&mesh type,MeshTypeEnum);3206 switch(mesh type){3205 element->FindParam(&meshxdim,MeshXDimEnum); 3206 switch(meshxdim){ 3207 3207 case Mesh2DverticalEnum: dim = 2; break; 3208 3208 case Mesh3DEnum: dim = 3; break; 3209 3209 case Mesh3DtetrasEnum: dim = 3; break; 3210 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3210 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3211 3211 } 3212 3212 … … 3281 3281 /*Intermediaries*/ 3282 3282 bool mainlyfloating; 3283 int i,mesh type,dim,epssize;3283 int i,meshxdim,dim,epssize; 3284 3284 int migration_style,point1; 3285 3285 IssmDouble alpha2,Jdet,fraction1,fraction2; … … 3289 3289 3290 3290 /*Get problem dimension*/ 3291 element->FindParam(&mesh type,MeshTypeEnum);3292 switch(mesh type){3291 element->FindParam(&meshxdim,MeshXDimEnum); 3292 switch(meshxdim){ 3293 3293 case Mesh2DverticalEnum: dim = 2;break; 3294 3294 case Mesh3DEnum: dim = 3;break; 3295 3295 case Mesh3DtetrasEnum: dim = 3;break; 3296 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3296 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3297 3297 } 3298 3298 … … 3322 3322 if(migration_style==SubelementMigrationEnum) phi=element->GetGroundedPortion(xyz_list_base); 3323 3323 if(migration_style==SubelementMigration2Enum){ 3324 if(mesh type==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline");3324 if(meshxdim==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline"); 3325 3325 gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input); 3326 3326 element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating); … … 3399 3399 ElementVector* StressbalanceAnalysis::CreatePVectorFSViscous(Element* element){/*{{{*/ 3400 3400 3401 int i,mesh type,dim;3401 int i,meshxdim,dim; 3402 3402 IssmDouble Jdet,forcex,forcey,forcez; 3403 3403 IssmDouble *xyz_list = NULL; 3404 3404 3405 3405 /*Get problem dimension*/ 3406 element->FindParam(&mesh type,MeshTypeEnum);3407 switch(mesh type){3406 element->FindParam(&meshxdim,MeshXDimEnum); 3407 switch(meshxdim){ 3408 3408 case Mesh2DverticalEnum: dim = 2; break; 3409 3409 case Mesh3DEnum: dim = 3; break; 3410 3410 case Mesh3DtetrasEnum: dim = 3; break; 3411 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3411 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3412 3412 } 3413 3413 … … 3474 3474 ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousXTH(Element* element){/*{{{*/ 3475 3475 3476 int i,tausize,mesh type,dim;3476 int i,tausize,meshxdim,dim; 3477 3477 IssmDouble Jdet,r; 3478 3478 IssmDouble epsxx,epsyy,epszz,epsxy,epsxz,epsyz; … … 3482 3482 3483 3483 /*Get problem dimension*/ 3484 element->FindParam(&mesh type,MeshTypeEnum);3485 switch(mesh type){3484 element->FindParam(&meshxdim,MeshXDimEnum); 3485 switch(meshxdim){ 3486 3486 case Mesh2DverticalEnum: dim = 2; tausize = 3; break; 3487 3487 case Mesh3DEnum: dim = 3; tausize = 6; break; 3488 3488 case Mesh3DtetrasEnum: dim = 3; tausize = 6; break; 3489 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3489 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3490 3490 } 3491 3491 … … 3650 3650 ElementVector* StressbalanceAnalysis::CreatePVectorFSShelf(Element* element){/*{{{*/ 3651 3651 3652 int i,mesh type,dim;3652 int i,meshxdim,dim; 3653 3653 IssmDouble Jdet,water_pressure,bed; 3654 3654 IssmDouble normal[3]; … … 3659 3659 3660 3660 /*Get problem dimension*/ 3661 element->FindParam(&mesh type,MeshTypeEnum);3662 switch(mesh type){3661 element->FindParam(&meshxdim,MeshXDimEnum); 3662 switch(meshxdim){ 3663 3663 case Mesh2DverticalEnum: dim = 2; break; 3664 3664 case Mesh3DEnum: dim = 3; break; 3665 3665 case Mesh3DtetrasEnum: dim = 3; break; 3666 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3666 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3667 3667 } 3668 3668 … … 3725 3725 3726 3726 /*Intermediaries*/ 3727 int i,mesh type,dim;3727 int i,meshxdim,dim; 3728 3728 IssmDouble Jdet,pressure,surface,z; 3729 3729 IssmDouble normal[3]; … … 3736 3736 3737 3737 /*Get problem dimension*/ 3738 element->FindParam(&mesh type,MeshTypeEnum);3739 switch(mesh type){3738 element->FindParam(&meshxdim,MeshXDimEnum); 3739 switch(meshxdim){ 3740 3740 case Mesh2DverticalEnum: dim = 2; break; 3741 3741 case Mesh3DEnum: dim = 3; break; 3742 3742 case Mesh3DtetrasEnum: dim = 3; break; 3743 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");3743 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 3744 3744 } 3745 3745 … … 4083 4083 int* pdoflist=NULL; 4084 4084 Input* vz_input=NULL; 4085 int mesh type,dim;4085 int meshxdim,dim; 4086 4086 IssmDouble vx,vy,vz,p; 4087 4087 IssmDouble FSreconditioning; 4088 4088 4089 4089 /*Get some parameters*/ 4090 element->FindParam(&mesh type,MeshTypeEnum);4090 element->FindParam(&meshxdim,MeshXDimEnum); 4091 4091 element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); 4092 switch(mesh type){4092 switch(meshxdim){ 4093 4093 case Mesh2DverticalEnum: dim = 2; break; 4094 4094 case Mesh3DEnum: dim = 3; break; 4095 4095 case Mesh3DtetrasEnum: dim = 3; break; 4096 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");4096 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 4097 4097 } 4098 4098 … … 4150 4150 4151 4151 /*Intermediaries*/ 4152 int mesh type,dim;4152 int meshxdim,dim; 4153 4153 IssmDouble dvx[3],dvy[3],dvz[3]; 4154 4154 IssmDouble viscosity; … … 4156 4156 4157 4157 /*Get problem dimension*/ 4158 parameters->FindParam(&mesh type,MeshTypeEnum);4159 switch(mesh type){4158 parameters->FindParam(&meshxdim,MeshXDimEnum); 4159 switch(meshxdim){ 4160 4160 case Mesh2DverticalEnum: dim = 2; break; 4161 4161 case Mesh3DEnum: dim = 3; break; 4162 4162 case Mesh3DtetrasEnum: dim = 3; break; 4163 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");4163 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 4164 4164 } 4165 4165 … … 4235 4235 4236 4236 bool results_on_nodes; 4237 int i,dim,mesh type;4237 int i,dim,meshxdim; 4238 4238 int* vdoflist=NULL; 4239 4239 int* pdoflist=NULL; 4240 4240 IssmDouble FSreconditioning; 4241 4241 4242 element->FindParam(&mesh type,MeshTypeEnum);4242 element->FindParam(&meshxdim,MeshXDimEnum); 4243 4243 element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); 4244 4244 element->FindParam(&results_on_nodes,SettingsResultsOnNodesEnum); 4245 switch(mesh type){4245 switch(meshxdim){ 4246 4246 case Mesh2DverticalEnum: dim = 2; break; 4247 4247 case Mesh3DEnum: dim = 3; break; 4248 4248 case Mesh3DtetrasEnum: dim = 3; break; 4249 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");4249 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 4250 4250 } 4251 4251 … … 4331 4331 4332 4332 /*Intermediaries*/ 4333 int dim,tausize,mesh type;4333 int dim,tausize,meshxdim; 4334 4334 IssmDouble epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar; 4335 4335 IssmDouble epsxx_old,epsyy_old,epszz_old,epsxy_old,epsxz_old,epsyz_old; … … 4340 4340 4341 4341 parameters->FindParam(&r,AugmentedLagrangianREnum); 4342 parameters->FindParam(&mesh type,MeshTypeEnum);4343 switch(mesh type){4342 parameters->FindParam(&meshxdim,MeshXDimEnum); 4343 switch(meshxdim){ 4344 4344 case Mesh2DverticalEnum: dim = 2; tausize = 3; break; 4345 4345 case Mesh3DEnum: dim = 3; tausize = 6; break; 4346 4346 case Mesh3DtetrasEnum: dim = 3; tausize = 6; break; 4347 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");4347 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 4348 4348 } 4349 4349 … … 4545 4545 4546 4546 /*Intermediaries*/ 4547 int dim,tausize,mesh type;4547 int dim,tausize,meshxdim; 4548 4548 IssmDouble epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar; 4549 4549 IssmDouble d_xx,d_yy,d_zz,d_xy,d_xz,d_yz; … … 4554 4554 4555 4555 parameters->FindParam(&r,AugmentedLagrangianREnum); 4556 parameters->FindParam(&mesh type,MeshTypeEnum);4557 switch(mesh type){4556 parameters->FindParam(&meshxdim,MeshXDimEnum); 4557 switch(meshxdim){ 4558 4558 case Mesh2DverticalEnum: dim = 2; tausize = 3; break; 4559 4559 case Mesh3DEnum: dim = 3; tausize = 6; break; 4560 4560 case Mesh3DtetrasEnum: dim = 3; tausize = 6; break; 4561 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");4561 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 4562 4562 } 4563 4563 … … 6340 6340 void StressbalanceAnalysis::InputUpdateFromSolutionSSAHO(IssmDouble* solution,Element* element){/*{{{*/ 6341 6341 6342 int i,mesh type;6342 int i,meshxdim; 6343 6343 IssmDouble rho_ice,g; 6344 6344 int* SSAdoflist = NULL; -
issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h
r17653 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp
r17610 r17674 7 7 8 8 /*Model processing*/ 9 int StressbalanceSIAAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/9 int StressbalanceSIAAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 10 10 return 2; 11 11 }/*}}}*/ … … 42 42 if(islevelset){ 43 43 iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum); 44 if(iomodel->mesh type!=Mesh2DhorizontalEnum)44 if(iomodel->meshxdim!=Mesh2DhorizontalEnum) 45 45 iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes 46 46 } … … 64 64 int lid=0; 65 65 iomodel->FetchData(4,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); 66 if(iomodel->mesh type!=Mesh2DhorizontalEnum){66 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 67 67 iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 68 68 } … … 163 163 if(!element->IsIceInElement()) return NULL; 164 164 165 int mesh type;166 element->FindParam(&mesh type,MeshTypeEnum);167 switch(mesh type){165 int meshxdim; 166 element->FindParam(&meshxdim,MeshXDimEnum); 167 switch(meshxdim){ 168 168 case Mesh2DhorizontalEnum: 169 169 return CreateKMatrix2D(element); 170 170 case Mesh3DEnum: 171 171 return CreateKMatrix3D(element); 172 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");172 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 173 173 } 174 174 }/*}}}*/ … … 266 266 if(!element->IsIceInElement()) return NULL; 267 267 268 int mesh type;269 element->FindParam(&mesh type,MeshTypeEnum);270 switch(mesh type){268 int meshxdim; 269 element->FindParam(&meshxdim,MeshXDimEnum); 270 switch(meshxdim){ 271 271 case Mesh2DhorizontalEnum: 272 272 return CreatePVector2D(element); 273 273 case Mesh3DEnum: 274 274 return CreatePVector3D(element); 275 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");275 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 276 276 } 277 277 }/*}}}*/ … … 495 495 void StressbalanceSIAAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ 496 496 497 int i,mesh type;497 int i,meshxdim; 498 498 IssmDouble rho_ice,g; 499 499 int* doflist=NULL; … … 539 539 rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum); 540 540 g = element->GetMaterialParameter(ConstantsGEnum); 541 element->FindParam(&mesh type,MeshTypeEnum);542 switch(mesh type){541 element->FindParam(&meshxdim,MeshXDimEnum); 542 switch(meshxdim){ 543 543 case Mesh2DhorizontalEnum: 544 544 element->GetInputListOnNodes(&thickness[0],ThicknessEnum); … … 550 550 for(i=0;i<numnodes;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]); 551 551 break; 552 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");552 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 553 553 } 554 554 -
issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp
r17610 r17674 7 7 8 8 /*Model processing*/ 9 int StressbalanceVerticalAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/9 int StressbalanceVerticalAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 10 10 return 1; 11 11 }/*}}}*/ … … 18 18 19 19 /*return if not 3d mesh*/ 20 if(iomodel->mesh type!=Mesh3DEnum) return;20 if(iomodel->meshxdim!=Mesh3DEnum) return; 21 21 22 22 /*Update elements: */ … … 43 43 44 44 /*return if not 3d mesh*/ 45 if(iomodel->mesh type!=Mesh3DEnum) return;45 if(iomodel->meshxdim!=Mesh3DEnum) return; 46 46 47 47 iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum); … … 59 59 60 60 /*return if not 3d mesh*/ 61 if(iomodel->mesh type!=Mesh3DEnum) return;61 if(iomodel->meshxdim!=Mesh3DEnum) return; 62 62 63 63 /*Fetch data: */ -
issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp
r17610 r17674 6 6 7 7 /*Model processing*/ 8 int ThermalAnalysis::DofsPerNode(int** doflist,int mesh type,int approximation){/*{{{*/8 int ThermalAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ 9 9 return 1; 10 10 }/*}}}*/ … … 31 31 32 32 /*Now, is the model 3d? otherwise, do nothing: */ 33 if(iomodel->mesh type==Mesh2DhorizontalEnum)return;33 if(iomodel->meshxdim==Mesh2DhorizontalEnum)return; 34 34 35 35 /*Update elements: */ … … 83 83 void ThermalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ 84 84 85 if(iomodel->mesh type==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);85 if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); 86 86 ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P1Enum); 87 87 iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); … … 90 90 91 91 /*Only 3d mesh supported*/ 92 if(iomodel->mesh type==Mesh3DEnum){92 if(iomodel->meshxdim==Mesh3DEnum){ 93 93 IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P1Enum); 94 94 } … … 97 97 void ThermalAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/ 98 98 99 if(iomodel->mesh type==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");99 if(iomodel->meshxdim==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet"); 100 100 101 101 /*create penalties for nodes: no node can have a temperature over the melting point*/ -
issm/trunk-jpl/src/c/analyses/ThermalAnalysis.h
r17212 r17674 13 13 public: 14 14 /*Model processing*/ 15 int DofsPerNode(int** doflist,int mesh type,int approximation);15 int DofsPerNode(int** doflist,int meshxdim,int approximation); 16 16 void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); 17 17 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -
issm/trunk-jpl/src/c/classes/Elements/Tria.cpp
r17671 r17674 101 101 _assert_(this->inputs); 102 102 103 int mesh type;104 parameters->FindParam(&mesh type,MeshTypeEnum);105 switch(mesh type){103 int meshxdim; 104 parameters->FindParam(&meshxdim,MeshXDimEnum); 105 switch(meshxdim){ 106 106 case Mesh2DhorizontalEnum: 107 107 this->inputs->AddInput(new TriaInput(input_enum,values,interpolation_enum)); … … 123 123 } 124 124 break; 125 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");125 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 126 126 } 127 127 … … 461 461 462 462 bool mainlyfloating = true; 463 int mesh type,index1,index2;463 int meshxdim,index1,index2; 464 464 const IssmPDouble epsilon = 1.e-15; 465 465 IssmDouble phi,s1,s2,area_init,area_grounded; … … 468 468 469 469 /*Recover parameters and values*/ 470 parameters->FindParam(&mesh type,MeshTypeEnum);470 parameters->FindParam(&meshxdim,MeshXDimEnum); 471 471 GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum); 472 472 … … 476 476 if(gl[2]==0.) gl[2]=gl[2]+epsilon; 477 477 478 if(mesh type==Mesh2DverticalEnum){478 if(meshxdim==Mesh2DverticalEnum){ 479 479 this->EdgeOnBaseIndices(&index1,&index2); 480 480 if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded … … 488 488 489 489 } 490 else if(mesh type==Mesh2DhorizontalEnum || meshtype==Mesh3DEnum){490 else if(meshxdim==Mesh2DhorizontalEnum || meshxdim==Mesh3DEnum){ 491 491 /*Check that not all nodes are grounded or floating*/ 492 492 if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All grounded … … 568 568 } 569 569 } 570 else _error_("mesh type "<<EnumToStringx(mesh type)<<"not supported yet ");570 else _error_("mesh type "<<EnumToStringx(meshxdim)<<"not supported yet "); 571 571 572 572 if(phi>1 || phi<0) _error_("Error. Problem with portion of grounded element: value should be between 0 and 1"); … … 1110 1110 bool Tria::IsOnBase(){ 1111 1111 1112 int mesh type;1113 this->parameters->FindParam(&mesh type,MeshTypeEnum);1114 switch(mesh type){1112 int meshxdim; 1113 this->parameters->FindParam(&meshxdim,MeshXDimEnum); 1114 switch(meshxdim){ 1115 1115 case Mesh2DverticalEnum: 1116 1116 return HasEdgeOnBase(); 1117 1117 case Mesh2DhorizontalEnum: 1118 1118 return true; 1119 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1119 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1120 1120 } 1121 1121 } … … 1124 1124 bool Tria::IsOnSurface(){ 1125 1125 1126 int mesh type;1127 this->parameters->FindParam(&mesh type,MeshTypeEnum);1128 switch(mesh type){1126 int meshxdim; 1127 this->parameters->FindParam(&meshxdim,MeshXDimEnum); 1128 switch(meshxdim){ 1129 1129 case Mesh2DverticalEnum: 1130 1130 return HasEdgeOnSurface(); 1131 1131 case Mesh2DhorizontalEnum: 1132 1132 return true; 1133 default: _error_("mesh "<<EnumToStringx(mesh type)<<" not supported yet");1133 default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet"); 1134 1134 } 1135 1135 } … … 1788 1788 1789 1789 int index1,index2; 1790 int mesh type;1791 1792 this->parameters->FindParam(&mesh type,MeshTypeEnum);1793 switch(mesh type){1790 int meshxdim; 1791 1792 this->parameters->FindParam(&meshxdim,MeshXDimEnum); 1793 switch(meshxdim){ 1794 1794 case Mesh2DhorizontalEnum: 1795 1795 return this; … … 1807 1807 1808 1808 int index1,index2; 1809 int mesh type;1810 1811 this->parameters->FindParam(&mesh type,MeshTypeEnum);1812 switch(mesh type){1809 int meshxdim; 1810 1811 this->parameters->FindParam(&meshxdim,MeshXDimEnum); 1812 switch(meshxdim){ 1813 1813 case Mesh2DhorizontalEnum: 1814 1814 return this; … … 2166 2166 2167 2167 /*Return: */ 2168 int mesh type;2169 parameters->FindParam(&mesh type,MeshTypeEnum);2170 if(mesh type==Mesh2DverticalEnum){2168 int meshxdim; 2169 parameters->FindParam(&meshxdim,MeshXDimEnum); 2170 if(meshxdim==Mesh2DverticalEnum){ 2171 2171 return base; 2172 2172 } … … 2210 2210 IssmDouble Tria::MassFlux( IssmDouble x1, IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){ 2211 2211 2212 int mesh type;2212 int meshxdim; 2213 2213 IssmDouble mass_flux=0.; 2214 2214 IssmDouble xyz_list[NUMVERTICES][3]; … … 2241 2241 2242 2242 Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input); 2243 this->parameters->FindParam(&mesh type,MeshTypeEnum);2243 this->parameters->FindParam(&meshxdim,MeshXDimEnum); 2244 2244 Input* vx_input=NULL; 2245 2245 Input* vy_input=NULL; 2246 if(mesh type==Mesh2DhorizontalEnum){2246 if(meshxdim==Mesh2DhorizontalEnum){ 2247 2247 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); 2248 2248 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); … … 2274 2274 IssmDouble Tria::MassFlux( IssmDouble* segment){ 2275 2275 2276 int mesh type;2276 int meshxdim; 2277 2277 IssmDouble mass_flux=0.; 2278 2278 IssmDouble xyz_list[NUMVERTICES][3]; … … 2308 2308 2309 2309 Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input); 2310 this->parameters->FindParam(&mesh type,MeshTypeEnum);2310 this->parameters->FindParam(&meshxdim,MeshXDimEnum); 2311 2311 Input* vx_input=NULL; 2312 2312 Input* vy_input=NULL; 2313 if(mesh type==Mesh2DhorizontalEnum){2313 if(meshxdim==Mesh2DhorizontalEnum){ 2314 2314 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); 2315 2315 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); -
issm/trunk-jpl/src/c/classes/IoModel.cpp
r17660 r17674 30 30 this->my_vertices=NULL; 31 31 32 this->mesh type=-1;32 this->meshxdim=-1; 33 33 this->numberofvertices=-1; 34 34 this->numberofelements=-1; … … 75 75 this->my_vertices = NULL; 76 76 77 FetchData(&this->mesh type,MeshTypeEnum);77 FetchData(&this->meshxdim,MeshXDimEnum); 78 78 FetchData(&this->numberofvertices,MeshNumberofverticesEnum); 79 79 FetchData(&this->numberofelements,MeshNumberofelementsEnum); -
issm/trunk-jpl/src/c/classes/IoModel.h
r17122 r17674 31 31 32 32 /*Mesh properties and connectivity tables*/ 33 int mesh type;33 int meshxdim; 34 34 int numberofvertices; 35 35 int numberofelements; -
issm/trunk-jpl/src/c/classes/Node.cpp
r17610 r17674 43 43 44 44 Analysis* analysis = EnumToAnalysis(analysis_enum); 45 int numdofs = analysis->DofsPerNode(&doftypes,iomodel->mesh type,in_approximation);45 int numdofs = analysis->DofsPerNode(&doftypes,iomodel->meshxdim,in_approximation); 46 46 indexing.Init(numdofs,doftypes); 47 47 xDelete<int>(doftypes); … … 61 61 _assert_(sqrt( coord_system[0][0]*coord_system[0][0] + coord_system[1][0]*coord_system[1][0]) >1.e-4); 62 62 63 if(iomodel->mesh type!=Mesh2DhorizontalEnum){63 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 64 64 /*We have a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */ 65 65 _assert_(iomodel->Data(MeshVertexonbaseEnum)); … … 101 101 analysis_enum==ExtrapolationAnalysisEnum 102 102 ){ 103 if(iomodel->mesh type!=Mesh2DhorizontalEnum){103 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 104 104 /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */ 105 105 _assert_(iomodel->Data(MeshVertexonbaseEnum)); … … 112 112 analysis_enum==FreeSurfaceTopAnalysisEnum 113 113 ){ 114 if(iomodel->mesh type!=Mesh2DhorizontalEnum){114 if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ 115 115 /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */ 116 116 _assert_(iomodel->Data(MeshVertexonsurfaceEnum)); -
issm/trunk-jpl/src/c/classes/Vertex.cpp
r17555 r17674 32 32 this->y = iomodel->Data(MeshYEnum)[i]; 33 33 this->z = iomodel->Data(MeshZEnum)[i]; 34 this->mesh type = iomodel->meshtype;34 this->meshxdim = iomodel->meshxdim; 35 35 36 36 _assert_(iomodel->Data(BaseEnum) && iomodel->Data(ThicknessEnum) && iomodel->numbernodetoelementconnectivity); 37 switch(iomodel->mesh type){37 switch(iomodel->meshxdim){ 38 38 case Mesh3DEnum: 39 39 case Mesh2DhorizontalEnum: … … 132 132 133 133 /*sigma remains constant. z=bed+sigma*thickness*/ 134 switch(this->mesh type){134 switch(this->meshxdim){ 135 135 case Mesh2DhorizontalEnum: 136 136 /*Nothing*/ -
issm/trunk-jpl/src/c/classes/Vertex.h
r16447 r17674 21 21 public: 22 22 bool clone; 23 int mesh type;23 int meshxdim; 24 24 int id; // random index 25 25 int sid; // "serial" id (rank of this vertex if the dataset was on 1 cpu) -
issm/trunk-jpl/src/c/cores/bedslope_core.cpp
r16529 r17674 14 14 /*parameters: */ 15 15 bool save_results; 16 int mesh type;16 int meshxdim; 17 17 18 18 /*Recover some parameters: */ 19 19 femmodel->parameters->FindParam(&save_results,SaveResultsEnum); 20 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);20 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 21 21 22 22 if(VerboseSolution()) _printf0_(" computing slope\n"); … … 28 28 solutionsequence_linear(femmodel); 29 29 30 if(mesh type!=Mesh2DverticalEnum){30 if(meshxdim!=Mesh2DverticalEnum){ 31 31 femmodel->parameters->SetParam(BedSlopeYEnum,InputToL2ProjectEnum); 32 32 solutionsequence_linear(femmodel); … … 35 35 if(save_results){ 36 36 if(VerboseSolution()) _printf0_(" saving results\n"); 37 if(mesh type!=Mesh2DverticalEnum){37 if(meshxdim!=Mesh2DverticalEnum){ 38 38 int outputs[2] = {BedSlopeXEnum,BedSlopeYEnum}; 39 39 femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2); -
issm/trunk-jpl/src/c/cores/levelsetfunctionslope_core.cpp
r17274 r17674 14 14 /*parameters: */ 15 15 bool save_results; 16 int mesh type;16 int meshxdim; 17 17 18 18 /*Recover some parameters: */ 19 19 femmodel->parameters->FindParam(&save_results,SaveResultsEnum); 20 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);20 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 21 21 22 22 if(VerboseSolution()) _printf0_("computing slope of levelset function...\n"); … … 28 28 solutionsequence_linear(femmodel); 29 29 30 if(mesh type!=Mesh2DverticalEnum){30 if(meshxdim!=Mesh2DverticalEnum){ 31 31 femmodel->parameters->SetParam(LevelsetfunctionSlopeYEnum,InputToL2ProjectEnum); 32 32 solutionsequence_linear(femmodel); 33 33 } 34 if(mesh type==Mesh2DverticalEnum){34 if(meshxdim==Mesh2DverticalEnum){ 35 35 femmodel->parameters->SetParam(LevelsetfunctionSlopeXEnum,InputToExtrudeEnum); 36 36 extrudefrombase_core(femmodel); … … 39 39 if(save_results){ 40 40 if(VerboseSolution()) _printf0_("saving results:\n"); 41 if(mesh type!=Mesh2DverticalEnum){41 if(meshxdim!=Mesh2DverticalEnum){ 42 42 int outputs[2] = {LevelsetfunctionSlopeXEnum,LevelsetfunctionSlopeYEnum}; 43 43 femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2); -
issm/trunk-jpl/src/c/cores/masstransport_core.cpp
r17555 r17674 14 14 /*parameters: */ 15 15 int i; 16 int numoutputs,mesh type;16 int numoutputs,meshxdim; 17 17 bool save_results; 18 18 bool issmbgradients,ispdd,isdelta18o,isFS,isfreesurface,dakota_analysis; … … 29 29 femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum); 30 30 femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); 31 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);31 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 32 32 femmodel->parameters->FindParam(&numoutputs,MasstransportNumRequestedOutputsEnum); 33 33 if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,MasstransportRequestedOutputsEnum); … … 48 48 femmodel->SetCurrentConfiguration(FreeSurfaceBaseAnalysisEnum); 49 49 solutionsequence_linear(femmodel); 50 if(mesh type!=Mesh2DhorizontalEnum){50 if(meshxdim!=Mesh2DhorizontalEnum){ 51 51 femmodel->parameters->SetParam(BaseEnum,InputToExtrudeEnum); 52 52 extrudefrombase_core(femmodel); … … 54 54 femmodel->SetCurrentConfiguration(FreeSurfaceTopAnalysisEnum); 55 55 solutionsequence_linear(femmodel); 56 if(mesh type!=Mesh2DhorizontalEnum){56 if(meshxdim!=Mesh2DhorizontalEnum){ 57 57 femmodel->parameters->SetParam(SurfaceEnum,InputToExtrudeEnum); 58 58 extrudefromtop_core(femmodel); … … 62 62 if(VerboseSolution()) _printf0_(" call computational core\n"); 63 63 solutionsequence_linear(femmodel); 64 if(mesh type==Mesh2DverticalEnum){64 if(meshxdim==Mesh2DverticalEnum){ 65 65 femmodel->parameters->SetParam(ThicknessEnum,InputToExtrudeEnum); 66 66 extrudefrombase_core(femmodel); -
issm/trunk-jpl/src/c/cores/stressbalance_core.cpp
r17322 r17674 15 15 /*parameters: */ 16 16 bool dakota_analysis; 17 int mesh type;17 int meshxdim; 18 18 bool isSIA,isSSA,isL1L2,isHO,isFS; 19 19 bool save_results; … … 24 24 25 25 /* recover parameters:*/ 26 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);26 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 27 27 femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum); 28 28 femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum); … … 40 40 InputDuplicatex(femmodel,QmuVxEnum,VxEnum); 41 41 InputDuplicatex(femmodel,QmuVyEnum,VyEnum); 42 if(mesh type==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum);42 if(meshxdim==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum); 43 43 if(isFS) InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum); 44 44 } 45 45 46 46 /*Compute slopes if necessary */ 47 if(isSIA || (isFS && mesh type==Mesh2DverticalEnum)) surfaceslope_core(femmodel);47 if(isSIA || (isFS && meshxdim==Mesh2DverticalEnum)) surfaceslope_core(femmodel); 48 48 if(isFS){ 49 49 bedslope_core(femmodel); … … 74 74 75 75 /*Compute vertical velocities*/ 76 if (mesh type==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){76 if (meshxdim==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){ 77 77 analysis = new StressbalanceVerticalAnalysis(); 78 78 analysis->Core(femmodel); -
issm/trunk-jpl/src/c/cores/surfaceslope_core.cpp
r17511 r17674 14 14 /*parameters: */ 15 15 bool save_results; 16 int mesh type;16 int meshxdim; 17 17 18 18 /*Recover some parameters: */ 19 19 femmodel->parameters->FindParam(&save_results,SaveResultsEnum); 20 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);20 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 21 21 22 22 if(VerboseSolution()) _printf0_("computing slope...\n"); … … 28 28 solutionsequence_linear(femmodel); 29 29 30 if(mesh type!=Mesh2DverticalEnum){30 if(meshxdim!=Mesh2DverticalEnum){ 31 31 femmodel->parameters->SetParam(SurfaceSlopeYEnum,InputToL2ProjectEnum); 32 32 solutionsequence_linear(femmodel); 33 33 } 34 if(mesh type==Mesh2DverticalEnum){34 if(meshxdim==Mesh2DverticalEnum){ 35 35 femmodel->parameters->SetParam(SurfaceSlopeXEnum,InputToExtrudeEnum); 36 36 extrudefrombase_core(femmodel); … … 39 39 if(save_results){ 40 40 if(VerboseSolution()) _printf0_("saving results:\n"); 41 if(mesh type!=Mesh2DverticalEnum){41 if(meshxdim!=Mesh2DverticalEnum){ 42 42 int outputs[2] = {SurfaceSlopeXEnum,SurfaceSlopeYEnum}; 43 43 femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2); -
issm/trunk-jpl/src/c/cores/transient_core.cpp
r17642 r17674 26 26 bool time_adapt=false; 27 27 int output_frequency; 28 int mesh type,groundingline_migration,smb_model;28 int meshxdim,groundingline_migration,smb_model; 29 29 int numoutputs = 0; 30 30 Analysis *analysis = NULL; … … 37 37 38 38 //first recover parameters common to all solutions 39 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);39 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 40 40 femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum); 41 41 femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum); … … 66 66 InputDuplicatex(femmodel,QmuVxEnum,VxEnum); 67 67 InputDuplicatex(femmodel,QmuVyEnum,VyEnum); 68 if(mesh type==Mesh3DEnum){68 if(meshxdim==Mesh3DEnum){ 69 69 InputDuplicatex(femmodel,QmuVzEnum,VzEnum); 70 70 if(isFS)InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum); … … 78 78 } 79 79 if(isgroundingline) InputDuplicatex(femmodel,QmuMaskGroundediceLevelsetEnum,MaskGroundediceLevelsetEnum); 80 if(isthermal && mesh type==Mesh3DEnum){80 if(isthermal && meshxdim==Mesh3DEnum){ 81 81 //Update Vertex Position after updating Thickness and Bed 82 82 femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum); … … 114 114 femmodel->parameters->SetParam(save_results,SaveResultsEnum); 115 115 116 if(isthermal && mesh type==Mesh3DEnum){116 if(isthermal && meshxdim==Mesh3DEnum){ 117 117 if(VerboseSolution()) _printf0_(" computing thermal regime\n"); 118 118 thermal_core(femmodel); -
issm/trunk-jpl/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp
r17561 r17674 51 51 break; 52 52 case P1bubbleEnum: 53 switch(iomodel->mesh type){53 switch(iomodel->meshxdim){ 54 54 case Mesh2DhorizontalEnum: elementnbv = 3; break; 55 55 case Mesh2DverticalEnum: elementnbv = 3; break; … … 73 73 case P2Enum: 74 74 EdgesPartitioning(&my_edges,iomodel); 75 if(iomodel->mesh type==Mesh3DEnum){75 if(iomodel->meshxdim==Mesh3DEnum){ 76 76 FacesPartitioning(&my_faces,iomodel); 77 77 } … … 118 118 } 119 119 } 120 if(iomodel->mesh type==Mesh3DEnum){120 if(iomodel->meshxdim==Mesh3DEnum){ 121 121 for(i=0;i<iomodel->numberoffaces;i++){ 122 122 if(iomodel->faces[i*6+5]==2){/*Vertical quads*/ -
issm/trunk-jpl/src/c/modules/MeshPartitionx/MeshPartitionx.h
r17472 r17674 11 11 template <class doubletype> 12 12 int MeshPartitionx(int** pepart, int** pnpart, int numberofelements,int numberofnodes,int* elements, 13 int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int mesh type,int num_procs){13 int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int meshxdim,int num_procs){ 14 14 15 15 int noerr=1; … … 31 31 int edgecut=1; 32 32 33 switch(mesh type){33 switch(meshxdim){ 34 34 case Mesh2DhorizontalEnum: 35 35 case Mesh2DverticalEnum: … … 111 111 break; 112 112 default: 113 _error_("mesh type "<<EnumToStringx(mesh type)<<" not supported yet");113 _error_("mesh type "<<EnumToStringx(meshxdim)<<" not supported yet"); 114 114 } 115 115 -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateEdges.cpp
r17490 r17674 23 23 24 24 /*Mesh dependent variables*/ 25 if(iomodel->mesh type==Mesh2DhorizontalEnum){25 if(iomodel->meshxdim==Mesh2DhorizontalEnum){ 26 26 elementnbv = 3; 27 27 elementnbe = 3; … … 32 32 elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1; 33 33 } 34 else if(iomodel->mesh type==Mesh2DverticalEnum){34 else if(iomodel->meshxdim==Mesh2DverticalEnum){ 35 35 elementnbv = 3; 36 36 elementnbe = 3; … … 41 41 elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1; 42 42 } 43 else if(iomodel->mesh type==Mesh3DtetrasEnum){43 else if(iomodel->meshxdim==Mesh3DtetrasEnum){ 44 44 elementnbv = 4; 45 45 elementnbe = 6; … … 53 53 elementedges[2*5+0] = 2; elementedges[2*5+1] = 3; elementedges_markers[5] = 1; 54 54 } 55 else if(iomodel->mesh type==Mesh3DEnum){55 else if(iomodel->meshxdim==Mesh3DEnum){ 56 56 elementnbv = 6; 57 57 elementnbe = 9; -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp
r17555 r17674 26 26 /*Create elements*/ 27 27 if(control_analysis)iomodel->FetchData(3,InversionControlParametersEnum,InversionMinParametersEnum,InversionMaxParametersEnum); 28 switch(iomodel->mesh type){28 switch(iomodel->meshxdim){ 29 29 case Mesh2DhorizontalEnum: 30 30 for(i=0;i<iomodel->numberofelements;i++){ … … 59 59 iomodel->FetchDataToInput(elements,DamageDEnum); 60 60 for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel)); 61 switch(iomodel->mesh type){61 switch(iomodel->meshxdim){ 62 62 case Mesh2DhorizontalEnum: case Mesh2DverticalEnum: 63 63 elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum); -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateFaces.cpp
r17561 r17674 17 17 18 18 /*Check Iomodel properties*/ 19 if(iomodel->mesh type==Mesh2DhorizontalEnum || iomodel->meshtype==Mesh2DverticalEnum){19 if(iomodel->meshxdim==Mesh2DhorizontalEnum || iomodel->meshxdim==Mesh2DverticalEnum){ 20 20 /*Keep going*/ 21 21 } 22 else if(iomodel->mesh type==Mesh3DEnum){22 else if(iomodel->meshxdim==Mesh3DEnum){ 23 23 CreateFaces3d(iomodel); 24 24 return; … … 144 144 145 145 /*Mesh specific face indexing per element*/ 146 if(iomodel->mesh type==Mesh3DEnum){146 if(iomodel->meshxdim==Mesh3DEnum){ 147 147 elementnbv = 6; /*Number of vertices per element*/ 148 148 elementnbf = 5; /*Number of faces per element*/ … … 243 243 244 244 int numbervertices; 245 if(iomodel->mesh type==Mesh3DEnum){245 if(iomodel->meshxdim==Mesh3DEnum){ 246 246 if((iomodel->faces[6*facenumber+5])==1){ 247 247 numbervertices=3; -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNodes.cpp
r17525 r17674 144 144 } 145 145 id0 = id0+iomodel->numberofvertices+iomodel->numberofedges; 146 if(iomodel->mesh type==Mesh3DEnum){146 if(iomodel->meshxdim==Mesh3DEnum){ 147 147 FacesPartitioning(&my_faces,iomodel); 148 148 for(i=0;i<iomodel->numberoffaces;i++){ … … 309 309 } 310 310 id0 = id0+iomodel->numberofvertices+iomodel->numberofedges; 311 if(iomodel->mesh type==Mesh3DEnum){311 if(iomodel->meshxdim==Mesh3DEnum){ 312 312 FacesPartitioning(&my_faces,iomodel); 313 313 for(i=0;i<iomodel->numberoffaces;i++){ … … 328 328 329 329 /*P1 pressure*/ 330 if(iomodel->mesh type==Mesh3DEnum){330 if(iomodel->meshxdim==Mesh3DEnum){ 331 331 numberoffaces=iomodel->numberoffaces; 332 332 } -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp
r17472 r17674 36 36 37 37 /*Get element width*/ 38 switch(iomodel->mesh type){38 switch(iomodel->meshxdim){ 39 39 case Mesh2DhorizontalEnum: elementswidth=3; break; 40 40 case Mesh2DverticalEnum: elementswidth=3; break; -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp
r17642 r17674 19 19 20 20 int i,j,m,k; 21 int numoutputs,mesh type,smb_model;21 int numoutputs,meshxdim,smb_model; 22 22 char** requestedoutputs = NULL; 23 23 IssmDouble time; … … 41 41 42 42 /*Copy some constants from iomodel */ 43 parameters->AddObject(iomodel->CopyConstantObject(Mesh TypeEnum));43 parameters->AddObject(iomodel->CopyConstantObject(MeshXDimEnum)); 44 44 parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum)); 45 45 parameters->AddObject(iomodel->CopyConstantObject(SteadystateReltolEnum)); … … 84 84 parameters->AddObject(iomodel->CopyConstantObject(StressbalanceReltolEnum)); 85 85 parameters->AddObject(iomodel->CopyConstantObject(StressbalanceAbstolEnum)); 86 if(iomodel->mesh type==Mesh3DEnum)86 if(iomodel->meshxdim==Mesh3DEnum) 87 87 parameters->AddObject(iomodel->CopyConstantObject(MeshNumberoflayersEnum)); 88 88 -
issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp
r16637 r17674 30 30 31 31 /*Get element width (3 or 6)*/ 32 switch(iomodel->mesh type){32 switch(iomodel->meshxdim){ 33 33 case Mesh2DhorizontalEnum: elementswidth=3; break; 34 34 case Mesh2DverticalEnum : elementswidth=3; break; 35 35 case Mesh3DEnum : elementswidth=6; break; 36 default: _error_("mesh type "<<EnumToStringx(iomodel->mesh type)<<" not supported yet");36 default: _error_("mesh type "<<EnumToStringx(iomodel->meshxdim)<<" not supported yet"); 37 37 } 38 38 -
issm/trunk-jpl/src/c/modules/ModelProcessorx/EdgesPartitioning.cpp
r17490 r17674 18 18 19 19 /*Mesh dependent variables*/ 20 if(iomodel->mesh type==Mesh2DhorizontalEnum){20 if(iomodel->meshxdim==Mesh2DhorizontalEnum){ 21 21 elementnbe = 3; 22 22 } 23 else if(iomodel->mesh type==Mesh2DverticalEnum){23 else if(iomodel->meshxdim==Mesh2DverticalEnum){ 24 24 elementnbe = 3; 25 25 } 26 else if(iomodel->mesh type==Mesh3DtetrasEnum){26 else if(iomodel->meshxdim==Mesh3DtetrasEnum){ 27 27 elementnbe = 6; 28 28 } 29 else if(iomodel->mesh type==Mesh3DEnum){29 else if(iomodel->meshxdim==Mesh3DEnum){ 30 30 elementnbe = 9; 31 31 } -
issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp
r17487 r17674 51 51 /*Number of vertices per elements, needed to correctly retrieve data: */ 52 52 /*Determine parallel partitioning of elements: we use Metis for now. First load the data, then partition*/ 53 switch(iomodel->mesh type){53 switch(iomodel->meshxdim){ 54 54 case Mesh2DhorizontalEnum: 55 55 elements_width=3; … … 81 81 } 82 82 83 MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->mesh type,num_procs);83 MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->meshxdim,num_procs); 84 84 85 85 /*Free elements2d: */ -
issm/trunk-jpl/src/c/modules/ModelProcessorx/FacesPartitioning.cpp
r17122 r17674 18 18 19 19 /*Mesh dependent variables*/ 20 if(iomodel->mesh type==Mesh2DhorizontalEnum){20 if(iomodel->meshxdim==Mesh2DhorizontalEnum){ 21 21 elementnbf = 3; 22 22 } 23 else if(iomodel->mesh type==Mesh2DverticalEnum){23 else if(iomodel->meshxdim==Mesh2DverticalEnum){ 24 24 elementnbf = 3; 25 25 } 26 else if(iomodel->mesh type==Mesh3DEnum){26 else if(iomodel->meshxdim==Mesh3DEnum){ 27 27 elementnbf = 5; 28 28 } -
issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp
r17642 r17674 59 59 60 60 /*Hack for trasient runs (FIXME: to be improved)*/ 61 if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && iomodel->mesh type==Mesh2DhorizontalEnum) continue;62 if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && iomodel->mesh type==Mesh2DhorizontalEnum) continue;63 if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->mesh type==Mesh2DhorizontalEnum) continue;61 if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue; 62 if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue; 63 if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue; 64 64 if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && isthermal==false) continue; 65 65 if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && isthermal==false) continue; -
issm/trunk-jpl/src/c/modules/ModelProcessorx/NodesPartitioning.cpp
r16291 r17674 65 65 66 66 /*First: add all the nodes of all the elements belonging to this cpu*/ 67 if(iomodel->mesh type==Mesh2DhorizontalEnum){67 if(iomodel->meshxdim==Mesh2DhorizontalEnum){ 68 68 for (i=0;i<iomodel->numberofelements;i++){ 69 69 if (my_elements[i]){ -
issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp
r17610 r17674 15 15 /* intermediaries */ 16 16 bool solvein2d=false; 17 int i,in,mesh type,analysis_type;17 int i,in,meshxdim,analysis_type; 18 18 Elements* elements = femmodel->elements; 19 19 20 20 /* find parameters */ 21 femmodel->parameters->FindParam(&mesh type,MeshTypeEnum);21 femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); 22 22 23 23 for(i=0;i<elements->Size();i++){ … … 50 50 51 51 /* if solving 2d problem on vertically extende mesh, solve on basal layer only*/ 52 if(mesh type!=Mesh2DhorizontalEnum){52 if(meshxdim!=Mesh2DhorizontalEnum){ 53 53 femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum); 54 54 if( -
issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h
r17651 r17674 211 211 MeshYEnum, 212 212 MeshZEnum, 213 MeshXDimEnum, 214 MeshDimEnum, 213 215 MeshTypeEnum, 214 216 Mesh2DhorizontalEnum, -
issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp
r17651 r17674 219 219 case MeshYEnum : return "MeshY"; 220 220 case MeshZEnum : return "MeshZ"; 221 case MeshXDimEnum : return "MeshXDim"; 222 case MeshDimEnum : return "MeshDim"; 221 223 case MeshTypeEnum : return "MeshType"; 222 224 case Mesh2DhorizontalEnum : return "Mesh2Dhorizontal"; -
issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp
r17651 r17674 222 222 else if (strcmp(name,"MeshY")==0) return MeshYEnum; 223 223 else if (strcmp(name,"MeshZ")==0) return MeshZEnum; 224 else if (strcmp(name,"MeshXDim")==0) return MeshXDimEnum; 225 else if (strcmp(name,"MeshDim")==0) return MeshDimEnum; 224 226 else if (strcmp(name,"MeshType")==0) return MeshTypeEnum; 225 227 else if (strcmp(name,"Mesh2Dhorizontal")==0) return Mesh2DhorizontalEnum; … … 258 260 else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum; 259 261 else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum; 260 else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;261 else if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum;262 262 else stage=3; 263 263 } 264 264 if(stage==3){ 265 if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum; 265 if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum; 266 else if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum; 267 else if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum; 266 268 else if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum; 267 269 else if (strcmp(name,"SteadystateReltol")==0) return SteadystateReltolEnum; … … 381 383 else if (strcmp(name,"FSpressure")==0) return FSpressureEnum; 382 384 else if (strcmp(name,"Constraints")==0) return ConstraintsEnum; 383 else if (strcmp(name,"Loads")==0) return LoadsEnum;384 else if (strcmp(name,"Materials")==0) return MaterialsEnum;385 385 else stage=4; 386 386 } 387 387 if(stage==4){ 388 if (strcmp(name,"Nodes")==0) return NodesEnum; 388 if (strcmp(name,"Loads")==0) return LoadsEnum; 389 else if (strcmp(name,"Materials")==0) return MaterialsEnum; 390 else if (strcmp(name,"Nodes")==0) return NodesEnum; 389 391 else if (strcmp(name,"Contours")==0) return ContoursEnum; 390 392 else if (strcmp(name,"Parameters")==0) return ParametersEnum; … … 504 506 else if (strcmp(name,"VxPicard")==0) return VxPicardEnum; 505 507 else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; 506 else if (strcmp(name,"Vy")==0) return VyEnum;507 else if (strcmp(name,"VyPicard")==0) return VyPicardEnum;508 508 else stage=5; 509 509 } 510 510 if(stage==5){ 511 if (strcmp(name,"Vz")==0) return VzEnum; 511 if (strcmp(name,"Vy")==0) return VyEnum; 512 else if (strcmp(name,"VyPicard")==0) return VyPicardEnum; 513 else if (strcmp(name,"Vz")==0) return VzEnum; 512 514 else if (strcmp(name,"VzSSA")==0) return VzSSAEnum; 513 515 else if (strcmp(name,"VzHO")==0) return VzHOEnum; … … 627 629 else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum; 628 630 else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum; 629 else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;630 else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;631 631 else stage=6; 632 632 } 633 633 if(stage==6){ 634 if (strcmp(name,"FSSolver")==0) return FSSolverEnum; 634 if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum; 635 else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum; 636 else if (strcmp(name,"FSSolver")==0) return FSSolverEnum; 635 637 else if (strcmp(name,"Adjoint")==0) return AdjointEnum; 636 638 else if (strcmp(name,"Colinear")==0) return ColinearEnum; -
issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m
r17071 r17674 38 38 39 39 %First find segments that are not completely on the front 40 if strcmp(meshtype(md.mesh),' 3D'),40 if strcmp(meshtype(md.mesh),'Penta'), 41 41 numbernodesfront=4; 42 elseif strcmp(meshtype(md.mesh),' 2Dhorizontal'),42 elseif strcmp(meshtype(md.mesh),'Tria'), 43 43 numbernodesfront=2; 44 44 else -
issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py
r17480 r17674 44 44 45 45 #First find segments that are not completely on the front 46 if m.strcmp(md.mesh.meshtype(),' 3D'):46 if m.strcmp(md.mesh.meshtype(),'Penta'): 47 47 numbernodesfront=4; 48 elif m.strcmp(md.mesh.meshtype(),' 2Dhorizontal'):48 elif m.strcmp(md.mesh.meshtype(),'Tria'): 49 49 numbernodesfront=2; 50 50 else: -
issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m
r17475 r17674 52 52 53 53 %First find segments that are not completely on the front 54 if ~strcmp(md.mesh.mesh type(),'3D'),54 if ~strcmp(md.mesh.meshxdim(),'3D'), 55 55 numbernodesfront=2; 56 56 else -
issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py
r17480 r17674 53 53 54 54 #First find segments that are not completely on the front 55 if not m.strcmp(md.mesh.mesh type(),'3D'):55 if not m.strcmp(md.mesh.meshxdim(),'3D'): 56 56 numbernodesfront=2 57 57 else: -
issm/trunk-jpl/src/m/classes/damage.m
r17644 r17674 117 117 function list=defaultoutputs(self,md) % {{{ 118 118 119 if strcmp(meshtype(md.mesh),'3D'), 120 list = {'DamageD',}; 121 elseif strcmp(meshtype(md.mesh),'2Dhorizontal'), 122 list = {'DamageD'}; 123 elseif strcmp(meshtype(md.mesh),'2Dvertical'), 124 list = {'DamageD'}; 125 else 126 error('mesh type not supported yet'); 127 end 119 list = {'DamageD'}; 128 120 129 121 end % }}} -
issm/trunk-jpl/src/m/classes/damage.py
r17632 r17674 110 110 def defaultoutputs(self,md): # {{{ 111 111 112 if m.strcmp(md.mesh.meshtype(),'3D'): 113 list = ['DamageD'] 114 elif m.strcmp(md.mesh.meshtype(),'2Dhorizontal'): 115 list = ['DamageD'] 116 elif m.strcmp(md.mesh.meshtype(),'2Dvertical'): 117 list = ['DamageD'] 118 else: 119 raise TypeError('mesh type not supported yet') 112 list = ['DamageD'] 120 113 return list 121 114 -
issm/trunk-jpl/src/m/classes/flowequation.m
r17659 r17674 95 95 md = checkfield(md,'fieldname','flowequation.borderHO','size',[md.mesh.numberofvertices 1],'values',[0 1]); 96 96 md = checkfield(md,'fieldname','flowequation.borderFS','size',[md.mesh.numberofvertices 1],'values',[0 1]); 97 if strcmp(mesh type(md.mesh),'2Dhorizontal')97 if strcmp(meshxdim(md.mesh),'2Dhorizontal') 98 98 md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[1:2]); 99 99 md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[1:2]); 100 elseif strcmp(mesh type(md.mesh),'2Dvertical')100 elseif strcmp(meshxdim(md.mesh),'2Dvertical') 101 101 md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[2:4]); 102 102 md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[2:4]); 103 elseif strcmp(mesh type(md.mesh),'3D'),103 elseif strcmp(meshxdim(md.mesh),'3D'), 104 104 md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[0:8]); 105 105 md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[0:8]); -
issm/trunk-jpl/src/m/classes/flowequation.py
r17659 r17674 84 84 md = checkfield(md,'fieldname','flowequation.XTH_r','numel',[1],'>',0.) 85 85 md = checkfield(md,'fieldname','flowequation.XTH_theta','numel',[1],'>=',0.,'<',.5) 86 if m.strcmp(md.mesh.mesh type(),'2Dhorizontal'):86 if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): 87 87 md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',[1,2]) 88 88 md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements],'values',[1,2]) 89 elif m.strcmp(md.mesh.mesh type(),'3D'):89 elif m.strcmp(md.mesh.meshxdim(),'3D'): 90 90 md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',numpy.arange(0,8+1)) 91 91 md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements],'values',numpy.arange(0,8+1)) -
issm/trunk-jpl/src/m/classes/initialization.m
r17523 r17674 52 52 md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]); 53 53 md = checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]); 54 if strcmp(meshtype(md.mesh),'3D')54 if meshdim(md.mesh)==3 55 55 md = checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices 1]); 56 56 end -
issm/trunk-jpl/src/m/classes/initialization.py
r17480 r17674 66 66 md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices]) 67 67 md = checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices]) 68 if m .strcmp(md.mesh.meshtype(),'3D'):68 if md.mesh.meshdim()==3: 69 69 md = checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices]) 70 70 md = checkfield(md,'fieldname','initialization.pressure','NaN',1,'size',[md.mesh.numberofvertices]) -
issm/trunk-jpl/src/m/classes/mesh2d.m
r17562 r17674 105 105 end % }}} 106 106 function marshall(obj,md,fid) % {{{ 107 WriteData(fid,'enum',Mesh TypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');107 WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer'); 108 108 WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); 109 109 WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); … … 114 114 WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer'); 115 115 end % }}} 116 function t = mesh type(obj) % {{{116 function t = meshxdim(obj) % {{{ 117 117 t = '2Dhorizontal'; 118 end % }}} 119 function d = meshdim(obj) % {{{ 120 d = 2; 121 end % }}} 122 function s = meshtype(obj) % {{{ 123 s = 'Tria'; 118 124 end % }}} 119 125 end -
issm/trunk-jpl/src/m/classes/mesh2d.py
r17562 r17674 98 98 return md 99 99 # }}} 100 def mesh type(self): # {{{100 def meshxdim(self): # {{{ 101 101 return "2Dhorizontal" 102 102 #}}} 103 def meshdim(self): # {{{ 104 return 2 105 #}}} 106 def meshtype(self): # {{{ 107 return "Tria" 108 #}}} 103 109 def marshall(self,md,fid): # {{{ 104 WriteData(fid,'enum',Mesh TypeEnum(),'data',StringToEnum("Mesh"+self.meshtype())[0],'format','Integer');110 WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum("Mesh"+self.meshxdim())[0],'format','Integer'); 105 111 WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1) 106 112 WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1) -
issm/trunk-jpl/src/m/classes/mesh2dvertical.m
r17610 r17674 104 104 end % }}} 105 105 function marshall(obj,md,fid) % {{{ 106 WriteData(fid,'enum',Mesh TypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');106 WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer'); 107 107 WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); 108 108 WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); … … 115 115 WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer'); 116 116 end % }}} 117 function t = mesh type(obj) % {{{117 function t = meshxdim(obj) % {{{ 118 118 t = '2Dvertical'; 119 end % }}} 120 function d = meshdim(obj) % {{{ 121 d = 2; 122 end % }}} 123 function s = meshtype(obj) % {{{ 124 s = 'Tria'; 119 125 end % }}} 120 126 function flags = vertexflags(self,value) % {{{ -
issm/trunk-jpl/src/m/classes/mesh3dprisms.m
r17610 r17674 135 135 end % }}} 136 136 function marshall(obj,md,fid) % {{{ 137 WriteData(fid,'enum',Mesh TypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');137 WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer'); 138 138 WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); 139 139 WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); … … 154 154 WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer'); 155 155 end % }}} 156 function type = mesh type(obj) % {{{156 function type = meshxdim(obj) % {{{ 157 157 type = '3D'; 158 end % }}} 159 function d = meshdim(obj) % {{{ 160 d = 3; 161 end % }}} 162 function s = meshtype(obj) % {{{ 163 s = 'Penta'; 158 164 end % }}} 159 165 end -
issm/trunk-jpl/src/m/classes/mesh3dprisms.py
r17610 r17674 130 130 return md 131 131 # }}} 132 def mesh type(self): # {{{132 def meshxdim(self): # {{{ 133 133 return "3D" 134 134 #}}} 135 def meshdim(self): # {{{ 136 return 3 137 #}}} 138 def meshtype(self): # {{{ 139 return "Penta" 140 #}}} 135 141 def marshall(self,md,fid): # {{{ 136 WriteData(fid,'enum',Mesh TypeEnum(),'data',StringToEnum("Mesh"+self.meshtype())[0],'format','Integer');142 WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum("Mesh"+self.meshxdim())[0],'format','Integer'); 137 143 WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1) 138 144 WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1) -
issm/trunk-jpl/src/m/classes/mesh3dtetras.m
r17610 r17674 129 129 end % }}} 130 130 function marshall(obj,md,fid) % {{{ 131 WriteData(fid,'enum',Mesh TypeEnum(),'data',Mesh3DtetrasEnum,'format','Integer');131 WriteData(fid,'enum',MeshXDimEnum(),'data',Mesh3DtetrasEnum,'format','Integer'); 132 132 WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); 133 133 WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); … … 146 146 WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer'); 147 147 end % }}} 148 function type = meshtype(obj) % {{{ 149 type = '3D'; 148 function t = meshxdim(obj) % {{{ 149 t = '3D'; 150 end % }}} 151 function d = meshdim(obj) % {{{ 152 d = 3; 153 end % }}} 154 function s = meshtype(obj) % {{{ 155 s = 'Tetra'; 150 156 end % }}} 151 157 end -
issm/trunk-jpl/src/m/classes/model.m
r17610 r17674 156 156 157 157 %Check that the model is really a 3d model 158 if ~strcmp(md.mesh.mesh type(),'3D'),158 if ~strcmp(md.mesh.meshxdim(),'3D'), 159 159 error('collapse error message: only 3d mesh can be collapsed') 160 160 end … … 426 426 427 427 %Edges 428 if( strcmp(meshtype(md.mesh),'2Dhorizontal')),428 if(meshdim(md.mesh)==2), 429 429 if size(md2.mesh.edges,2)>1, %do not use ~isnan because there are some NaNs... 430 430 %renumber first two columns … … 608 608 error('number of layers should be at least 2'); 609 609 end 610 if strcmp(md.mesh.mesh type(),'3D')610 if strcmp(md.mesh.meshxdim(),'3D') 611 611 error('Cannot extrude a 3d mesh (extrude cannot be called more than once)'); 612 612 end -
issm/trunk-jpl/src/m/classes/model.py
r17610 r17674 327 327 328 328 #Edges 329 if m.strcmp(md.mesh.mesh type(),'2Dhorizontal'):329 if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): 330 330 if numpy.ndim(md2.mesh.edges)>1 and numpy.size(md2.mesh.edges,axis=1)>1: #do not use ~isnan because there are some NaNs... 331 331 #renumber first two columns -
issm/trunk-jpl/src/m/classes/modellist.m
r17559 r17674 32 32 33 33 %2D or 3D? 34 if strcmp(meshtype(md.mesh),'3D'),34 if meshdim(md.mesh)==3, 35 35 numberofelements=md.mesh.numberofelements2d; %this will be forgotten when we get out. 36 36 flags=project2d(md,flags,1); … … 84 84 for i=1:size(flag_list,1), 85 85 disp([' ' num2str(i) '/' num2str(size(flag_list,1))]); 86 if strcmp(meshtype(md.mesh),'3D'),86 if meshdim(md.mesh)==3, 87 87 flags2d=flag_list{i}; 88 88 realflags=project3d(md,flags2d,'element'); -
issm/trunk-jpl/src/m/classes/rifts.m
r17559 r17674 28 28 end 29 29 if numrifts, 30 if ~(strcmp(mesh type(md.mesh),'2Dhorizontal')),30 if ~(strcmp(meshxdim(md.mesh),'2Dhorizontal')), 31 31 md = checkmessage(md,['models with rifts are only supported in 2d for now!']); 32 32 end -
issm/trunk-jpl/src/m/classes/rifts.py
r17563 r17674 40 40 41 41 if numrifts: 42 if not m.strcmp(md.mesh.mesh type(),'2Dhorizontal'):42 if not m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): 43 43 md.checkmessage("models with rifts are only supported in 2d for now!") 44 44 if not isinstance(self.riftstruct,list): -
issm/trunk-jpl/src/m/classes/stressbalance.m
r17610 r17674 112 112 end 113 113 %CHECK THAT NO rotation specified for FS Grounded ice at base 114 if strcmp(mesh type(md.mesh),'3D') & md.flowequation.isFS,114 if strcmp(meshxdim(md.mesh),'3D') & md.flowequation.isFS, 115 115 pos=find(md.mask.groundedice_levelset>0. & md.mesh.vertexonbase); 116 116 if any(~isnan(md.stressbalance.referential(pos,:))), … … 122 122 function list=defaultoutputs(self,md) % {{{ 123 123 124 if strcmp(meshtype(md.mesh),'3D'),124 if meshdim(md.mesh)==3, 125 125 list = {'Vx','Vy','Vz','Vel','Pressure'}; 126 elseif strcmp(meshtype(md.mesh),'2Dhorizontal'), 127 list = {'Vx','Vy','Vel','Pressure'}; 128 elseif strcmp(meshtype(md.mesh),'2Dvertical'), 126 elseif meshdim(md.mesh)==2, 129 127 list = {'Vx','Vy','Vel','Pressure'}; 130 128 else -
issm/trunk-jpl/src/m/classes/stressbalance.py
r17610 r17674 110 110 def defaultoutputs(self,md): # {{{ 111 111 112 if m .strcmp(md.mesh.meshtype(),'3D'):112 if md.mesh.meshdim==3: 113 113 list = ['Vx','Vy','Vz','Vel','Pressure'] 114 el if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):114 else: 115 115 list = ['Vx','Vy','Vel','Pressure'] 116 elif m.strcmp(md.mesh.meshtype(),'2Dvertical'):117 list = ['Vx','Vy','Vel','Pressure']118 else:119 raise TypeError('mesh type not supported yet');120 116 return list 121 117 … … 129 125 md = checkfield(md,'fieldname','stressbalance.spcvx','forcing',1) 130 126 md = checkfield(md,'fieldname','stressbalance.spcvy','forcing',1) 131 if m.strcmp(md.mesh.mesh type(),'3D'):127 if m.strcmp(md.mesh.meshxdim(),'3D'): 132 128 md = checkfield(md,'fieldname','stressbalance.spcvz','forcing',1) 133 129 md = checkfield(md,'fieldname','stressbalance.restol','size',[1],'>',0) … … 161 157 md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal") 162 158 #CHECK THAT NO rotation specified for FS Grounded ice at base 163 if m.strcmp(md.mesh.mesh type(),'3D') and md.flowequation.isFS:159 if m.strcmp(md.mesh.meshxdim(),'3D') and md.flowequation.isFS: 164 160 pos=numpy.nonzero(numpy.logical_and(md.mask.groundedice_levelset,md.mesh.vertexonbase)) 165 161 if numpy.any(numpy.logical_not(numpy.isnan(md.stressbalance.referential[pos,:]))): -
issm/trunk-jpl/src/m/classes/thermal.m
r17559 r17674 64 64 md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0 1 2]); 65 65 md = checkfield(md,'fieldname','thermal.spctemperature','forcing',1); 66 if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & strcmp(meshtype(md.mesh),'3D')),66 if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & meshdim(md.mesh)==3), 67 67 pos=find(md.thermal.spctemperature(1:md.mesh.numberofvertices,:)~=NaN); 68 68 replicate=repmat(md.geometry.surface-md.mesh.z,1,size(md.thermal.spctemperature,2)); -
issm/trunk-jpl/src/m/classes/thermal.py
r17563 r17674 82 82 md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0,1,2]) 83 83 md = checkfield(md,'fieldname','thermal.spctemperature','forcing',1) 84 if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and m .strcmp(md.mesh.meshtype(),'3D'):84 if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and md.mesh.meshdim()==3: 85 85 pos=numpy.nonzero(numpy.logical_not(numpy.isnan(md.thermal.spctemperature[0:md.mesh.numberofvertices]))) 86 86 replicate=numpy.tile(md.geometry.surface-md.mesh.z,(1,numpy.size(md.thermal.spctemperature,axis=1))) -
issm/trunk-jpl/src/m/contrib/ecco/PropagateFlagsUntilDistance.m
r17559 r17674 10 10 11 11 %make 3d work in 2d: 12 if strcmp(mesh type(md.mesh),'3D'),12 if strcmp(meshxdim(md.mesh),'3D'), 13 13 md.mesh.x=md.mesh.x2d; 14 14 md.mesh.y=md.mesh.y2d; -
issm/trunk-jpl/src/m/contrib/hack/tres.m
r17559 r17674 9 9 10 10 if strcmpi(string,'stressbalance'), 11 if strcmp(mesh type(md.mesh),'2Dhorizontal'),11 if strcmp(meshxdim(md.mesh),'2Dhorizontal'), 12 12 md.initialization.vx=md.results.StressbalanceSolution.Vx; 13 13 md.initialization.vy=md.results.StressbalanceSolution.Vy; -
issm/trunk-jpl/src/m/contrib/massbalance/divergence.m
r17559 r17674 5 5 % div=divergence(md,a,b) 6 6 7 if ( strcmp(meshtype(md.mesh),'2Dhorizontal')),7 if (meshdim(md.mesh)==2), 8 8 numberofelements=md.mesh.numberofelements; 9 9 numberofnodes=md.mesh.numberofvertices; -
issm/trunk-jpl/src/m/contrib/massbalance/outflux.m
r17559 r17674 16 16 17 17 if nargin==1, 18 if strcmp(meshtype(md.mesh),'3D'),18 if meshdim(md.mesh)==3, 19 19 vxa=DepthAverage(md,md.initialization.vx); 20 20 vya=DepthAverage(md,md.initialization.vy); … … 28 28 else 29 29 step=varargin{1}; 30 if strcmp(meshtype(md.mesh),'3D'),30 if meshdim(md.mesh)==3, 31 31 vxa=DepthAverage(md,md.results.TransientSolution(step).Vx); 32 32 vya=DepthAverage(md,md.results.TransientSolution(step).Vy); -
issm/trunk-jpl/src/m/enum/EnumDefinitions.py
r17651 r17674 211 211 def MeshYEnum(): return StringToEnum("MeshY")[0] 212 212 def MeshZEnum(): return StringToEnum("MeshZ")[0] 213 def MeshXDimEnum(): return StringToEnum("MeshXDim")[0] 214 def MeshDimEnum(): return StringToEnum("MeshDim")[0] 213 215 def MeshTypeEnum(): return StringToEnum("MeshType")[0] 214 216 def Mesh2DhorizontalEnum(): return StringToEnum("Mesh2Dhorizontal")[0] -
issm/trunk-jpl/src/m/exp/contourlevelzero.m
r17559 r17674 10 10 11 11 %process data 12 if strcmp(meshtype(md.mesh),'3D'),12 if meshdim(md.mesh)==3, 13 13 error('contourlevelzero error message: routine not supported for 3d meshes, project on a layer'); 14 14 end -
issm/trunk-jpl/src/m/extrusion/DepthAverage.m
r17510 r17674 9 9 10 10 %check that the model given in input is 3d 11 if ~strcmp(md.mesh.mesh type,'3D');11 if ~strcmp(md.mesh.meshxdim,'3D'); 12 12 error('DepthAverage error message: the model given in input must be 3d') 13 13 end -
issm/trunk-jpl/src/m/extrusion/project2d.m
r17510 r17674 20 20 end 21 21 22 if ~strcmp(md3d.mesh.mesh type,'3D');22 if ~strcmp(md3d.mesh.meshxdim,'3D'); 23 23 error('wrong model type ... should be ''3d'''); 24 24 end -
issm/trunk-jpl/src/m/extrusion/project3d.m
r17465 r17674 23 23 error('bad usage'); 24 24 end 25 if ~strcmp(meshtype(md.mesh),' 3D')25 if ~strcmp(meshtype(md.mesh),'Penta') 26 26 error('input model is not 3d'); 27 27 end -
issm/trunk-jpl/src/m/extrusion/project3d.py
r17480 r17674 27 27 if not md: 28 28 raise TypeError("bad usage") 29 if not m.strcmp(md.mesh.meshtype(),' 3D'):29 if not m.strcmp(md.mesh.meshtype(),'Penta'): 30 30 raise TypeError("input model is not 3d") 31 31 -
issm/trunk-jpl/src/m/geometry/slope.m
r17559 r17674 7 7 8 8 %load some variables (it is much faster if the variab;es are loaded from md once for all) 9 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),9 if meshdim(md.mesh)==2, 10 10 numberofelements=md.mesh.numberofelements; 11 11 numberofnodes=md.mesh.numberofvertices; … … 30 30 s=sqrt(sx.^2+sy.^2); 31 31 32 if strcmp(meshtype(md.mesh),'3D'),32 if meshdim(md.mesh)==3, 33 33 sx=project3d(md,'vector',sx,'type','element'); 34 34 sy=project3d(md,'vector',sy,'type','element'); -
issm/trunk-jpl/src/m/geometry/slope.py
r17559 r17674 12 12 13 13 #load some variables (it is much faster if the variables are loaded from md once for all) 14 if m .strcmp(md.mesh.meshtype(),'2Dhorizontal'):14 if md.mesh.meshdim()==2: 15 15 numberofelements=md.mesh.numberofelements 16 16 numberofnodes=md.mesh.numberofvertices … … 39 39 s=npy.sqrt(sx**2+sy**2) 40 40 41 if m .strcmp(md.mesh.meshtype(),'3D'):41 if md.mesh.meshdim()==3: 42 42 sx=project3d(md,'vector',sx,'type','element') 43 43 sy=project3d(md,'vector',sy,'type','element') -
issm/trunk-jpl/src/m/interp/SectionValues.m
r17590 r17674 29 29 error('SectionValues error message: wrong resolution type. Resolution must be an array [horizontal_resolution vertical_resolution]') 30 30 end 31 if strcmp(meshtype(md.mesh),'3D')31 if meshdim(md.mesh)==3 32 32 if (length(resolution)==2 & isnumeric(resolution(2))) 33 33 res_v=resolution(2); … … 78 78 79 79 %New mesh and Data interpolation 80 if ( strcmp(meshtype(md.mesh),'2Dhorizontal'))80 if (meshdim(md.mesh)==2) 81 81 82 82 %Interpolation of data on specified points -
issm/trunk-jpl/src/m/interp/averaging.m
r17559 r17674 25 25 error('averaging error message: data not supported yet'); 26 26 end 27 if strcmp(meshtype(md.mesh),'3D')& nargin==4,27 if meshdim(md.mesh)==3 & nargin==4, 28 28 if varargin{1}<=0 | varargin{1}>md.mesh.numberoflayers, 29 29 error('layer should be between 1 and md.mesh.numberoflayers'); … … 56 56 %build some variables 57 57 line=index(:); 58 if strcmp(meshtype(md.mesh),'3D')& layer==0,58 if meshdim(md.mesh)==3 & layer==0, 59 59 rep=6; 60 60 areas=GetAreas(index,md.mesh.x,md.mesh.y,md.mesh.z); 61 elseif strcmp(meshtype(md.mesh),'2Dhorizontal'),61 elseif meshdim(md.mesh)==2, 62 62 rep=3; 63 63 areas=GetAreas(index,md.mesh.x,md.mesh.y); -
issm/trunk-jpl/src/m/interp/averaging.py
r17642 r17674 28 28 if len(data)!=md.mesh.numberofelements and len(data)!=md.mesh.numberofvertices: 29 29 raise StandardError('averaging error message: data not supported yet') 30 if m .strcmp(md.mesh.meshtype(),'3D')and layer!=0:30 if md.mesh.meshdim()==3 and layer!=0: 31 31 if layer<=0 or layer>md.mesh.numberoflayers: 32 32 raise ValueError('layer should be between 1 and md.mesh.numberoflayers') … … 54 54 55 55 #build some variables 56 if m .strcmp(md.mesh.meshtype(),'3D')and layer==0:56 if md.mesh.meshdim()==3 and layer==0: 57 57 rep=6 58 58 areas=GetAreas(index,md.mesh.x,md.mesh.y,md.mesh.z) 59 elif m .strcmp(md.mesh.meshtype(),'2Dhorizontal'):59 elif md.mesh.meshdim()==2: 60 60 rep=3 61 61 areas=GetAreas(index,md.mesh.x,md.mesh.y) -
issm/trunk-jpl/src/m/inversions/velocitymisfit.m
r17559 r17674 9 9 % 10 10 11 if strcmp(meshtype(md.mesh),'2Dhorizontal'),11 if meshdim(md.mesh)==2, 12 12 elements=md.mesh.elements; 13 13 x=md.mesh.x; -
issm/trunk-jpl/src/m/mech/analyticaldamage.m
r17559 r17674 48 48 error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']); 49 49 end 50 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),50 if meshdim(md.mesh)~=2, 51 51 error('only 2d model supported currently'); 52 52 end -
issm/trunk-jpl/src/m/mech/backstressfrominversion.m
r17559 r17674 41 41 error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']); 42 42 end 43 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),43 if meshdim(md.mesh)~=2, 44 44 error('only 2d model supported currently'); 45 45 end -
issm/trunk-jpl/src/m/mech/damagefrominversion.m
r17559 r17674 21 21 error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']); 22 22 end 23 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),23 if meshdim(md.mesh)~=2, 24 24 error('only 2d model supported currently'); 25 25 end -
issm/trunk-jpl/src/m/mech/mechanicalproperties.m
r17559 r17674 17 17 %error(['the input velocity should be of size ' num2str(md.mesh.numberofvertices) '!']) 18 18 end 19 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal'))19 if meshdim(md.mesh)~=2 20 20 error('only 2d model supported yet'); 21 21 end -
issm/trunk-jpl/src/m/mech/strainrateuncert.m
r17559 r17674 32 32 error(['the velocity error dvy should be of size ' num2str(md.mesh.numberofelements) ' or 1!']) 33 33 end 34 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal'))34 if meshdim(md.mesh)~=2, 35 35 error('only 2d model supported yet'); 36 36 end -
issm/trunk-jpl/src/m/mech/thomasparams.m
r17559 r17674 51 51 error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']) 52 52 end 53 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal'))53 if meshdim(md.mesh)~=2, 54 54 error('only 2d model supported currently'); 55 55 end -
issm/trunk-jpl/src/m/mesh/bamg.m
r17559 r17674 284 284 %}}} 285 285 % Bamg Mesh parameters {{{ 286 if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & strcmp(meshtype(md.mesh),' 2Dhorizontal')),286 if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & strcmp(meshtype(md.mesh),'Tria')), 287 287 288 288 if isstruct(md.private.bamg) & isfield(md.private.bamg,'mesh'), -
issm/trunk-jpl/src/m/mesh/bamg.py
r17559 r17674 272 272 #}}} 273 273 # Bamg Mesh parameters {{{ 274 if not options.exist('domain') and md.mesh.numberofvertices and m.strcmp(md.mesh.meshtype(),' 2Dhorizontal'):274 if not options.exist('domain') and md.mesh.numberofvertices and m.strcmp(md.mesh.meshtype(),'Tria'): 275 275 276 276 if isinstance(md.private.bamg,dict) and 'mesh' in md.private.bamg: -
issm/trunk-jpl/src/m/miscellaneous/vorticity.m
r17575 r17674 9 9 10 10 %load some variables (it is much faster if the variab;es are loaded from md once for all) 11 if ~strcmpi(md.mesh.mesh type(),'3D'),11 if ~strcmpi(md.mesh.meshxdim(),'3D'), 12 12 numberofelements=md.mesh.numberofelements; 13 13 numberofnodes=md.mesh.numberofvertices; -
issm/trunk-jpl/src/m/parameterization/contourenvelope.m
r17558 r17674 42 42 %get nodes inside profile 43 43 mesh.elementconnectivity=md.mesh.elementconnectivity; 44 if strcmp(md.mesh.mesh type(),'2Dhorizontal'),44 if strcmp(md.mesh.meshxdim(),'2Dhorizontal'), 45 45 mesh.elements=md.mesh.elements; 46 46 mesh.x=md.mesh.x; -
issm/trunk-jpl/src/m/parameterization/contourenvelope.py
r17602 r17674 47 47 #get nodes inside profile 48 48 elementconnectivity=copy.deepcopy(md.mesh.elementconnectivity) 49 if m.strcmp(md.mesh.mesh type(),'2Dhorizontal'):49 if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): 50 50 elements=copy.deepcopy(md.mesh.elements) 51 51 x=copy.deepcopy(md.mesh.x) -
issm/trunk-jpl/src/m/parameterization/setflowequation.m
r16317 r17674 71 71 72 72 %Check that no L1L2 or HO or FS for 2d mesh 73 if strcmp(meshtype(md.mesh),'2Dhorizontal')73 if meshdim(md.mesh)==2 74 74 if any(L1L2flag | FSflag | HOflag) 75 75 error('FS and HO elements not allowed in 2d mesh, extrude it first') -
issm/trunk-jpl/src/m/partition/AreaAverageOntoPartition.m
r17559 r17674 9 9 10 10 %some checks 11 if strcmp(meshtype(md.mesh),'3D'),11 if meshdim(md.mesh)==3, 12 12 if nargin~=3, 13 13 error('layer should be provided onto which Area Averaging occurs'); … … 51 51 52 52 %in 3D, restore 3D model: 53 if strcmp(meshtype(md.mesh),'3D'),53 if meshdim(md.mesh)==3, 54 54 md=md3d; 55 55 end -
issm/trunk-jpl/src/m/partition/partitioner.m
r17559 r17674 30 30 recomputeadjacency=getfieldvalue(options,'recomputeadjacency'); 31 31 32 if( strcmp(meshtype(md.mesh),'3D')),32 if(meshdim(md.mesh)==3), 33 33 %partitioning essentially happens in 2D. So partition in 2D, then 34 34 %extrude the partition vector vertically. … … 100 100 101 101 %extrude if we are in 3D: 102 if strcmp(meshtype(md.mesh),'3D'),102 if meshdim(md.mesh)==3, 103 103 md3d.qmu.vertex_weight=md.qmu.vertex_weight; 104 104 md3d.qmu.adjacency=md.qmu.adjacency; -
issm/trunk-jpl/src/m/plot/applyoptions.m
r17568 r17674 49 49 50 50 %view 51 if strcmp(mesh type(md.mesh),'3D') & ~exist(options,'layer'),51 if strcmp(meshxdim(md.mesh),'3D') & ~exist(options,'layer'), 52 52 view(getfieldvalue(options,'view',3)); 53 53 else … … 60 60 eval(['axis ' getfieldvalue(options,'axis')]); 61 61 else 62 if strcmpi(mesh type(md.mesh),'2Dhorizontal') | exist(options,'layer'),62 if strcmpi(meshxdim(md.mesh),'2Dhorizontal') | exist(options,'layer'), 63 63 axis tight equal; 64 64 else -
issm/trunk-jpl/src/m/plot/plot_basaldrag.m
r17590 r17674 9 9 10 10 %check layer 11 if strcmp(meshtype(md.mesh),'3D'),11 if meshdim(md.mesh)==3, 12 12 if getfieldvalue(options,'layer',1)~=1; 13 13 disp('plot_basaldrag warning: basal drag is displayed in the lower layer') -
issm/trunk-jpl/src/m/plot/plot_edges.m
r17559 r17674 17 17 end 18 18 19 if (strcmp(mesh type(md.mesh),'2Dhorizontal')),19 if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), 20 20 %plot mesh 21 21 A=elements(:,1); B=elements(:,2); C=elements(:,3); -
issm/trunk-jpl/src/m/plot/plot_icefront.m
r17559 r17674 19 19 elementzeroice=sum(zeroice(md.mesh.elements),2); 20 20 21 if (strcmp(mesh type(md.mesh),'2Dhorizontal')),21 if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), 22 22 icefront=(elementice & elementnoice) & ~(elementice==2 & elementzeroice); 23 23 -
issm/trunk-jpl/src/m/plot/plot_penalties.m
r17559 r17674 21 21 end 22 22 23 if ~strcmp(mesh type(md.mesh),'3D'),23 if ~strcmp(meshxdim(md.mesh),'3D'), 24 24 error('no penalties to plot for ''2d'' model'); 25 25 elseif isempty(md.penalties), -
issm/trunk-jpl/src/m/plot/plot_qmu_mass_flux_segments.m
r17559 r17674 13 13 allsegments=md.qmu.mass_flux_segments; 14 14 15 if (strcmp(mesh type(md.mesh),'2Dhorizontal')),15 if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), 16 16 17 17 %recover segments -
issm/trunk-jpl/src/m/plot/plot_referential.m
r17559 r17674 28 28 Yhat=cross(Zhat,Xhat); 29 29 30 if (strcmp(mesh type(md.mesh),'2Dhorizontal')),30 if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), 31 31 32 32 %plot mesh -
issm/trunk-jpl/src/m/plot/plot_section.m
r17559 r17674 203 203 %apply options 204 204 options=addfielddefault(options,'title','Section value'); 205 if (strcmp(meshtype(md.mesh),'2Dhorizontal'))205 if meshdim(md.mesh)==2 206 206 options=addfielddefault(options,'colorbar',0); 207 207 end 208 if (( strcmp(meshtype(md.mesh),'2Dhorizontal')) | getfieldvalue(options,'view')==2 )208 if ((meshdim(md.mesh)==2) | getfieldvalue(options,'view')==2 ) 209 209 options=addfielddefault(options,'xlabel','Curvilinear coordinate'); 210 210 options=addfielddefault(options,'axis','auto'); 211 211 end 212 if ( strcmp(meshtype(md.mesh),'3D')& getfieldvalue(options,'view')==2 )212 if (meshdim(md.mesh)==3 & getfieldvalue(options,'view')==2 ) 213 213 options=addfielddefault(options,'ylabel','z'); 214 214 end -
issm/trunk-jpl/src/m/plot/plot_segments.m
r17559 r17674 14 14 segments=md.mesh.segments; 15 15 16 if (strcmp(mesh type(md.mesh),'2Dhorizontal')),16 if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), 17 17 %plot mesh 18 18 A=elements(:,1); B=elements(:,2); C=elements(:,3); -
issm/trunk-jpl/src/m/plot/plot_tensor_components.m
r17559 r17674 10 10 upperplots=fix((i-1)/width); 11 11 if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end 12 if (strcmp(mesh type(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes12 if (strcmp(meshxdim(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes 13 13 index1=4*width*upperplots+2*leftplots+1; 14 14 index2=index1+1; 15 15 index3=index1+width*2; 16 elseif strcmp(meshtype(md.mesh),'3D')%6 components -> 6 indexes16 elseif meshdim(md.mesh)==3%6 components -> 6 indexes 17 17 index1=3*3*width*upperplots+3*leftplots+1; 18 18 index2=index1+1; … … 28 28 [tensor.yy datatype]=processdata(md,tensor.yy,options); 29 29 [tensor.xy datatype]=processdata(md,tensor.xy,options); 30 if strcmp(meshtype(md.mesh),'3D')30 if meshdim(md.mesh)==3 31 31 [tensor.xz datatype]=processdata(md,tensor.xz,options); 32 32 [tensor.yz datatype]=processdata(md,tensor.yz,options); … … 34 34 end 35 35 36 if ((strcmp(mesh type(md.mesh),'2Dhorizontal'))),36 if ((strcmp(meshxdim(md.mesh),'2Dhorizontal'))), 37 37 subplot(2*width,2*width,index1), 38 38 plot_unit(x,y,z,elements,tensor.xx,is2d,isplanet,datatype,options) -
issm/trunk-jpl/src/m/plot/plot_tensor_principal.m
r17559 r17674 10 10 upperplots=fix((i-1)/width); 11 11 if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end 12 if ( strcmp(meshtype(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes12 if (meshdim(md.mesh)==2)%3 components -> 3 indexes 13 13 index1=4*width*upperplots+2*leftplots+1; 14 14 index2=index1+1; … … 16 16 index4=index3+1; 17 17 newwidth=2*width; 18 elseif strcmp(meshtype(md.mesh),'3D')%6 components -> 6 indexes18 elseif meshdim(md.mesh)==3%6 components -> 6 indexes 19 19 index1=3*3*width*upperplots+3*leftplots+1; 20 20 index2=index1+1; … … 31 31 type2=[type 'axis2']; 32 32 plot_tensor_principalaxis(md,options,newwidth,index2,tensor,type2,plot_options); 33 if strcmp(meshtype(md.mesh),'3D')33 if meshdim(md.mesh)==3 34 34 type3=[type 'axis3']; 35 35 plot_tensor_principalaxis(md,options,newwidth,index3,tensor,type3,plot_options); … … 40 40 [tensor.principalvalue1 datatype]=processdata(md,tensor.principalvalue1,options); 41 41 [tensor.principalvalue2 datatype]=processdata(md,tensor.principalvalue2,options); 42 if strcmp(meshtype(md.mesh),'3D')42 if meshdim(md.mesh)==3 43 43 [tensor.principalvalue3 datatype]=processdata(md,tensor.principalvalue3,options); 44 44 end 45 45 46 if ((strcmp(meshtype(md.mesh),'2Dhorizontal'))),46 if meshdim(md.mesh)==2, 47 47 subplot(2*width,2*width,index3) 48 48 plot_unit(x,y,z,elements,tensor.principalvalue1,is2d,isplanet,datatype,options) -
issm/trunk-jpl/src/m/plot/plot_tensor_principalaxis.m
r17559 r17674 13 13 [x y z elements is2d isplanet]=processmesh(md,[],options); 14 14 15 if ((strcmp(meshtype(md.mesh),'2Dhorizontal'))),15 if meshdim(md.mesh)==2, 16 16 eval(['Vx=tensor.principalaxis' type(end) '(:,1); Vy=tensor.principalaxis' type(end) '(:,2);']) 17 17 eval(['value=tensor.principalvalue' type(end) ';']); … … 33 33 34 34 %plot quivers 35 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),35 if meshdim(md.mesh)==2, 36 36 37 37 %density -
issm/trunk-jpl/src/m/plot/plot_transient_results.m
r17559 r17674 41 41 clear string; 42 42 43 if strcmp(mesh type(md.mesh),'3D'),43 if strcmp(meshxdim(md.mesh),'3D'), 44 44 string='plotmodel(md'; 45 45 for i=1:length(md.results.transient), … … 67 67 clear string; 68 68 69 if strcmp(mesh type(md.mesh),'3D'),69 if strcmp(meshxdim(md.mesh),'3D'), 70 70 string='plotmodel(md'; 71 71 for i=2:length(md.results.transient), -
issm/trunk-jpl/src/m/plot/processdata.m
r17597 r17674 23 23 24 24 %special case for mesh 2dvertical 25 if strcmp(mesh type(md.mesh),'2Dvertical'),25 if strcmp(meshxdim(md.mesh),'2Dvertical'), 26 26 [data datatype] = processdata(md.mesh,md,data,options); 27 27 return; … … 56 56 57 57 %check length 58 if datasize(1)~=md.mesh.numberofvertices & datasize(1)~=md.mesh.numberofelements & datasize(1)~=md.mesh.numberofvertices*6 & (strcmp(md.mesh.mesh type(),'3D') & ~(datasize(1)==numberofelements2d | datasize(1)==numberofvertices2d))58 if datasize(1)~=md.mesh.numberofvertices & datasize(1)~=md.mesh.numberofelements & datasize(1)~=md.mesh.numberofvertices*6 & (strcmp(md.mesh.meshxdim(),'3D') & ~(datasize(1)==numberofelements2d | datasize(1)==numberofvertices2d)) 59 59 error('plotmodel error message: data not supported yet'); 60 60 end … … 65 65 66 66 %check number of columns, add zeros if necessary, 67 if (strcmp(md.mesh.mesh type(),'3D'))67 if (strcmp(md.mesh.meshxdim(),'3D')) 68 68 if datasize(2)==2, 69 69 data=[data, zeros(datasize(1),1)]; … … 85 85 86 86 %treat the case datasize(1)=nodes2d 87 if (strcmp(md.mesh.mesh type(),'3D') & datasize(1)==numberofvertices2d),87 if (strcmp(md.mesh.meshxdim(),'3D') & datasize(1)==numberofvertices2d), 88 88 data=project3d(md,'vector',data,'type','node'); 89 89 datasize(1)=md.mesh.numberofvertices; … … 92 92 93 93 %treat the case datasize(1)=nodes2d 94 if (strcmp(md.mesh.mesh type(),'3D') & datasize(1)==numberofelements2d),94 if (strcmp(md.mesh.meshxdim(),'3D') & datasize(1)==numberofelements2d), 95 95 data=project3d(md,'vector',data,'type','element'); 96 96 datasize(1)=md.mesh.numberofelements; -
issm/trunk-jpl/src/m/plot/processmesh.m
r17578 r17674 16 16 17 17 %special case for mesg 2dvertical 18 if strcmp(mesh type(md.mesh),'2Dvertical'),18 if strcmp(meshxdim(md.mesh),'2Dvertical'), 19 19 [x y z elements is2d isplanet] = processmesh(md.mesh,options); 20 20 return; … … 46 46 47 47 %is it a 2d plot? 48 if ~strcmp(md.mesh.meshtype(),'3D');48 if md.mesh.meshdim()==2, 49 49 is2d=1; 50 50 else -
issm/trunk-jpl/src/m/plot/processmesh.py
r17597 r17674 42 42 43 43 #is it a 2D plot? 44 if m.strcmp(md.mesh.mesh type(),'2Dhorizontal'):44 if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): 45 45 is2d=1 46 elif m.strcmp(md.mesh.mesh type(),'3D'):46 elif m.strcmp(md.mesh.meshxdim(),'3D'): 47 47 if options.getfieldvalue('layer',0)>=1: 48 48 is2d=1 … … 64 64 else: 65 65 #Process mesh for plotting 66 if m.strcmp(md.mesh.mesh type(),'2Dhorizontal'):66 if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): 67 67 is2d=1 68 68 else: -
issm/trunk-jpl/src/wrappers/MeshPartition/MeshPartition.cpp
r16329 r17674 19 19 20 20 /* required input: */ 21 int mesh type;21 int meshxdim; 22 22 int numberofelements; 23 23 int numberofvertices; … … 50 50 51 51 if(strcmp(mxGetClassName(MESH),"mesh3d")==0){ 52 mesh type= Mesh3DEnum;52 meshxdim = Mesh3DEnum; 53 53 FetchData(&numberofelements2d,mxGetAssignedField(MESH,0,"numberofelements2d")); 54 54 FetchData(&numberofvertices2d,mxGetAssignedField(MESH,0,"numberofvertices2d")); … … 57 57 } 58 58 else if(strcmp(mxGetClassName(MESH),"mesh2dhorizontal")==0){ 59 mesh type= Mesh2DhorizontalEnum;59 meshxdim = Mesh2DhorizontalEnum; 60 60 numberoflayers=1; 61 61 } 62 62 else if(strcmp(mxGetClassName(MESH),"mesh2dvertical")==0){ 63 mesh type= Mesh2DverticalEnum;63 meshxdim = Mesh2DverticalEnum; 64 64 numberoflayers=1; 65 65 } … … 71 71 /*Run partitioning algorithm based on a "clever" use of the Metis partitioner: */ 72 72 MeshPartitionx(&int_element_partitioning,&int_node_partitioning,numberofelements,numberofvertices,elements, 73 numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,mesh type,numareas);73 numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,meshxdim,numareas); 74 74 75 75 /*Post process node_partitioning and element_partitioning to be in double format. Metis needed them in int* format: */
Note:
See TracChangeset
for help on using the changeset viewer.