Index: /issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processor*/ -int AdjointBalancethicknessAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int AdjointBalancethicknessAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -49,10 +49,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -62,5 +62,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); xDelete(dbasis); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete gauss; return pe; @@ -152,7 +152,7 @@ void AdjointBalancethicknessAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,AdjointEnum); @@ -161,5 +161,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,AdjointEnum); break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -68,5 +68,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; } @@ -136,5 +136,5 @@ xDelete(dbasis); xDelete(xyz_list); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -304,5 +304,5 @@ /*Intermediaries */ - int num_responses,i,meshxdim,dim; + int num_responses,i,domaintype,dim; IssmDouble Jdet,obs_velocity_mag,velocity_mag; IssmDouble vx,vy,vxobs,vyobs,dux,duy,weight; @@ -312,9 +312,9 @@ /*Get problem dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -697,5 +697,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(xyz_list); xDelete(basis); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete gauss; return pe; Index: /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/Analysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/Analysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/Analysis.h (revision 17686) @@ -25,5 +25,5 @@ /*Model processing*/ - virtual int DofsPerNode(int** doflist,int meshxdim,int approximation)=0; + virtual int DofsPerNode(int** doflist,int domaintype,int approximation)=0; virtual void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum)=0; virtual void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type)=0; Index: /issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int BalancethicknessAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int BalancethicknessAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -44,5 +44,5 @@ iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); @@ -55,8 +55,8 @@ /*Check in 3d*/ - if(stabilization==3 && iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet"); + if(stabilization==3 && iomodel->domaintype==Mesh3DEnum) _error_("DG 3d not implemented yet"); /*First fetch data: */ - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); if(stabilization!=3){ ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1Enum); @@ -141,7 +141,7 @@ } - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -150,5 +150,5 @@ /*Intermediaries */ int stabilization; - int meshxdim; + int domaintype; IssmDouble Jdet,D_scalar,h; IssmDouble vel,vx,vy,dvxdx,dvydy; @@ -167,9 +167,9 @@ /*Retrieve all inputs and parameters*/ element->GetVerticesCoordinates(&xyz_list); - element->FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); element->FindParam(&stabilization,BalancethicknessStabilizationEnum); Input* vxaverage_input=NULL; Input* vyaverage_input=NULL; - if(meshxdim==Mesh2DhorizontalEnum){ + if(domaintype==Mesh2DhorizontalEnum){ vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); @@ -253,5 +253,5 @@ /*Intermediaries */ - int meshxdim; + int domaintype; IssmDouble Jdet,D_scalar,vx,vy,dvxdx,dvydy,vel; IssmDouble dvx[2],dvy[2]; @@ -269,8 +269,8 @@ /*Retrieve all inputs and parameters*/ element->GetVerticesCoordinates(&xyz_list); - element->FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); Input* vxaverage_input=NULL; Input* vyaverage_input=NULL; - if(meshxdim==Mesh2DhorizontalEnum){ + if(domaintype==Mesh2DhorizontalEnum){ vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); @@ -333,7 +333,7 @@ } - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -480,7 +480,7 @@ void BalancethicknessAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,ThicknessEnum); @@ -489,5 +489,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,ThicknessEnum); break; - default: _error_("mesh "<FetchDataToInput(elements,BalancethicknessThickeningRateEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); @@ -41,5 +41,5 @@ /*Check in 3d*/ - if(iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet"); + if(iomodel->domaintype==Mesh3DEnum) _error_("DG 3d not implemented yet"); /*First fetch data: */ @@ -148,10 +148,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -161,5 +161,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(Ny); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -243,7 +243,7 @@ void BalancevelocityAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,VelEnum); @@ -252,5 +252,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,VelEnum); break; - default: _error_("mesh "<FetchDataToInput(elements,VxEnum); iomodel->FetchDataToInput(elements,VyEnum); - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum); iomodel->FetchDataToInput(elements,DamageDEnum); iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); @@ -73,5 +73,5 @@ void DamageEvolutionAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); ::CreateNodes(nodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum); iomodel->DeleteData(1,MeshVertexonbaseEnum); @@ -109,5 +109,5 @@ /*Intermediaries*/ Element* basalelement; - int meshxdim,dim; + int domaintype,dim; int stabilization; IssmDouble Jdet,dt,D_scalar,h; @@ -116,6 +116,6 @@ /*Get problem dimension and basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -127,5 +127,5 @@ dim = 2; break; - default: _error_("mesh "<GetInput(VxEnum); _assert_(vxaverage_input); vyaverage_input=basalelement->GetInput(VyEnum); _assert_(vyaverage_input); @@ -249,5 +249,5 @@ xDelete(D); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -258,5 +258,5 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; IssmDouble Jdet,dt; @@ -265,6 +265,6 @@ /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -274,5 +274,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(xyz_list); xDelete(basis); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete gauss; return pe; @@ -377,11 +377,11 @@ void DamageEvolutionAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim; + int domaintype; IssmDouble max_damage; int *doflist = NULL; Element* basalelement=NULL; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){ + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){ if(!element->IsOnBase()) return; basalelement=element->SpawnBasalElement(); @@ -416,5 +416,5 @@ xDelete(newdamage); xDelete(doflist); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ void DamageEvolutionAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ Index: /issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int DepthAverageAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int DepthAverageAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -22,5 +22,5 @@ } - if(iomodel->meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); } @@ -54,11 +54,11 @@ /*Get dimension*/ - int dim,meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int dim,domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<meshxdim==Mesh2DhorizontalEnum)return; + if(iomodel->domaintype==Mesh2DhorizontalEnum)return; /*Is enthalpy requested?*/ @@ -94,5 +94,5 @@ void EnthalpyAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,EnthalpyAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -117,5 +117,5 @@ /*return if 2d mesh*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum) return; + if(iomodel->domaintype==Mesh2DhorizontalEnum) return; /*Fetch data: */ Index: /issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.h (revision 17686) @@ -8,5 +8,5 @@ #endif /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ #include "../solutionsequences/solutionsequences.h" -int ExtrapolationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int ExtrapolationAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; } @@ -30,5 +30,5 @@ } } - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); @@ -38,5 +38,5 @@ void ExtrapolationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ int finiteelement=P1Enum; - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,ExtrapolationAnalysisEnum,finiteelement); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -88,5 +88,5 @@ /*Intermediaries */ - int meshxdim,dim; + int domaintype,dim; int i,row,col,stabilization; bool extrapolatebydiffusion = true; @@ -97,10 +97,10 @@ /*Get problem dimension*/ - basalelement->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + basalelement->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1; break; case Mesh2DhorizontalEnum: dim = 2; break; case Mesh3DEnum: dim = 2; break; - default: _error_("mesh "<(normal); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; @@ -223,5 +223,5 @@ /*Intermediaries */ - int i, meshxdim; + int i, domaintype; /*Fetch number of nodes */ @@ -233,6 +233,6 @@ pe->values[i]=0.; - basalelement->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + basalelement->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -242,8 +242,8 @@ void ExtrapolationAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim, extrapolationvariable; - element->FindParam(&meshxdim,MeshXDimEnum); + int domaintype, extrapolationvariable; + element->FindParam(&domaintype,DomainTypeEnum); element->FindParam(&extrapolationvariable, ExtrapolationVariableEnum); - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,extrapolationvariable); @@ -252,5 +252,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,extrapolationvariable); break; - default: _error_("mesh "<meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); } @@ -68,10 +68,10 @@ /*Get dimension*/ - int dim,meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int dim,domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int dim,domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int dim,domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); } @@ -64,14 +64,14 @@ /*Intermediaries */ - int meshxdim,dim; + int domaintype,dim; IssmDouble Jdet,D; IssmDouble *xyz_list = NULL; /*Get dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int dim,domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int dim,domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; - default: _error_("mesh "<meshxdim==Mesh2DhorizontalEnum)return; + if (iomodel->domaintype==Mesh2DhorizontalEnum)return; /*Finite element type*/ @@ -35,5 +35,5 @@ iomodel->FetchDataToInput(elements,VxEnum); iomodel->FetchDataToInput(elements,VyEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,VzEnum); iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); @@ -43,5 +43,5 @@ void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -60,5 +60,5 @@ IssmDouble *nodeonbase=NULL; iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); for(int i=0;imeshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ if(!(reCast(nodeonbase[reCast(vertex_pairing[2*i+0])-1])) || !(reCast(nodeonbase[reCast(vertex_pairing[2*i+1])-1]))) continue; } @@ -105,5 +105,5 @@ /*Intermediaries*/ - int meshxdim,dim,stabilization; + int domaintype,dim,stabilization; Element* basalelement = NULL; IssmDouble *xyz_list = NULL; @@ -112,6 +112,6 @@ /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -128,5 +128,5 @@ dim = 2; break; - default: _error_("mesh "<(D); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ ElementVector* FreeSurfaceBaseAnalysis::CreatePVector(Element* element){/*{{{*/ /*Intermediaries*/ - int meshxdim,dim; + int domaintype,dim; IssmDouble Jdet,dt; IssmDouble mb,mb_correction,bed,vz; @@ -235,6 +235,6 @@ /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -251,5 +251,5 @@ dim = 2; break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; Index: /issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -14,5 +14,5 @@ /*Now, is the model 3d? otherwise, do nothing: */ - if (iomodel->meshxdim==Mesh2DhorizontalEnum)return; + if (iomodel->domaintype==Mesh2DhorizontalEnum)return; int smb_model; @@ -35,6 +35,6 @@ iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); iomodel->FetchDataToInput(elements,VxEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,VzEnum); iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); @@ -52,5 +52,5 @@ void FreeSurfaceTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -69,5 +69,5 @@ IssmDouble *nodeonsurface=NULL; iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum); for(int i=0;imeshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ if(!(reCast(nodeonsurface[reCast(vertex_pairing[2*i+0])-1])) || !(reCast(nodeonsurface[reCast(vertex_pairing[2*i+1])-1]))) continue; } @@ -114,5 +114,5 @@ /*Intermediaries*/ - int meshxdim,dim,stabilization; + int domaintype,dim,stabilization; Element* topelement = NULL; IssmDouble *xyz_list = NULL; @@ -121,6 +121,6 @@ /*Get top element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: topelement = element; @@ -137,5 +137,5 @@ dim = 2; break; - default: _error_("mesh "<(D); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;}; + if(domaintype!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;}; return Ke; }/*}}}*/ ElementVector* FreeSurfaceTopAnalysis::CreatePVector(Element* element){/*{{{*/ /*Intermediaries*/ - int meshxdim,dim; + int domaintype,dim; IssmDouble Jdet,dt; IssmDouble ms,surface,vz; @@ -244,6 +244,6 @@ /*Get top element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: topelement = element; @@ -260,5 +260,5 @@ dim = 2; break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;}; + if(domaintype!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;}; return pe; Index: /issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/GiaAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/GiaAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/GiaAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int GiaAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int GiaAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ Index: /issm/trunk-jpl/src/c/analyses/GiaAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/GiaAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/GiaAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int HydrologyDCEfficientAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int HydrologyDCEfficientAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -56,5 +56,5 @@ iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum); iomodel->FetchDataToInput(elements,HydrologydcEplThicknessEnum); - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); // elements->InputDuplicate(HydrologydcEplInitialThicknessEnum,HydrologydcEplThicknessEnum); @@ -73,5 +73,5 @@ if(!isefficientlayer) return; - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -111,10 +111,10 @@ /*Intermediaries*/ bool active_element; - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -124,5 +124,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement; @@ -207,5 +207,5 @@ xDelete(B); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; @@ -215,10 +215,10 @@ /*Intermediaries*/ bool active_element; - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -228,5 +228,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement; @@ -309,5 +309,5 @@ xDelete(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -317,10 +317,10 @@ void HydrologyDCEfficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim,i; + int domaintype,i; Element* basalelement=NULL; - element->FindParam(&meshxdim,MeshXDimEnum); - - if(meshxdim!=Mesh2DhorizontalEnum){ + element->FindParam(&domaintype,DomainTypeEnum); + + if(domaintype!=Mesh2DhorizontalEnum){ if(!element->IsOnBase()) return; basalelement=element->SpawnBasalElement(); @@ -351,5 +351,5 @@ xDelete(eplHeads); xDelete(doflist); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; } /*}}}*/ void HydrologyDCEfficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ @@ -481,10 +481,10 @@ bool active_element; - int meshxdim; + int domaintype; IssmDouble dt,A,B; IssmDouble EPLgrad2; IssmDouble EPL_N; - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); for(int j=0;jelements->Size();j++){ @@ -492,5 +492,5 @@ Element* element=(Element*)femmodel->elements->GetObjectByOffset(j); - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: if(!element->IsOnBase()) return; @@ -602,5 +602,5 @@ bool active_element; int i,j; - int meshxdim; + int domaintype; IssmDouble h_max; IssmDouble sedheadmin; @@ -608,6 +608,6 @@ /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -617,5 +617,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; xDelete(epl_thickness); xDelete(old_active); @@ -684,10 +684,10 @@ /*Constants*/ - int meshxdim; + int domaintype; Element* basalelement=NULL; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -697,5 +697,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; xDelete(active); } Index: /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.h (revision 17686) @@ -14,5 +14,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp (revision 17686) @@ -7,5 +7,5 @@ /*Model processing*/ -int HydrologyDCInefficientAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int HydrologyDCInefficientAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -88,5 +88,5 @@ iomodel->FetchDataToInput(elements,SedimentHeadEnum); iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum); - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveNodeEnum); @@ -101,5 +101,5 @@ if(hydrology_model!=HydrologydcEnum) return; - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -121,10 +121,10 @@ if(hydrology_model!=HydrologydcEnum) return; - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); //create penalties for nodes: no node can have water above the max CreateSingleNodeToElementConnectivity(iomodel); for(int i=0;inumberofvertices;i++){ - if (iomodel->meshxdim!=Mesh3DEnum){ + if (iomodel->domaintype!=Mesh3DEnum){ /*keep only this partition's nodes:*/ if(iomodel->my_vertices[i]){ @@ -155,10 +155,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -168,5 +168,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -260,10 +260,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -273,5 +273,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -392,11 +392,11 @@ void HydrologyDCInefficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim; + int domaintype; bool converged; int* doflist=NULL; Element* basalelement=NULL; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){ + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){ if(!element->IsOnBase()) return; basalelement=element->SpawnBasalElement(); @@ -446,5 +446,5 @@ xDelete(residual); xDelete(doflist); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ void HydrologyDCInefficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ Index: /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.h (revision 17686) @@ -14,5 +14,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int HydrologyShreveAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int HydrologyShreveAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -62,5 +62,5 @@ if(hydrology_model!=HydrologyshreveEnum) return; - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); Index: /issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int L2ProjectionBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int L2ProjectionBaseAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -26,9 +26,9 @@ iomodel->FetchDataToInput(elements,BaseEnum); iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); } - if(iomodel->meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); } @@ -36,8 +36,8 @@ void L2ProjectionBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){ + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum){ iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); } - else if(iomodel->meshxdim==Mesh2DverticalEnum){ + else if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchData(1,MeshVertexonbaseEnum); } @@ -68,10 +68,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -89,5 +89,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -131,10 +131,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -152,5 +152,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -212,9 +212,9 @@ void L2ProjectionBaseAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int inputenum,meshxdim; + int inputenum,domaintype; element->FindParam(&inputenum,InputToL2ProjectEnum); - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,inputenum); @@ -227,5 +227,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum); break; - default: _error_("mesh "<FetchDataToInput(elements,EplHeadEnum); iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); } @@ -51,8 +51,8 @@ if(!isefficientlayer) return; - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchData(1,MeshVertexonbaseEnum); } - else if(iomodel->meshxdim==Mesh2DverticalEnum){ + else if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchData(1,MeshVertexonbaseEnum); } @@ -83,11 +83,11 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; bool active_element; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -101,5 +101,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement; @@ -149,5 +149,5 @@ xDelete(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -155,11 +155,11 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; bool active_element; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -169,5 +169,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement; @@ -222,5 +222,5 @@ xDelete(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -229,9 +229,9 @@ }/*}}}*/ void L2ProjectionEPLAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int inputenum,meshxdim; + int inputenum,domaintype; element->FindParam(&inputenum,InputToL2ProjectEnum); - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,inputenum); @@ -243,5 +243,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum); break; - default: _error_("mesh "<meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,LevelsetAnalysisEnum,finiteelement); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -93,5 +93,5 @@ /*Intermediaries */ - int dim, meshxdim; + int dim, domaintype; int i, row, col; IssmDouble kappa; @@ -103,10 +103,10 @@ /*Get problem dimension*/ - basalelement->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + basalelement->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1; break; case Mesh2DhorizontalEnum: dim = 2; break; case Mesh3DEnum: dim = 2; break; - default: _error_("mesh "<GetInput(VxEnum); _assert_(vx_input); vy_input=basalelement->GetInput(VyEnum); _assert_(vy_input); @@ -253,5 +253,5 @@ xDelete(dlsf); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -262,5 +262,5 @@ /*Intermediaries */ - int i, ig, meshxdim; + int i, ig, domaintype; IssmDouble Jdet,dt; IssmDouble lsf; @@ -298,6 +298,6 @@ xDelete(xyz_list); xDelete(basis); - basalelement->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + basalelement->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete gauss; } @@ -310,7 +310,7 @@ void LevelsetAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum); @@ -319,5 +319,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum); break; - default: _error_("mesh "<meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,LsfReinitializationAnalysisEnum,finiteelement); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -252,15 +252,15 @@ IssmDouble lsf; - int meshxdim,dim,dofpernode; + int domaintype,dim,dofpernode; int* doflist = NULL; /*Get some parameters*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: dim = 2; dofpernode = 1; break; case Mesh2DverticalEnum: dim = 2; dofpernode = 1; break; case Mesh3DEnum: dim = 3; dofpernode = 1; break; case Mesh3DtetrasEnum: dim = 3; dofpernode = 1; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum); @@ -303,5 +303,5 @@ element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum); break; - default: _error_("mesh "<meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); @@ -90,5 +90,5 @@ if(islevelset){ iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes } @@ -132,8 +132,8 @@ /*Check in 3d*/ - if(stabilization==3 && iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet"); + if(stabilization==3 && iomodel->domaintype==Mesh3DEnum) _error_("DG 3d not implemented yet"); /*Create Nodes either DG or CG depending on stabilization*/ - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); if(stabilization!=3){ ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1Enum); @@ -195,5 +195,5 @@ IssmDouble *nodeonbase=NULL; iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); for(int i=0;imeshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ if(!(reCast(nodeonbase[reCast(vertex_pairing[2*i+0])-1])) || !(reCast(nodeonbase[reCast(vertex_pairing[2*i+1])-1]))) continue; } @@ -259,7 +259,7 @@ } - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; }/*}}}*/ @@ -271,5 +271,5 @@ /*Intermediaries */ int stabilization; - int meshxdim,dim; + int domaintype,dim; IssmDouble Jdet,D_scalar,dt,h; IssmDouble vel,vx,vy,dvxdx,dvydy; @@ -278,10 +278,10 @@ /*Get problem dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1; break; case Mesh2DhorizontalEnum: dim = 2; break; case Mesh3DEnum: dim = 2; break; - default: _error_("mesh "<GetVerticesCoordinates(&xyz_list); element->FindParam(&dt,TimesteppingTimeStepEnum); - element->FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); element->FindParam(&stabilization,MasstransportStabilizationEnum); Input* vxaverage_input=NULL; Input* vyaverage_input=NULL; - if(meshxdim==Mesh2DhorizontalEnum){ + if(domaintype==Mesh2DhorizontalEnum){ vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); @@ -415,5 +415,5 @@ /*Intermediaries */ - int meshxdim; + int domaintype; IssmDouble Jdet,D_scalar,dt,vx,vy; IssmDouble* xyz_list = NULL; @@ -432,8 +432,8 @@ element->GetVerticesCoordinates(&xyz_list); element->FindParam(&dt,TimesteppingTimeStepEnum); - element->FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); Input* vxaverage_input=NULL; Input* vyaverage_input=NULL; - if(meshxdim==Mesh2DhorizontalEnum){ + if(domaintype==Mesh2DhorizontalEnum){ vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input); vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input); @@ -505,7 +505,7 @@ } - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ @@ -670,11 +670,11 @@ void MasstransportAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ - int i,hydroadjustment,meshxdim; + int i,hydroadjustment,domaintype; int* doflist=NULL; IssmDouble rho_ice,rho_water,minthickness; Element* basalelement=NULL; - element->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum){ + element->FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum){ if(!element->IsOnBase()) return; basalelement=element->SpawnBasalElement(); @@ -750,5 +750,5 @@ xDelete(phi); xDelete(doflist); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ void MasstransportAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ Index: /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int MeltingAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int MeltingAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -14,5 +14,5 @@ /*Now, is the model 3d? otherwise, do nothing: */ - if(iomodel->meshxdim==Mesh2DhorizontalEnum)return; + if(iomodel->domaintype==Mesh2DhorizontalEnum)return; /*Update elements: */ @@ -44,5 +44,5 @@ void MeltingAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,MeltingAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -54,5 +54,5 @@ /*if 2d: Error*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet"); + if(iomodel->domaintype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet"); //create penalties for nodes: no node can have a temperature over the melting point Index: /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int MeshdeformationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int MeshdeformationAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ _error_("not implemented"); }/*}}}*/ Index: /issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int SmoothedSurfaceSlopeXAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int SmoothedSurfaceSlopeXAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -26,16 +26,16 @@ iomodel->FetchDataToInput(elements,BaseEnum); iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); } - if(iomodel->meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); } }/*}}}*/ void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum); - if(iomodel->meshxdim==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum); }/*}}}*/ void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ @@ -105,10 +105,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -118,5 +118,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ Index: /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int SmoothedSurfaceSlopeYAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int SmoothedSurfaceSlopeYAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -26,16 +26,16 @@ iomodel->FetchDataToInput(elements,BaseEnum); iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); } - if(iomodel->meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); } }/*}}}*/ void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum); ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum); - if(iomodel->meshxdim==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum); }/*}}}*/ void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ @@ -105,10 +105,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -118,5 +118,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<(basis); delete gauss; - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return pe; }/*}}}*/ Index: /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 17686) @@ -10,5 +10,5 @@ /*Model processing*/ -int StressbalanceAnalysis::DofsPerNode(int** pdoftype,int meshxdim,int approximation){/*{{{*/ +int StressbalanceAnalysis::DofsPerNode(int** pdoftype,int domaintype,int approximation){/*{{{*/ /*output*/ @@ -18,5 +18,5 @@ switch(approximation){ case SSAApproximationEnum: - switch(meshxdim){ + switch(domaintype){ case Mesh3DEnum: numdofs=2; break; case Mesh3DtetrasEnum: numdofs=2; break; @@ -28,5 +28,5 @@ case L1L2ApproximationEnum: numdofs =2; break; case HOApproximationEnum: - switch(meshxdim){ + switch(domaintype){ case Mesh3DEnum: numdofs=2; break; case Mesh3DtetrasEnum: numdofs=2; break; @@ -37,5 +37,5 @@ case SIAApproximationEnum: numdofs =2; break; case FSvelocityEnum: - switch(meshxdim){ + switch(domaintype){ case Mesh3DEnum: numdofs=3; break; case Mesh3DtetrasEnum: numdofs=3; break; @@ -46,5 +46,5 @@ case FSpressureEnum: numdofs=1; break; case NoneApproximationEnum: - switch(meshxdim){ + switch(domaintype){ case Mesh3DEnum: numdofs=4; break; case Mesh3DtetrasEnum: numdofs=4; break; @@ -218,5 +218,5 @@ iomodel->FetchDataToInput(elements,DamageDEnum); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ iomodel->FetchDataToInput(elements,MeshElementonbaseEnum); iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); @@ -227,5 +227,5 @@ if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum); } - if(iomodel->meshxdim==Mesh3DtetrasEnum){ + if(iomodel->domaintype==Mesh3DtetrasEnum){ iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); @@ -235,5 +235,5 @@ if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum); } - if(iomodel->meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); } @@ -245,5 +245,5 @@ if(islevelset){ iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes } @@ -299,5 +299,5 @@ } iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum); + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum); ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation); iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, @@ -431,8 +431,8 @@ iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){ + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum){ iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum); } - else if (iomodel->meshxdim==Mesh2DverticalEnum){ + else if (iomodel->domaintype==Mesh2DverticalEnum){ iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvyEnum); } @@ -440,5 +440,5 @@ _error_("not supported yet"); } - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){ + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum){ IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0); IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1); @@ -446,5 +446,5 @@ iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum); } - else if (iomodel->meshxdim==Mesh2DverticalEnum){ + else if (iomodel->domaintype==Mesh2DverticalEnum){ IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0); IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,finiteelement,1); @@ -507,5 +507,5 @@ else{ IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0); - if(iomodel->meshxdim!=Mesh2DverticalEnum){ + if(iomodel->domaintype!=Mesh2DverticalEnum){ IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1); } @@ -520,8 +520,8 @@ iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum); iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum); iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum); iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum); @@ -750,8 +750,8 @@ iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum); iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum); - if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum); + if(iomodel->domaintype==Mesh3DEnum || iomodel->domaintype==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum); iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum); iomodel->DeleteData(surface,SurfaceEnum); @@ -835,5 +835,5 @@ bool isSSA,isL1L2,isHO,isFS; bool conserve_loads = true; - int newton,meshxdim,fe_FS; + int newton,domaintype,fe_FS; /* recover parameters:*/ @@ -843,5 +843,5 @@ femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum); femmodel->parameters->FindParam(&fe_FS,FlowequationFeFSEnum); - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum); @@ -866,5 +866,5 @@ solutionsequence_nonlinear(femmodel,conserve_loads); - if(meshxdim==Mesh2DverticalEnum && isSSA){ + if(domaintype==Mesh2DverticalEnum && isSSA){ femmodel->parameters->SetParam(VxEnum,InputToExtrudeEnum); extrudefrombase_core(femmodel); @@ -989,15 +989,15 @@ IssmDouble vx,vy; - int meshxdim,dim,approximation,dofpernode; + int domaintype,dim,approximation,dofpernode; int* doflist = NULL; /*Get some parameters*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: dim = 2; dofpernode = 2; break; case Mesh2DverticalEnum: dim = 2; dofpernode = 1; break; case Mesh3DEnum: dim = 3; dofpernode = 2; break; case Mesh3DtetrasEnum: dim = 3; dofpernode = 2; break; - default: _error_("mesh "<GetInput(VxEnum); _assert_(vx_input); Input* vy_input=NULL; - if(meshxdim!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);} + if(domaintype!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);} /*Ok, we have vx and vy in values, fill in vx and vy arrays: */ @@ -1083,10 +1083,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -1096,5 +1096,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; return Ke; @@ -1169,10 +1169,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -1182,5 +1182,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete Ke1; delete Ke2; @@ -1202,5 +1202,5 @@ /*Intermediaries*/ - int dim,meshxdim; + int dim,domaintype; bool mainlyfloating; int migration_style,point1; @@ -1211,11 +1211,11 @@ /*Get problem dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1;break; case Mesh2DhorizontalEnum: dim = 2;break; case Mesh3DEnum: dim = 2;break; case Mesh3DtetrasEnum: dim = 2;break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1; bsize = 1; break; case Mesh2DhorizontalEnum: dim = 2; bsize = 3; break; case Mesh3DEnum: dim = 2; bsize = 3; break; case Mesh3DtetrasEnum: dim = 2; bsize = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -1385,5 +1385,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete pe1; delete pe2; @@ -1405,16 +1405,16 @@ /*Intermediaries */ - int dim,meshxdim; + int dim,domaintype; IssmDouble thickness,Jdet,slope[2]; IssmDouble* xyz_list = NULL; /*Get problem dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1;break; case Mesh2DhorizontalEnum: dim = 2;break; case Mesh3DEnum: dim = 2;break; case Mesh3DtetrasEnum: dim = 2;break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 1;break; case Mesh2DhorizontalEnum: dim = 2;break; case Mesh3DEnum: dim = 2;break; case Mesh3DtetrasEnum: dim = 2;break; - default: _error_("mesh "<(numvertices); - element->FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum); g =element->GetMaterialParameter(ConstantsGEnum); - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: element->GetInputListOnVertices(thickness,ThicknessEnum); @@ -1687,5 +1687,5 @@ dim=1; break; - default: _error_("mesh "<AddInput(PressureEnum,pressure,P1Enum); @@ -1695,5 +1695,5 @@ /*Get basal element*/ - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -1703,5 +1703,5 @@ basalelement=element->SpawnBasalElement(); break; - default: _error_("mesh "<(xyz_list); xDelete(doflist); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ @@ -1852,10 +1852,10 @@ /*Intermediaries*/ - int meshxdim; + int domaintype; Element* basalelement; /*Get basal element*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -1865,5 +1865,5 @@ basalelement = element->SpawnBasalElement(); break; - default: _error_("mesh "<DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; delete pe1; delete pe2; @@ -1988,5 +1988,5 @@ void StressbalanceAnalysis::InputUpdateFromSolutionL1L2(IssmDouble* solution,Element* element){/*{{{*/ - int i,meshxdim; + int i,domaintype; IssmDouble rho_ice,g; int* doflist=NULL; @@ -2000,8 +2000,8 @@ IssmDouble* surface = xNew(numvertices); - element->FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum); g =element->GetMaterialParameter(ConstantsGEnum); - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: element->GetInputListOnVertices(thickness,ThicknessEnum); @@ -2013,5 +2013,5 @@ for(i=0;iAddInput(PressureEnum,pressure,P1Enum); @@ -2021,5 +2021,5 @@ /*Get basal element*/ - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: basalelement = element; @@ -2029,5 +2029,5 @@ basalelement=element->SpawnBasalElement(); break; - default: _error_("mesh "<TransformSolutionCoord(&values[0],XYEnum); - basalelement->FindParam(&meshxdim,MeshXDimEnum); + basalelement->FindParam(&domaintype,DomainTypeEnum); /*Ok, we have vx and vy in values, fill in vx and vy arrays: */ @@ -2083,5 +2083,5 @@ xDelete(xyz_list); xDelete(doflist); - if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ @@ -2169,5 +2169,5 @@ /*Intermediaries*/ - int dim,meshxdim,bsize; + int dim,domaintype,bsize; IssmDouble viscosity,newviscosity,oldviscosity; IssmDouble viscosity_overshoot,thickness,Jdet; @@ -2176,10 +2176,10 @@ /*Get problem dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; bsize = 2; break; case Mesh3DEnum: dim = 3; bsize = 5; break; case Mesh3DtetrasEnum: dim = 3; bsize = 5; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); element->FindParam(&r,AugmentedLagrangianREnum); - switch(meshxdim){ + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; epssize = 3; break; case Mesh3DEnum: dim = 3; epssize = 6; break; case Mesh3DtetrasEnum: dim = 3; epssize = 6; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; epssize = 3; break; case Mesh3DEnum: dim = 3; epssize = 6; break; case Mesh3DtetrasEnum: dim = 3; epssize = 6; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2;break; case Mesh3DEnum: dim = 3;break; case Mesh3DtetrasEnum: dim = 3;break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2;break; case Mesh3DEnum: dim = 3;break; case Mesh3DtetrasEnum: dim = 3;break; - default: _error_("mesh "<FindParam(&fe_FS,FlowequationFeFSEnum); - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2;break; case Mesh3DEnum: dim = 3;break; case Mesh3DtetrasEnum: dim = 3;break; - default: _error_("mesh "<GetGroundedPortion(xyz_list_base); if(migration_style==SubelementMigration2Enum){ - if(meshxdim==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline"); + if(domaintype==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline"); gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input); element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating); @@ -3399,15 +3399,15 @@ ElementVector* StressbalanceAnalysis::CreatePVectorFSViscous(Element* element){/*{{{*/ - int i,meshxdim,dim; + int i,domaintype,dim; IssmDouble Jdet,forcex,forcey,forcez; IssmDouble *xyz_list = NULL; /*Get problem dimension*/ - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; tausize = 3; break; case Mesh3DEnum: dim = 3; tausize = 6; break; case Mesh3DtetrasEnum: dim = 3; tausize = 6; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); - switch(meshxdim){ + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); + element->FindParam(&domaintype,DomainTypeEnum); element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); element->FindParam(&results_on_nodes,SettingsResultsOnNodesEnum); - switch(meshxdim){ + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; break; case Mesh3DEnum: dim = 3; break; case Mesh3DtetrasEnum: dim = 3; break; - default: _error_("mesh "<FindParam(&r,AugmentedLagrangianREnum); - parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; tausize = 3; break; case Mesh3DEnum: dim = 3; tausize = 6; break; case Mesh3DtetrasEnum: dim = 3; tausize = 6; break; - default: _error_("mesh "<FindParam(&r,AugmentedLagrangianREnum); - parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: dim = 2; tausize = 3; break; case Mesh3DEnum: dim = 3; tausize = 6; break; case Mesh3DtetrasEnum: dim = 3; tausize = 6; break; - default: _error_("mesh "<FetchDataToInput(elements,IceMaskNodeActivationEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum) + if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes } @@ -64,5 +64,5 @@ int lid=0; iomodel->FetchData(4,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); } @@ -163,12 +163,12 @@ if(!element->IsIceInElement()) return NULL; - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: return CreateKMatrix2D(element); case Mesh3DEnum: return CreateKMatrix3D(element); - default: _error_("mesh "<IsIceInElement()) return NULL; - int meshxdim; - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: return CreatePVector2D(element); case Mesh3DEnum: return CreatePVector3D(element); - default: _error_("mesh "<GetMaterialParameter(MaterialsRhoIceEnum); g = element->GetMaterialParameter(ConstantsGEnum); - element->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: element->GetInputListOnNodes(&thickness[0],ThicknessEnum); @@ -550,5 +550,5 @@ for(i=0;imeshxdim!=Mesh3DEnum) return; + if(iomodel->domaintype!=Mesh3DEnum) return; /*Update elements: */ @@ -43,5 +43,5 @@ /*return if not 3d mesh*/ - if(iomodel->meshxdim!=Mesh3DEnum) return; + if(iomodel->domaintype!=Mesh3DEnum) return; iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum); @@ -59,5 +59,5 @@ /*return if not 3d mesh*/ - if(iomodel->meshxdim!=Mesh3DEnum) return; + if(iomodel->domaintype!=Mesh3DEnum) return; /*Fetch data: */ Index: /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp (revision 17686) @@ -6,5 +6,5 @@ /*Model processing*/ -int ThermalAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/ +int ThermalAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ return 1; }/*}}}*/ @@ -31,5 +31,5 @@ /*Now, is the model 3d? otherwise, do nothing: */ - if(iomodel->meshxdim==Mesh2DhorizontalEnum)return; + if(iomodel->domaintype==Mesh2DhorizontalEnum)return; /*Update elements: */ @@ -83,5 +83,5 @@ void ThermalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); + if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P1Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); @@ -90,5 +90,5 @@ /*Only 3d mesh supported*/ - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P1Enum); } @@ -97,5 +97,5 @@ void ThermalAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet"); + if(iomodel->domaintype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet"); /*create penalties for nodes: no node can have a temperature over the melting point*/ Index: /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.h (revision 17685) +++ /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.h (revision 17686) @@ -13,5 +13,5 @@ public: /*Model processing*/ - int DofsPerNode(int** doflist,int meshxdim,int approximation); + int DofsPerNode(int** doflist,int domaintype,int approximation); void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 17686) @@ -101,7 +101,7 @@ _assert_(this->inputs); - int meshxdim; - parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: this->inputs->AddInput(new TriaInput(input_enum,values,interpolation_enum)); @@ -123,5 +123,5 @@ } break; - default: _error_("mesh "<FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim==Mesh2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <FindParam(&domaintype,DomainTypeEnum); + if(domaintype==Mesh2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <GetInput(PressureEnum); _assert_(pressure_input); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); @@ -218,5 +218,5 @@ IssmDouble tau_yz[NUMVERTICES]={0,0,0}; GaussTria* gauss=NULL; - int meshxdim,dim=2; + int domaintype,dim=2; /* Get node coordinates and dof list: */ @@ -224,6 +224,6 @@ /*Retrieve all inputs we will be needing: */ - this->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim!=Mesh2DhorizontalEnum) _error_("deviatoric stress tensor calculation not implemented for mesh of type " <FindParam(&domaintype,DomainTypeEnum); + if(domaintype!=Mesh2DhorizontalEnum) _error_("deviatoric stress tensor calculation not implemented for mesh of type " <GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -514,5 +514,5 @@ bool mainlyfloating = true; - int meshxdim,index1,index2; + int domaintype,index1,index2; const IssmPDouble epsilon = 1.e-15; IssmDouble phi,s1,s2,area_init,area_grounded; @@ -521,5 +521,5 @@ /*Recover parameters and values*/ - parameters->FindParam(&meshxdim,MeshXDimEnum); + parameters->FindParam(&domaintype,DomainTypeEnum); GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum); @@ -529,5 +529,5 @@ if(gl[2]==0.) gl[2]=gl[2]+epsilon; - if(meshxdim==Mesh2DverticalEnum){ + if(domaintype==Mesh2DverticalEnum){ this->EdgeOnBaseIndices(&index1,&index2); if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded @@ -541,5 +541,5 @@ } - else if(meshxdim==Mesh2DhorizontalEnum || meshxdim==Mesh3DEnum){ + else if(domaintype==Mesh2DhorizontalEnum || domaintype==Mesh3DEnum){ /*Check that not all nodes are grounded or floating*/ if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All grounded @@ -621,5 +621,5 @@ } } - else _error_("mesh type "<1 || phi<0) _error_("Error. Problem with portion of grounded element: value should be between 0 and 1"); @@ -1163,12 +1163,12 @@ bool Tria::IsOnBase(){ - int meshxdim; - this->parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + this->parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: return HasEdgeOnBase(); case Mesh2DhorizontalEnum: return true; - default: _error_("mesh "<parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + this->parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DverticalEnum: return HasEdgeOnSurface(); case Mesh2DhorizontalEnum: return true; - default: _error_("mesh "<parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + + this->parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: return this; @@ -1860,8 +1860,8 @@ int index1,index2; - int meshxdim; - - this->parameters->FindParam(&meshxdim,MeshXDimEnum); - switch(meshxdim){ + int domaintype; + + this->parameters->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ case Mesh2DhorizontalEnum: return this; @@ -2219,7 +2219,7 @@ /*Return: */ - int meshxdim; - parameters->FindParam(&meshxdim,MeshXDimEnum); - if(meshxdim==Mesh2DverticalEnum){ + int domaintype; + parameters->FindParam(&domaintype,DomainTypeEnum); + if(domaintype==Mesh2DverticalEnum){ return base; } @@ -2263,5 +2263,5 @@ IssmDouble Tria::MassFlux( IssmDouble x1, IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){ - int meshxdim; + int domaintype; IssmDouble mass_flux=0.; IssmDouble xyz_list[NUMVERTICES][3]; @@ -2294,8 +2294,8 @@ Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input); - this->parameters->FindParam(&meshxdim,MeshXDimEnum); + this->parameters->FindParam(&domaintype,DomainTypeEnum); Input* vx_input=NULL; Input* vy_input=NULL; - if(meshxdim==Mesh2DhorizontalEnum){ + if(domaintype==Mesh2DhorizontalEnum){ vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -2327,5 +2327,5 @@ IssmDouble Tria::MassFlux( IssmDouble* segment){ - int meshxdim; + int domaintype; IssmDouble mass_flux=0.; IssmDouble xyz_list[NUMVERTICES][3]; @@ -2361,8 +2361,8 @@ Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input); - this->parameters->FindParam(&meshxdim,MeshXDimEnum); + this->parameters->FindParam(&domaintype,DomainTypeEnum); Input* vx_input=NULL; Input* vy_input=NULL; - if(meshxdim==Mesh2DhorizontalEnum){ + if(domaintype==Mesh2DhorizontalEnum){ vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); Index: /issm/trunk-jpl/src/c/classes/IoModel.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/IoModel.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/classes/IoModel.cpp (revision 17686) @@ -30,5 +30,5 @@ this->my_vertices=NULL; - this->meshxdim=-1; + this->domaintype=-1; this->numberofvertices=-1; this->numberofelements=-1; @@ -75,5 +75,5 @@ this->my_vertices = NULL; - FetchData(&this->meshxdim,MeshXDimEnum); + FetchData(&this->domaintype,DomainTypeEnum); FetchData(&this->numberofvertices,MeshNumberofverticesEnum); FetchData(&this->numberofelements,MeshNumberofelementsEnum); Index: /issm/trunk-jpl/src/c/classes/IoModel.h =================================================================== --- /issm/trunk-jpl/src/c/classes/IoModel.h (revision 17685) +++ /issm/trunk-jpl/src/c/classes/IoModel.h (revision 17686) @@ -31,5 +31,5 @@ /*Mesh properties and connectivity tables*/ - int meshxdim; + int domaintype; int numberofvertices; int numberofelements; Index: /issm/trunk-jpl/src/c/classes/Node.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Node.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/classes/Node.cpp (revision 17686) @@ -43,5 +43,5 @@ Analysis* analysis = EnumToAnalysis(analysis_enum); - int numdofs = analysis->DofsPerNode(&doftypes,iomodel->meshxdim,in_approximation); + int numdofs = analysis->DofsPerNode(&doftypes,iomodel->domaintype,in_approximation); indexing.Init(numdofs,doftypes); xDelete(doftypes); @@ -61,5 +61,5 @@ _assert_(sqrt( coord_system[0][0]*coord_system[0][0] + coord_system[1][0]*coord_system[1][0]) >1.e-4); - if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ /*We have a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */ _assert_(iomodel->Data(MeshVertexonbaseEnum)); @@ -101,5 +101,5 @@ analysis_enum==ExtrapolationAnalysisEnum ){ - if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */ _assert_(iomodel->Data(MeshVertexonbaseEnum)); @@ -112,5 +112,5 @@ analysis_enum==FreeSurfaceTopAnalysisEnum ){ - if(iomodel->meshxdim!=Mesh2DhorizontalEnum){ + if(iomodel->domaintype!=Mesh2DhorizontalEnum){ /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */ _assert_(iomodel->Data(MeshVertexonsurfaceEnum)); Index: /issm/trunk-jpl/src/c/classes/Vertex.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Vertex.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/classes/Vertex.cpp (revision 17686) @@ -32,8 +32,8 @@ this->y = iomodel->Data(MeshYEnum)[i]; this->z = iomodel->Data(MeshZEnum)[i]; - this->meshxdim = iomodel->meshxdim; + this->domaintype = iomodel->domaintype; _assert_(iomodel->Data(BaseEnum) && iomodel->Data(ThicknessEnum) && iomodel->numbernodetoelementconnectivity); - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh3DEnum: case Mesh2DhorizontalEnum: @@ -132,5 +132,5 @@ /*sigma remains constant. z=bed+sigma*thickness*/ - switch(this->meshxdim){ + switch(this->domaintype){ case Mesh2DhorizontalEnum: /*Nothing*/ Index: /issm/trunk-jpl/src/c/classes/Vertex.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Vertex.h (revision 17685) +++ /issm/trunk-jpl/src/c/classes/Vertex.h (revision 17686) @@ -21,5 +21,5 @@ public: bool clone; - int meshxdim; + int domaintype; int id; // random index int sid; // "serial" id (rank of this vertex if the dataset was on 1 cpu) Index: /issm/trunk-jpl/src/c/cores/bedslope_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/bedslope_core.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/cores/bedslope_core.cpp (revision 17686) @@ -14,9 +14,9 @@ /*parameters: */ bool save_results; - int meshxdim; + int domaintype; /*Recover some parameters: */ femmodel->parameters->FindParam(&save_results,SaveResultsEnum); - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); if(VerboseSolution()) _printf0_(" computing slope\n"); @@ -28,5 +28,5 @@ solutionsequence_linear(femmodel); - if(meshxdim!=Mesh2DverticalEnum){ + if(domaintype!=Mesh2DverticalEnum){ femmodel->parameters->SetParam(BedSlopeYEnum,InputToL2ProjectEnum); solutionsequence_linear(femmodel); @@ -35,5 +35,5 @@ if(save_results){ if(VerboseSolution()) _printf0_(" saving results\n"); - if(meshxdim!=Mesh2DverticalEnum){ + if(domaintype!=Mesh2DverticalEnum){ int outputs[2] = {BedSlopeXEnum,BedSlopeYEnum}; femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2); Index: /issm/trunk-jpl/src/c/cores/levelsetfunctionslope_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/levelsetfunctionslope_core.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/cores/levelsetfunctionslope_core.cpp (revision 17686) @@ -14,9 +14,9 @@ /*parameters: */ bool save_results; - int meshxdim; + int domaintype; /*Recover some parameters: */ femmodel->parameters->FindParam(&save_results,SaveResultsEnum); - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); if(VerboseSolution()) _printf0_("computing slope of levelset function...\n"); @@ -28,9 +28,9 @@ solutionsequence_linear(femmodel); - if(meshxdim!=Mesh2DverticalEnum){ + if(domaintype!=Mesh2DverticalEnum){ femmodel->parameters->SetParam(LevelsetfunctionSlopeYEnum,InputToL2ProjectEnum); solutionsequence_linear(femmodel); } - if(meshxdim==Mesh2DverticalEnum){ + if(domaintype==Mesh2DverticalEnum){ femmodel->parameters->SetParam(LevelsetfunctionSlopeXEnum,InputToExtrudeEnum); extrudefrombase_core(femmodel); @@ -39,5 +39,5 @@ if(save_results){ if(VerboseSolution()) _printf0_("saving results:\n"); - if(meshxdim!=Mesh2DverticalEnum){ + if(domaintype!=Mesh2DverticalEnum){ int outputs[2] = {LevelsetfunctionSlopeXEnum,LevelsetfunctionSlopeYEnum}; femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2); Index: /issm/trunk-jpl/src/c/cores/masstransport_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/masstransport_core.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/cores/masstransport_core.cpp (revision 17686) @@ -14,5 +14,5 @@ /*parameters: */ int i; - int numoutputs,meshxdim; + int numoutputs,domaintype; bool save_results; bool issmbgradients,ispdd,isdelta18o,isFS,isfreesurface,dakota_analysis; @@ -29,5 +29,5 @@ femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum); femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); femmodel->parameters->FindParam(&numoutputs,MasstransportNumRequestedOutputsEnum); if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,MasstransportRequestedOutputsEnum); @@ -48,5 +48,5 @@ femmodel->SetCurrentConfiguration(FreeSurfaceBaseAnalysisEnum); solutionsequence_linear(femmodel); - if(meshxdim!=Mesh2DhorizontalEnum){ + if(domaintype!=Mesh2DhorizontalEnum){ femmodel->parameters->SetParam(BaseEnum,InputToExtrudeEnum); extrudefrombase_core(femmodel); @@ -54,5 +54,5 @@ femmodel->SetCurrentConfiguration(FreeSurfaceTopAnalysisEnum); solutionsequence_linear(femmodel); - if(meshxdim!=Mesh2DhorizontalEnum){ + if(domaintype!=Mesh2DhorizontalEnum){ femmodel->parameters->SetParam(SurfaceEnum,InputToExtrudeEnum); extrudefromtop_core(femmodel); @@ -62,5 +62,5 @@ if(VerboseSolution()) _printf0_(" call computational core\n"); solutionsequence_linear(femmodel); - if(meshxdim==Mesh2DverticalEnum){ + if(domaintype==Mesh2DverticalEnum){ femmodel->parameters->SetParam(ThicknessEnum,InputToExtrudeEnum); extrudefrombase_core(femmodel); Index: /issm/trunk-jpl/src/c/cores/stressbalance_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/stressbalance_core.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/cores/stressbalance_core.cpp (revision 17686) @@ -15,5 +15,5 @@ /*parameters: */ bool dakota_analysis; - int meshxdim; + int domaintype; bool isSIA,isSSA,isL1L2,isHO,isFS; bool save_results; @@ -24,5 +24,5 @@ /* recover parameters:*/ - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum); femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum); @@ -40,10 +40,10 @@ InputDuplicatex(femmodel,QmuVxEnum,VxEnum); InputDuplicatex(femmodel,QmuVyEnum,VyEnum); - if(meshxdim==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum); + if(domaintype==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum); if(isFS) InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum); } /*Compute slopes if necessary */ - if(isSIA || (isFS && meshxdim==Mesh2DverticalEnum)) surfaceslope_core(femmodel); + if(isSIA || (isFS && domaintype==Mesh2DverticalEnum)) surfaceslope_core(femmodel); if(isFS){ bedslope_core(femmodel); @@ -74,5 +74,5 @@ /*Compute vertical velocities*/ - if (meshxdim==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){ + if (domaintype==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){ analysis = new StressbalanceVerticalAnalysis(); analysis->Core(femmodel); Index: /issm/trunk-jpl/src/c/cores/surfaceslope_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/surfaceslope_core.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/cores/surfaceslope_core.cpp (revision 17686) @@ -14,9 +14,9 @@ /*parameters: */ bool save_results; - int meshxdim; + int domaintype; /*Recover some parameters: */ femmodel->parameters->FindParam(&save_results,SaveResultsEnum); - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); if(VerboseSolution()) _printf0_("computing slope...\n"); @@ -28,9 +28,9 @@ solutionsequence_linear(femmodel); - if(meshxdim!=Mesh2DverticalEnum){ + if(domaintype!=Mesh2DverticalEnum){ femmodel->parameters->SetParam(SurfaceSlopeYEnum,InputToL2ProjectEnum); solutionsequence_linear(femmodel); } - if(meshxdim==Mesh2DverticalEnum){ + if(domaintype==Mesh2DverticalEnum){ femmodel->parameters->SetParam(SurfaceSlopeXEnum,InputToExtrudeEnum); extrudefrombase_core(femmodel); @@ -39,5 +39,5 @@ if(save_results){ if(VerboseSolution()) _printf0_("saving results:\n"); - if(meshxdim!=Mesh2DverticalEnum){ + if(domaintype!=Mesh2DverticalEnum){ int outputs[2] = {SurfaceSlopeXEnum,SurfaceSlopeYEnum}; femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2); Index: /issm/trunk-jpl/src/c/cores/transient_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/transient_core.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/cores/transient_core.cpp (revision 17686) @@ -26,5 +26,5 @@ bool time_adapt=false; int output_frequency; - int meshxdim,groundingline_migration,smb_model; + int domaintype,groundingline_migration,smb_model; int numoutputs = 0; Analysis *analysis = NULL; @@ -37,5 +37,5 @@ //first recover parameters common to all solutions - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum); femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum); @@ -66,5 +66,5 @@ InputDuplicatex(femmodel,QmuVxEnum,VxEnum); InputDuplicatex(femmodel,QmuVyEnum,VyEnum); - if(meshxdim==Mesh3DEnum){ + if(domaintype==Mesh3DEnum){ InputDuplicatex(femmodel,QmuVzEnum,VzEnum); if(isFS)InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum); @@ -78,5 +78,5 @@ } if(isgroundingline) InputDuplicatex(femmodel,QmuMaskGroundediceLevelsetEnum,MaskGroundediceLevelsetEnum); - if(isthermal && meshxdim==Mesh3DEnum){ + if(isthermal && domaintype==Mesh3DEnum){ //Update Vertex Position after updating Thickness and Bed femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum); @@ -114,5 +114,5 @@ femmodel->parameters->SetParam(save_results,SaveResultsEnum); - if(isthermal && meshxdim==Mesh3DEnum){ + if(isthermal && domaintype==Mesh3DEnum){ if(VerboseSolution()) _printf0_(" computing thermal regime\n"); thermal_core(femmodel); Index: /issm/trunk-jpl/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp (revision 17686) @@ -51,5 +51,5 @@ break; case P1bubbleEnum: - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh2DhorizontalEnum: elementnbv = 3; break; case Mesh2DverticalEnum: elementnbv = 3; break; @@ -73,5 +73,5 @@ case P2Enum: EdgesPartitioning(&my_edges,iomodel); - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ FacesPartitioning(&my_faces,iomodel); } @@ -118,5 +118,5 @@ } } - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ for(i=0;inumberoffaces;i++){ if(iomodel->faces[i*6+5]==2){/*Vertical quads*/ Index: /issm/trunk-jpl/src/c/modules/MeshPartitionx/MeshPartitionx.h =================================================================== --- /issm/trunk-jpl/src/c/modules/MeshPartitionx/MeshPartitionx.h (revision 17685) +++ /issm/trunk-jpl/src/c/modules/MeshPartitionx/MeshPartitionx.h (revision 17686) @@ -11,5 +11,5 @@ template int MeshPartitionx(int** pepart, int** pnpart, int numberofelements,int numberofnodes,int* elements, - int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int meshxdim,int num_procs){ + int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int domaintype,int num_procs){ int noerr=1; @@ -31,5 +31,5 @@ int edgecut=1; - switch(meshxdim){ + switch(domaintype){ case Mesh2DhorizontalEnum: case Mesh2DverticalEnum: @@ -111,5 +111,5 @@ break; default: - _error_("mesh type "<meshxdim==Mesh2DhorizontalEnum){ + if(iomodel->domaintype==Mesh2DhorizontalEnum){ elementnbv = 3; elementnbe = 3; @@ -32,5 +32,5 @@ elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1; } - else if(iomodel->meshxdim==Mesh2DverticalEnum){ + else if(iomodel->domaintype==Mesh2DverticalEnum){ elementnbv = 3; elementnbe = 3; @@ -41,5 +41,5 @@ elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1; } - else if(iomodel->meshxdim==Mesh3DtetrasEnum){ + else if(iomodel->domaintype==Mesh3DtetrasEnum){ elementnbv = 4; elementnbe = 6; @@ -53,5 +53,5 @@ elementedges[2*5+0] = 2; elementedges[2*5+1] = 3; elementedges_markers[5] = 1; } - else if(iomodel->meshxdim==Mesh3DEnum){ + else if(iomodel->domaintype==Mesh3DEnum){ elementnbv = 6; elementnbe = 9; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp (revision 17686) @@ -26,5 +26,5 @@ /*Create elements*/ if(control_analysis)iomodel->FetchData(3,InversionControlParametersEnum,InversionMinParametersEnum,InversionMaxParametersEnum); - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh2DhorizontalEnum: for(i=0;inumberofelements;i++){ @@ -59,5 +59,5 @@ iomodel->FetchDataToInput(elements,DamageDEnum); for (i=0;inumberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel)); - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh2DhorizontalEnum: case Mesh2DverticalEnum: elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum); Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateFaces.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateFaces.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateFaces.cpp (revision 17686) @@ -17,8 +17,8 @@ /*Check Iomodel properties*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum || iomodel->meshxdim==Mesh2DverticalEnum){ + if(iomodel->domaintype==Mesh2DhorizontalEnum || iomodel->domaintype==Mesh2DverticalEnum){ /*Keep going*/ } - else if(iomodel->meshxdim==Mesh3DEnum){ + else if(iomodel->domaintype==Mesh3DEnum){ CreateFaces3d(iomodel); return; @@ -144,5 +144,5 @@ /*Mesh specific face indexing per element*/ - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ elementnbv = 6; /*Number of vertices per element*/ elementnbf = 5; /*Number of faces per element*/ @@ -243,5 +243,5 @@ int numbervertices; - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ if((iomodel->faces[6*facenumber+5])==1){ numbervertices=3; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNodes.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNodes.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNodes.cpp (revision 17686) @@ -144,5 +144,5 @@ } id0 = id0+iomodel->numberofvertices+iomodel->numberofedges; - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ FacesPartitioning(&my_faces,iomodel); for(i=0;inumberoffaces;i++){ @@ -309,5 +309,5 @@ } id0 = id0+iomodel->numberofvertices+iomodel->numberofedges; - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ FacesPartitioning(&my_faces,iomodel); for(i=0;inumberoffaces;i++){ @@ -328,5 +328,5 @@ /*P1 pressure*/ - if(iomodel->meshxdim==Mesh3DEnum){ + if(iomodel->domaintype==Mesh3DEnum){ numberoffaces=iomodel->numberoffaces; } Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp (revision 17686) @@ -36,5 +36,5 @@ /*Get element width*/ - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh2DhorizontalEnum: elementswidth=3; break; case Mesh2DverticalEnum: elementswidth=3; break; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 17686) @@ -19,5 +19,5 @@ int i,j,m,k; - int numoutputs,meshxdim,smb_model; + int numoutputs,domaintype,smb_model; char** requestedoutputs = NULL; IssmDouble time; @@ -41,5 +41,5 @@ /*Copy some constants from iomodel */ - parameters->AddObject(iomodel->CopyConstantObject(MeshXDimEnum)); + parameters->AddObject(iomodel->CopyConstantObject(DomainTypeEnum)); parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum)); parameters->AddObject(iomodel->CopyConstantObject(SteadystateReltolEnum)); @@ -84,5 +84,5 @@ parameters->AddObject(iomodel->CopyConstantObject(StressbalanceReltolEnum)); parameters->AddObject(iomodel->CopyConstantObject(StressbalanceAbstolEnum)); - if(iomodel->meshxdim==Mesh3DEnum) + if(iomodel->domaintype==Mesh3DEnum) parameters->AddObject(iomodel->CopyConstantObject(MeshNumberoflayersEnum)); Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp (revision 17686) @@ -30,9 +30,9 @@ /*Get element width (3 or 6)*/ - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh2DhorizontalEnum: elementswidth=3; break; case Mesh2DverticalEnum : elementswidth=3; break; case Mesh3DEnum : elementswidth=6; break; - default: _error_("mesh type "<meshxdim)<<" not supported yet"); + default: _error_("mesh type "<domaintype)<<" not supported yet"); } Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/EdgesPartitioning.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/EdgesPartitioning.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/EdgesPartitioning.cpp (revision 17686) @@ -18,14 +18,14 @@ /*Mesh dependent variables*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum){ + if(iomodel->domaintype==Mesh2DhorizontalEnum){ elementnbe = 3; } - else if(iomodel->meshxdim==Mesh2DverticalEnum){ + else if(iomodel->domaintype==Mesh2DverticalEnum){ elementnbe = 3; } - else if(iomodel->meshxdim==Mesh3DtetrasEnum){ + else if(iomodel->domaintype==Mesh3DtetrasEnum){ elementnbe = 6; } - else if(iomodel->meshxdim==Mesh3DEnum){ + else if(iomodel->domaintype==Mesh3DEnum){ elementnbe = 9; } Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp (revision 17686) @@ -51,5 +51,5 @@ /*Number of vertices per elements, needed to correctly retrieve data: */ /*Determine parallel partitioning of elements: we use Metis for now. First load the data, then partition*/ - switch(iomodel->meshxdim){ + switch(iomodel->domaintype){ case Mesh2DhorizontalEnum: elements_width=3; @@ -81,5 +81,5 @@ } - MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->meshxdim,num_procs); + MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->domaintype,num_procs); /*Free elements2d: */ Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/FacesPartitioning.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/FacesPartitioning.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/FacesPartitioning.cpp (revision 17686) @@ -18,11 +18,11 @@ /*Mesh dependent variables*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum){ + if(iomodel->domaintype==Mesh2DhorizontalEnum){ elementnbf = 3; } - else if(iomodel->meshxdim==Mesh2DverticalEnum){ + else if(iomodel->domaintype==Mesh2DverticalEnum){ elementnbf = 3; } - else if(iomodel->meshxdim==Mesh3DEnum){ + else if(iomodel->domaintype==Mesh3DEnum){ elementnbf = 5; } Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 17686) @@ -59,7 +59,7 @@ /*Hack for trasient runs (FIXME: to be improved)*/ - if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue; - if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue; - if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue; + if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && iomodel->domaintype==Mesh2DhorizontalEnum) continue; + if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && iomodel->domaintype==Mesh2DhorizontalEnum) continue; + if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->domaintype==Mesh2DhorizontalEnum) continue; if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && isthermal==false) continue; if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && isthermal==false) continue; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/NodesPartitioning.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/NodesPartitioning.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/NodesPartitioning.cpp (revision 17686) @@ -65,5 +65,5 @@ /*First: add all the nodes of all the elements belonging to this cpu*/ - if(iomodel->meshxdim==Mesh2DhorizontalEnum){ + if(iomodel->domaintype==Mesh2DhorizontalEnum){ for (i=0;inumberofelements;i++){ if (my_elements[i]){ Index: /issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp (revision 17686) @@ -15,9 +15,9 @@ /* intermediaries */ bool solvein2d=false; - int i,in,meshxdim,analysis_type; + int i,in,domaintype,analysis_type; Elements* elements = femmodel->elements; /* find parameters */ - femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum); + femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); for(i=0;iSize();i++){ @@ -50,5 +50,5 @@ /* if solving 2d problem on vertically extende mesh, solve on basal layer only*/ - if(meshxdim!=Mesh2DhorizontalEnum){ + if(domaintype!=Mesh2DhorizontalEnum){ femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum); if( Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 17685) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 17686) @@ -211,7 +211,7 @@ MeshYEnum, MeshZEnum, - MeshXDimEnum, - MeshDimEnum, - MeshTypeEnum, + DomainTypeEnum, + DomainDimensionEnum, + MeshElementtypeEnum, Mesh2DhorizontalEnum, Mesh2DverticalEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 17686) @@ -219,7 +219,7 @@ case MeshYEnum : return "MeshY"; case MeshZEnum : return "MeshZ"; - case MeshXDimEnum : return "MeshXDim"; - case MeshDimEnum : return "MeshDim"; - case MeshTypeEnum : return "MeshType"; + case DomainTypeEnum : return "DomainType"; + case DomainDimensionEnum : return "DomainDimension"; + case MeshElementtypeEnum : return "MeshElementtype"; case Mesh2DhorizontalEnum : return "Mesh2Dhorizontal"; case Mesh2DverticalEnum : return "Mesh2Dvertical"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 17685) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 17686) @@ -222,7 +222,7 @@ else if (strcmp(name,"MeshY")==0) return MeshYEnum; else if (strcmp(name,"MeshZ")==0) return MeshZEnum; - else if (strcmp(name,"MeshXDim")==0) return MeshXDimEnum; - else if (strcmp(name,"MeshDim")==0) return MeshDimEnum; - else if (strcmp(name,"MeshType")==0) return MeshTypeEnum; + else if (strcmp(name,"DomainType")==0) return DomainTypeEnum; + else if (strcmp(name,"DomainDimension")==0) return DomainDimensionEnum; + else if (strcmp(name,"MeshElementtype")==0) return MeshElementtypeEnum; else if (strcmp(name,"Mesh2Dhorizontal")==0) return Mesh2DhorizontalEnum; else if (strcmp(name,"Mesh2Dvertical")==0) return Mesh2DverticalEnum; Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m (revision 17685) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m (revision 17686) @@ -38,7 +38,7 @@ %First find segments that are not completely on the front -if strcmp(meshtype(md.mesh),'Penta'), +if strcmp(elementtype(md.mesh),'Penta'), numbernodesfront=4; -elseif strcmp(meshtype(md.mesh),'Tria'), +elseif strcmp(elementtype(md.mesh),'Tria'), numbernodesfront=2; else Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 17685) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 17686) @@ -44,7 +44,7 @@ #First find segments that are not completely on the front - if m.strcmp(md.mesh.meshtype(),'Penta'): + if m.strcmp(md.mesh.elementtype(),'Penta'): numbernodesfront=4; - elif m.strcmp(md.mesh.meshtype(),'Tria'): + elif m.strcmp(md.mesh.elementtype(),'Tria'): numbernodesfront=2; else: Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m (revision 17685) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m (revision 17686) @@ -52,5 +52,5 @@ %First find segments that are not completely on the front -if ~strcmp(md.mesh.meshxdim(),'3D'), +if ~strcmp(md.mesh.domaintype(),'3D'), numbernodesfront=2; else Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 17685) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 17686) @@ -53,5 +53,5 @@ #First find segments that are not completely on the front - if not m.strcmp(md.mesh.meshxdim(),'3D'): + if not m.strcmp(md.mesh.domaintype(),'3D'): numbernodesfront=2 else: Index: /issm/trunk-jpl/src/m/classes/flowequation.m =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/flowequation.m (revision 17686) @@ -95,11 +95,11 @@ md = checkfield(md,'fieldname','flowequation.borderHO','size',[md.mesh.numberofvertices 1],'values',[0 1]); md = checkfield(md,'fieldname','flowequation.borderFS','size',[md.mesh.numberofvertices 1],'values',[0 1]); - if strcmp(meshxdim(md.mesh),'2Dhorizontal') + if strcmp(domaintype(md.mesh),'2Dhorizontal') md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[1:2]); md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[1:2]); - elseif strcmp(meshxdim(md.mesh),'2Dvertical') + elseif strcmp(domaintype(md.mesh),'2Dvertical') md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[2:4]); md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[2:4]); - elseif strcmp(meshxdim(md.mesh),'3D'), + elseif strcmp(domaintype(md.mesh),'3D'), md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[0:8]); md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[0:8]); Index: /issm/trunk-jpl/src/m/classes/flowequation.py =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/flowequation.py (revision 17686) @@ -84,8 +84,8 @@ md = checkfield(md,'fieldname','flowequation.XTH_r','numel',[1],'>',0.) md = checkfield(md,'fieldname','flowequation.XTH_theta','numel',[1],'>=',0.,'<',.5) - if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): + if m.strcmp(md.mesh.domaintype(),'2Dhorizontal'): md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',[1,2]) md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements],'values',[1,2]) - elif m.strcmp(md.mesh.meshxdim(),'3D'): + elif m.strcmp(md.mesh.domaintype(),'3D'): md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',numpy.arange(0,8+1)) md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements],'values',numpy.arange(0,8+1)) Index: /issm/trunk-jpl/src/m/classes/initialization.m =================================================================== --- /issm/trunk-jpl/src/m/classes/initialization.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/initialization.m (revision 17686) @@ -52,5 +52,5 @@ md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]); md = checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]); - if meshdim(md.mesh)==3 + if dimension(md.mesh)==3 md = checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices 1]); end Index: /issm/trunk-jpl/src/m/classes/initialization.py =================================================================== --- /issm/trunk-jpl/src/m/classes/initialization.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/initialization.py (revision 17686) @@ -66,5 +66,5 @@ md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices]) md = checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices]) - if md.mesh.meshdim()==3: + if md.mesh.dimension()==3: md = checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices]) md = checkfield(md,'fieldname','initialization.pressure','NaN',1,'size',[md.mesh.numberofvertices]) Index: /issm/trunk-jpl/src/m/classes/mesh2d.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh2d.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/mesh2d.m (revision 17686) @@ -105,5 +105,5 @@ end % }}} function marshall(obj,md,fid) % {{{ - WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer'); + WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Mesh' domaintype(obj)]),'format','Integer'); WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); @@ -114,11 +114,11 @@ WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer'); end % }}} - function t = meshxdim(obj) % {{{ + function t = domaintype(obj) % {{{ t = '2Dhorizontal'; end % }}} - function d = meshdim(obj) % {{{ + function d = dimension(obj) % {{{ d = 2; end % }}} - function s = meshtype(obj) % {{{ + function s = elementtype(obj) % {{{ s = 'Tria'; end % }}} Index: /issm/trunk-jpl/src/m/classes/mesh2d.py =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh2d.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/mesh2d.py (revision 17686) @@ -98,15 +98,15 @@ return md # }}} - def meshxdim(self): # {{{ + def domaintype(self): # {{{ return "2Dhorizontal" #}}} - def meshdim(self): # {{{ + def dimension(self): # {{{ return 2 #}}} - def meshtype(self): # {{{ + def elementtype(self): # {{{ return "Tria" #}}} def marshall(self,md,fid): # {{{ - WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum("Mesh"+self.meshxdim())[0],'format','Integer'); + WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum("Mesh"+self.domaintype())[0],'format','Integer'); WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1) WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1) Index: /issm/trunk-jpl/src/m/classes/mesh2dvertical.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh2dvertical.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/mesh2dvertical.m (revision 17686) @@ -104,5 +104,5 @@ end % }}} function marshall(obj,md,fid) % {{{ - WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer'); + WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Mesh' domaintype(obj)]),'format','Integer'); WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); @@ -115,11 +115,11 @@ WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer'); end % }}} - function t = meshxdim(obj) % {{{ + function t = domaintype(obj) % {{{ t = '2Dvertical'; end % }}} - function d = meshdim(obj) % {{{ + function d = dimension(obj) % {{{ d = 2; end % }}} - function s = meshtype(obj) % {{{ + function s = elementtype(obj) % {{{ s = 'Tria'; end % }}} Index: /issm/trunk-jpl/src/m/classes/mesh3dprisms.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh3dprisms.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/mesh3dprisms.m (revision 17686) @@ -135,5 +135,5 @@ end % }}} function marshall(obj,md,fid) % {{{ - WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer'); + WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Mesh' domaintype(obj)]),'format','Integer'); WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); @@ -154,11 +154,11 @@ WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer'); end % }}} - function type = meshxdim(obj) % {{{ + function type = domaintype(obj) % {{{ type = '3D'; end % }}} - function d = meshdim(obj) % {{{ + function d = dimension(obj) % {{{ d = 3; end % }}} - function s = meshtype(obj) % {{{ + function s = elementtype(obj) % {{{ s = 'Penta'; end % }}} Index: /issm/trunk-jpl/src/m/classes/mesh3dprisms.py =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh3dprisms.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/mesh3dprisms.py (revision 17686) @@ -3,5 +3,5 @@ from EnumDefinitions import * from checkfield import * -from MatlabFuncs import * +import MatlabFuncs as m from WriteData import WriteData @@ -19,5 +19,4 @@ self.z = float('NaN'); self.elements = float('NaN'); - self.dimension = 0; self.numberoflayers = 0; self.numberofelements = 0; @@ -116,5 +115,5 @@ md = checkfield(md,'fieldname','mesh.elements','NaN',1,'>',0,'values',numpy.arange(1,md.mesh.numberofvertices+1)) md = checkfield(md,'fieldname','mesh.elements','size',[md.mesh.numberofelements,6]) - if numpy.any(numpy.logical_not(ismember(numpy.arange(1,md.mesh.numberofvertices+1),md.mesh.elements))): + if numpy.any(numpy.logical_not(m.ismember(numpy.arange(1,md.mesh.numberofvertices+1),md.mesh.elements))): md.checkmessage("orphan nodes have been found. Check the mesh3dprisms outline") md = checkfield(md,'fieldname','mesh.numberoflayers','>=',0) @@ -130,15 +129,15 @@ return md # }}} - def meshxdim(self): # {{{ + def domaintype(self): # {{{ return "3D" #}}} - def meshdim(self): # {{{ + def dimension(self): # {{{ return 3 #}}} - def meshtype(self): # {{{ + def elementtype(self): # {{{ return "Penta" #}}} def marshall(self,md,fid): # {{{ - WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum("Mesh"+self.meshxdim())[0],'format','Integer'); + WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum("Mesh"+self.domaintype())[0],'format','Integer'); WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1) WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1) Index: /issm/trunk-jpl/src/m/classes/mesh3dtetras.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh3dtetras.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/mesh3dtetras.m (revision 17686) @@ -129,5 +129,5 @@ end % }}} function marshall(obj,md,fid) % {{{ - WriteData(fid,'enum',MeshXDimEnum(),'data',Mesh3DtetrasEnum,'format','Integer'); + WriteData(fid,'enum',DomainTypeEnum(),'data',Mesh3DtetrasEnum,'format','Integer'); WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1); WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1); @@ -146,11 +146,11 @@ WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer'); end % }}} - function t = meshxdim(obj) % {{{ + function t = domaintype(obj) % {{{ t = '3D'; end % }}} - function d = meshdim(obj) % {{{ + function d = dimension(obj) % {{{ d = 3; end % }}} - function s = meshtype(obj) % {{{ + function s = elementtype(obj) % {{{ s = 'Tetra'; end % }}} Index: /issm/trunk-jpl/src/m/classes/model.m =================================================================== --- /issm/trunk-jpl/src/m/classes/model.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/model.m (revision 17686) @@ -156,5 +156,5 @@ %Check that the model is really a 3d model - if ~strcmp(md.mesh.meshxdim(),'3D'), + if ~strcmp(md.mesh.domaintype(),'3D'), error('collapse error message: only 3d mesh can be collapsed') end @@ -426,5 +426,5 @@ %Edges - if(meshdim(md.mesh)==2), + if(dimension(md.mesh)==2), if size(md2.mesh.edges,2)>1, %do not use ~isnan because there are some NaNs... %renumber first two columns @@ -608,5 +608,5 @@ error('number of layers should be at least 2'); end - if strcmp(md.mesh.meshxdim(),'3D') + if strcmp(md.mesh.domaintype(),'3D') error('Cannot extrude a 3d mesh (extrude cannot be called more than once)'); end Index: /issm/trunk-jpl/src/m/classes/model.py =================================================================== --- /issm/trunk-jpl/src/m/classes/model.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/model.py (revision 17686) @@ -327,5 +327,5 @@ #Edges - if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): + if m.strcmp(md.mesh.domaintype(),'2Dhorizontal'): 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... #renumber first two columns Index: /issm/trunk-jpl/src/m/classes/modellist.m =================================================================== --- /issm/trunk-jpl/src/m/classes/modellist.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/modellist.m (revision 17686) @@ -32,5 +32,5 @@ %2D or 3D? - if meshdim(md.mesh)==3, + if dimension(md.mesh)==3, numberofelements=md.mesh.numberofelements2d; %this will be forgotten when we get out. flags=project2d(md,flags,1); @@ -84,5 +84,5 @@ for i=1:size(flag_list,1), disp([' ' num2str(i) '/' num2str(size(flag_list,1))]); - if meshdim(md.mesh)==3, + if dimension(md.mesh)==3, flags2d=flag_list{i}; realflags=project3d(md,flags2d,'element'); Index: /issm/trunk-jpl/src/m/classes/rifts.m =================================================================== --- /issm/trunk-jpl/src/m/classes/rifts.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/rifts.m (revision 17686) @@ -28,5 +28,5 @@ end if numrifts, - if ~(strcmp(meshxdim(md.mesh),'2Dhorizontal')), + if ~(strcmp(domaintype(md.mesh),'2Dhorizontal')), md = checkmessage(md,['models with rifts are only supported in 2d for now!']); end Index: /issm/trunk-jpl/src/m/classes/rifts.py =================================================================== --- /issm/trunk-jpl/src/m/classes/rifts.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/rifts.py (revision 17686) @@ -40,5 +40,5 @@ if numrifts: - if not m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): + if not m.strcmp(md.mesh.domaintype(),'2Dhorizontal'): md.checkmessage("models with rifts are only supported in 2d for now!") if not isinstance(self.riftstruct,list): Index: /issm/trunk-jpl/src/m/classes/stressbalance.m =================================================================== --- /issm/trunk-jpl/src/m/classes/stressbalance.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/stressbalance.m (revision 17686) @@ -112,5 +112,5 @@ end %CHECK THAT NO rotation specified for FS Grounded ice at base - if strcmp(meshxdim(md.mesh),'3D') & md.flowequation.isFS, + if strcmp(domaintype(md.mesh),'3D') & md.flowequation.isFS, pos=find(md.mask.groundedice_levelset>0. & md.mesh.vertexonbase); if any(~isnan(md.stressbalance.referential(pos,:))), @@ -122,7 +122,7 @@ function list=defaultoutputs(self,md) % {{{ - if meshdim(md.mesh)==3, + if dimension(md.mesh)==3, list = {'Vx','Vy','Vz','Vel','Pressure'}; - elseif meshdim(md.mesh)==2, + elseif dimension(md.mesh)==2, list = {'Vx','Vy','Vel','Pressure'}; else Index: /issm/trunk-jpl/src/m/classes/stressbalance.py =================================================================== --- /issm/trunk-jpl/src/m/classes/stressbalance.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/stressbalance.py (revision 17686) @@ -110,5 +110,5 @@ def defaultoutputs(self,md): # {{{ - if md.mesh.meshdim()==3: + if md.mesh.dimension()==3: list = ['Vx','Vy','Vz','Vel','Pressure'] else: @@ -125,5 +125,5 @@ md = checkfield(md,'fieldname','stressbalance.spcvx','forcing',1) md = checkfield(md,'fieldname','stressbalance.spcvy','forcing',1) - if m.strcmp(md.mesh.meshxdim(),'3D'): + if m.strcmp(md.mesh.domaintype(),'3D'): md = checkfield(md,'fieldname','stressbalance.spcvz','forcing',1) md = checkfield(md,'fieldname','stressbalance.restol','size',[1],'>',0) @@ -157,5 +157,5 @@ md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal") #CHECK THAT NO rotation specified for FS Grounded ice at base - if m.strcmp(md.mesh.meshxdim(),'3D') and md.flowequation.isFS: + if m.strcmp(md.mesh.domaintype(),'3D') and md.flowequation.isFS: pos=numpy.nonzero(numpy.logical_and(md.mask.groundedice_levelset,md.mesh.vertexonbase)) if numpy.any(numpy.logical_not(numpy.isnan(md.stressbalance.referential[pos,:]))): Index: /issm/trunk-jpl/src/m/classes/thermal.m =================================================================== --- /issm/trunk-jpl/src/m/classes/thermal.m (revision 17685) +++ /issm/trunk-jpl/src/m/classes/thermal.m (revision 17686) @@ -64,5 +64,5 @@ md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0 1 2]); md = checkfield(md,'fieldname','thermal.spctemperature','forcing',1); - if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & meshdim(md.mesh)==3), + if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & dimension(md.mesh)==3), pos=find(md.thermal.spctemperature(1:md.mesh.numberofvertices,:)~=NaN); replicate=repmat(md.geometry.surface-md.mesh.z,1,size(md.thermal.spctemperature,2)); Index: /issm/trunk-jpl/src/m/classes/thermal.py =================================================================== --- /issm/trunk-jpl/src/m/classes/thermal.py (revision 17685) +++ /issm/trunk-jpl/src/m/classes/thermal.py (revision 17686) @@ -82,5 +82,5 @@ md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0,1,2]) md = checkfield(md,'fieldname','thermal.spctemperature','forcing',1) - if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and md.mesh.meshdim()==3: + if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and md.mesh.dimension()==3: pos=numpy.nonzero(numpy.logical_not(numpy.isnan(md.thermal.spctemperature[0:md.mesh.numberofvertices]))) replicate=numpy.tile(md.geometry.surface-md.mesh.z,(1,numpy.size(md.thermal.spctemperature,axis=1))) Index: /issm/trunk-jpl/src/m/contrib/ecco/PropagateFlagsUntilDistance.m =================================================================== --- /issm/trunk-jpl/src/m/contrib/ecco/PropagateFlagsUntilDistance.m (revision 17685) +++ /issm/trunk-jpl/src/m/contrib/ecco/PropagateFlagsUntilDistance.m (revision 17686) @@ -10,5 +10,5 @@ %make 3d work in 2d: -if strcmp(meshxdim(md.mesh),'3D'), +if strcmp(domaintype(md.mesh),'3D'), md.mesh.x=md.mesh.x2d; md.mesh.y=md.mesh.y2d; Index: /issm/trunk-jpl/src/m/contrib/hack/tres.m =================================================================== --- /issm/trunk-jpl/src/m/contrib/hack/tres.m (revision 17685) +++ /issm/trunk-jpl/src/m/contrib/hack/tres.m (revision 17686) @@ -9,5 +9,5 @@ if strcmpi(string,'stressbalance'), - if strcmp(meshxdim(md.mesh),'2Dhorizontal'), + if strcmp(domaintype(md.mesh),'2Dhorizontal'), md.initialization.vx=md.results.StressbalanceSolution.Vx; md.initialization.vy=md.results.StressbalanceSolution.Vy; Index: /issm/trunk-jpl/src/m/contrib/massbalance/divergence.m =================================================================== --- /issm/trunk-jpl/src/m/contrib/massbalance/divergence.m (revision 17685) +++ /issm/trunk-jpl/src/m/contrib/massbalance/divergence.m (revision 17686) @@ -5,5 +5,5 @@ % div=divergence(md,a,b) -if (meshdim(md.mesh)==2), +if (dimension(md.mesh)==2), numberofelements=md.mesh.numberofelements; numberofnodes=md.mesh.numberofvertices; Index: /issm/trunk-jpl/src/m/contrib/massbalance/outflux.m =================================================================== --- /issm/trunk-jpl/src/m/contrib/massbalance/outflux.m (revision 17685) +++ /issm/trunk-jpl/src/m/contrib/massbalance/outflux.m (revision 17686) @@ -16,5 +16,5 @@ if nargin==1, - if meshdim(md.mesh)==3, + if dimension(md.mesh)==3, vxa=DepthAverage(md,md.initialization.vx); vya=DepthAverage(md,md.initialization.vy); @@ -28,5 +28,5 @@ else step=varargin{1}; - if meshdim(md.mesh)==3, + if dimension(md.mesh)==3, vxa=DepthAverage(md,md.results.TransientSolution(step).Vx); vya=DepthAverage(md,md.results.TransientSolution(step).Vy); Index: /issm/trunk-jpl/src/m/enum/DomainDimensionEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/DomainDimensionEnum.m (revision 17686) +++ /issm/trunk-jpl/src/m/enum/DomainDimensionEnum.m (revision 17686) @@ -0,0 +1,11 @@ +function macro=DomainDimensionEnum() +%DOMAINDIMENSIONENUM - Enum of DomainDimension +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=DomainDimensionEnum() + +macro=StringToEnum('DomainDimension'); Index: /issm/trunk-jpl/src/m/enum/DomainTypeEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/DomainTypeEnum.m (revision 17686) +++ /issm/trunk-jpl/src/m/enum/DomainTypeEnum.m (revision 17686) @@ -0,0 +1,11 @@ +function macro=DomainTypeEnum() +%DOMAINTYPEENUM - Enum of DomainType +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=DomainTypeEnum() + +macro=StringToEnum('DomainType'); Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.py =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 17685) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 17686) @@ -211,7 +211,7 @@ def MeshYEnum(): return StringToEnum("MeshY")[0] def MeshZEnum(): return StringToEnum("MeshZ")[0] -def MeshXDimEnum(): return StringToEnum("MeshXDim")[0] -def MeshDimEnum(): return StringToEnum("MeshDim")[0] -def MeshTypeEnum(): return StringToEnum("MeshType")[0] +def DomainTypeEnum(): return StringToEnum("DomainType")[0] +def DomainDimensionEnum(): return StringToEnum("DomainDimension")[0] +def MeshElementtypeEnum(): return StringToEnum("MeshElementtype")[0] def Mesh2DhorizontalEnum(): return StringToEnum("Mesh2Dhorizontal")[0] def Mesh2DverticalEnum(): return StringToEnum("Mesh2Dvertical")[0] Index: sm/trunk-jpl/src/m/enum/MeshDimEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MeshDimEnum.m (revision 17685) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=MeshDimEnum() -%MESHDIMENUM - Enum of MeshDim -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=MeshDimEnum() - -macro=StringToEnum('MeshDim'); Index: /issm/trunk-jpl/src/m/enum/MeshElementtypeEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MeshElementtypeEnum.m (revision 17686) +++ /issm/trunk-jpl/src/m/enum/MeshElementtypeEnum.m (revision 17686) @@ -0,0 +1,11 @@ +function macro=MeshElementtypeEnum() +%MESHELEMENTTYPEENUM - Enum of MeshElementtype +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MeshElementtypeEnum() + +macro=StringToEnum('MeshElementtype'); Index: sm/trunk-jpl/src/m/enum/MeshTypeEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MeshTypeEnum.m (revision 17685) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=MeshTypeEnum() -%MESHTYPEENUM - Enum of MeshType -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=MeshTypeEnum() - -macro=StringToEnum('MeshType'); Index: sm/trunk-jpl/src/m/enum/MeshXDimEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MeshXDimEnum.m (revision 17685) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=MeshXDimEnum() -%MESHXDIMENUM - Enum of MeshXDim -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=MeshXDimEnum() - -macro=StringToEnum('MeshXDim'); Index: /issm/trunk-jpl/src/m/exp/contourlevelzero.m =================================================================== --- /issm/trunk-jpl/src/m/exp/contourlevelzero.m (revision 17685) +++ /issm/trunk-jpl/src/m/exp/contourlevelzero.m (revision 17686) @@ -10,5 +10,5 @@ %process data -if meshdim(md.mesh)==3, +if dimension(md.mesh)==3, error('contourlevelzero error message: routine not supported for 3d meshes, project on a layer'); end Index: /issm/trunk-jpl/src/m/extrusion/DepthAverage.m =================================================================== --- /issm/trunk-jpl/src/m/extrusion/DepthAverage.m (revision 17685) +++ /issm/trunk-jpl/src/m/extrusion/DepthAverage.m (revision 17686) @@ -9,5 +9,5 @@ %check that the model given in input is 3d -if ~strcmp(md.mesh.meshxdim,'3D'); +if ~strcmp(md.mesh.domaintype,'3D'); error('DepthAverage error message: the model given in input must be 3d') end Index: /issm/trunk-jpl/src/m/extrusion/project2d.m =================================================================== --- /issm/trunk-jpl/src/m/extrusion/project2d.m (revision 17685) +++ /issm/trunk-jpl/src/m/extrusion/project2d.m (revision 17686) @@ -20,5 +20,5 @@ end -if ~strcmp(md3d.mesh.meshxdim,'3D'); +if ~strcmp(md3d.mesh.domaintype,'3D'); error('wrong model type ... should be ''3d'''); end Index: /issm/trunk-jpl/src/m/extrusion/project3d.m =================================================================== --- /issm/trunk-jpl/src/m/extrusion/project3d.m (revision 17685) +++ /issm/trunk-jpl/src/m/extrusion/project3d.m (revision 17686) @@ -23,5 +23,5 @@ error('bad usage'); end -if ~strcmp(meshtype(md.mesh),'Penta') +if ~strcmp(elementtype(md.mesh),'Penta') error('input model is not 3d'); end Index: /issm/trunk-jpl/src/m/extrusion/project3d.py =================================================================== --- /issm/trunk-jpl/src/m/extrusion/project3d.py (revision 17685) +++ /issm/trunk-jpl/src/m/extrusion/project3d.py (revision 17686) @@ -27,5 +27,5 @@ if not md: raise TypeError("bad usage") - if not m.strcmp(md.mesh.meshtype(),'Penta'): + if not m.strcmp(md.mesh.elementtype(),'Penta'): raise TypeError("input model is not 3d") Index: /issm/trunk-jpl/src/m/geometry/slope.m =================================================================== --- /issm/trunk-jpl/src/m/geometry/slope.m (revision 17685) +++ /issm/trunk-jpl/src/m/geometry/slope.m (revision 17686) @@ -7,5 +7,5 @@ %load some variables (it is much faster if the variab;es are loaded from md once for all) -if meshdim(md.mesh)==2, +if dimension(md.mesh)==2, numberofelements=md.mesh.numberofelements; numberofnodes=md.mesh.numberofvertices; @@ -30,5 +30,5 @@ s=sqrt(sx.^2+sy.^2); -if meshdim(md.mesh)==3, +if dimension(md.mesh)==3, sx=project3d(md,'vector',sx,'type','element'); sy=project3d(md,'vector',sy,'type','element'); Index: /issm/trunk-jpl/src/m/geometry/slope.py =================================================================== --- /issm/trunk-jpl/src/m/geometry/slope.py (revision 17685) +++ /issm/trunk-jpl/src/m/geometry/slope.py (revision 17686) @@ -12,5 +12,5 @@ #load some variables (it is much faster if the variables are loaded from md once for all) - if md.mesh.meshdim()==2: + if md.mesh.dimension()==2: numberofelements=md.mesh.numberofelements numberofnodes=md.mesh.numberofvertices @@ -39,5 +39,5 @@ s=npy.sqrt(sx**2+sy**2) - if md.mesh.meshdim()==3: + if md.mesh.dimension()==3: sx=project3d(md,'vector',sx,'type','element') sy=project3d(md,'vector',sy,'type','element') Index: /issm/trunk-jpl/src/m/interp/SectionValues.m =================================================================== --- /issm/trunk-jpl/src/m/interp/SectionValues.m (revision 17685) +++ /issm/trunk-jpl/src/m/interp/SectionValues.m (revision 17686) @@ -29,5 +29,5 @@ error('SectionValues error message: wrong resolution type. Resolution must be an array [horizontal_resolution vertical_resolution]') end -if meshdim(md.mesh)==3 +if dimension(md.mesh)==3 if (length(resolution)==2 & isnumeric(resolution(2))) res_v=resolution(2); @@ -78,5 +78,5 @@ %New mesh and Data interpolation -if (meshdim(md.mesh)==2) +if (dimension(md.mesh)==2) %Interpolation of data on specified points Index: /issm/trunk-jpl/src/m/interp/averaging.m =================================================================== --- /issm/trunk-jpl/src/m/interp/averaging.m (revision 17685) +++ /issm/trunk-jpl/src/m/interp/averaging.m (revision 17686) @@ -25,5 +25,5 @@ error('averaging error message: data not supported yet'); end -if meshdim(md.mesh)==3 & nargin==4, +if dimension(md.mesh)==3 & nargin==4, if varargin{1}<=0 | varargin{1}>md.mesh.numberoflayers, error('layer should be between 1 and md.mesh.numberoflayers'); @@ -56,8 +56,8 @@ %build some variables line=index(:); -if meshdim(md.mesh)==3 & layer==0, +if dimension(md.mesh)==3 & layer==0, rep=6; areas=GetAreas(index,md.mesh.x,md.mesh.y,md.mesh.z); -elseif meshdim(md.mesh)==2, +elseif dimension(md.mesh)==2, rep=3; areas=GetAreas(index,md.mesh.x,md.mesh.y); Index: /issm/trunk-jpl/src/m/interp/averaging.py =================================================================== --- /issm/trunk-jpl/src/m/interp/averaging.py (revision 17685) +++ /issm/trunk-jpl/src/m/interp/averaging.py (revision 17686) @@ -28,5 +28,5 @@ if len(data)!=md.mesh.numberofelements and len(data)!=md.mesh.numberofvertices: raise StandardError('averaging error message: data not supported yet') - if md.mesh.meshdim()==3 and layer!=0: + if md.mesh.dimension()==3 and layer!=0: if layer<=0 or layer>md.mesh.numberoflayers: raise ValueError('layer should be between 1 and md.mesh.numberoflayers') @@ -54,8 +54,8 @@ #build some variables - if md.mesh.meshdim()==3 and layer==0: + if md.mesh.dimension()==3 and layer==0: rep=6 areas=GetAreas(index,md.mesh.x,md.mesh.y,md.mesh.z) - elif md.mesh.meshdim()==2: + elif md.mesh.dimension()==2: rep=3 areas=GetAreas(index,md.mesh.x,md.mesh.y) Index: /issm/trunk-jpl/src/m/inversions/velocitymisfit.m =================================================================== --- /issm/trunk-jpl/src/m/inversions/velocitymisfit.m (revision 17685) +++ /issm/trunk-jpl/src/m/inversions/velocitymisfit.m (revision 17686) @@ -9,5 +9,5 @@ % -if meshdim(md.mesh)==2, +if dimension(md.mesh)==2, elements=md.mesh.elements; x=md.mesh.x; Index: /issm/trunk-jpl/src/m/mech/analyticaldamage.m =================================================================== --- /issm/trunk-jpl/src/m/mech/analyticaldamage.m (revision 17685) +++ /issm/trunk-jpl/src/m/mech/analyticaldamage.m (revision 17686) @@ -48,5 +48,5 @@ error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']); end -if meshdim(md.mesh)~=2, +if dimension(md.mesh)~=2, error('only 2d model supported currently'); end Index: /issm/trunk-jpl/src/m/mech/backstressfrominversion.m =================================================================== --- /issm/trunk-jpl/src/m/mech/backstressfrominversion.m (revision 17685) +++ /issm/trunk-jpl/src/m/mech/backstressfrominversion.m (revision 17686) @@ -41,5 +41,5 @@ error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']); end -if meshdim(md.mesh)~=2, +if dimension(md.mesh)~=2, error('only 2d model supported currently'); end Index: /issm/trunk-jpl/src/m/mech/damagefrominversion.m =================================================================== --- /issm/trunk-jpl/src/m/mech/damagefrominversion.m (revision 17685) +++ /issm/trunk-jpl/src/m/mech/damagefrominversion.m (revision 17686) @@ -21,5 +21,5 @@ error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']); end -if meshdim(md.mesh)~=2, +if dimension(md.mesh)~=2, error('only 2d model supported currently'); end Index: /issm/trunk-jpl/src/m/mech/mechanicalproperties.m =================================================================== --- /issm/trunk-jpl/src/m/mech/mechanicalproperties.m (revision 17685) +++ /issm/trunk-jpl/src/m/mech/mechanicalproperties.m (revision 17686) @@ -17,5 +17,5 @@ %error(['the input velocity should be of size ' num2str(md.mesh.numberofvertices) '!']) end -if meshdim(md.mesh)~=2 +if dimension(md.mesh)~=2 error('only 2d model supported yet'); end Index: /issm/trunk-jpl/src/m/mech/strainrateuncert.m =================================================================== --- /issm/trunk-jpl/src/m/mech/strainrateuncert.m (revision 17685) +++ /issm/trunk-jpl/src/m/mech/strainrateuncert.m (revision 17686) @@ -32,5 +32,5 @@ error(['the velocity error dvy should be of size ' num2str(md.mesh.numberofelements) ' or 1!']) end -if meshdim(md.mesh)~=2, +if dimension(md.mesh)~=2, error('only 2d model supported yet'); end Index: /issm/trunk-jpl/src/m/mech/thomasparams.m =================================================================== --- /issm/trunk-jpl/src/m/mech/thomasparams.m (revision 17685) +++ /issm/trunk-jpl/src/m/mech/thomasparams.m (revision 17686) @@ -51,5 +51,5 @@ error(['md.results.strainrate is not present. Calculate using md=mechanicalproperties(md,vx,vy)']) end -if meshdim(md.mesh)~=2, +if dimension(md.mesh)~=2, error('only 2d model supported currently'); end Index: /issm/trunk-jpl/src/m/mesh/bamg.m =================================================================== --- /issm/trunk-jpl/src/m/mesh/bamg.m (revision 17685) +++ /issm/trunk-jpl/src/m/mesh/bamg.m (revision 17686) @@ -284,5 +284,5 @@ %}}} % Bamg Mesh parameters {{{ -if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & strcmp(meshtype(md.mesh),'Tria')), +if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & strcmp(elementtype(md.mesh),'Tria')), if isstruct(md.private.bamg) & isfield(md.private.bamg,'mesh'), Index: /issm/trunk-jpl/src/m/mesh/bamg.py =================================================================== --- /issm/trunk-jpl/src/m/mesh/bamg.py (revision 17685) +++ /issm/trunk-jpl/src/m/mesh/bamg.py (revision 17686) @@ -272,5 +272,5 @@ #}}} # Bamg Mesh parameters {{{ - if not options.exist('domain') and md.mesh.numberofvertices and m.strcmp(md.mesh.meshtype(),'Tria'): + if not options.exist('domain') and md.mesh.numberofvertices and m.strcmp(md.mesh.elementtype(),'Tria'): if isinstance(md.private.bamg,dict) and 'mesh' in md.private.bamg: Index: /issm/trunk-jpl/src/m/miscellaneous/vorticity.m =================================================================== --- /issm/trunk-jpl/src/m/miscellaneous/vorticity.m (revision 17685) +++ /issm/trunk-jpl/src/m/miscellaneous/vorticity.m (revision 17686) @@ -9,5 +9,5 @@ %load some variables (it is much faster if the variab;es are loaded from md once for all) -if ~strcmpi(md.mesh.meshxdim(),'3D'), +if ~strcmpi(md.mesh.domaintype(),'3D'), numberofelements=md.mesh.numberofelements; numberofnodes=md.mesh.numberofvertices; Index: /issm/trunk-jpl/src/m/parameterization/contourenvelope.m =================================================================== --- /issm/trunk-jpl/src/m/parameterization/contourenvelope.m (revision 17685) +++ /issm/trunk-jpl/src/m/parameterization/contourenvelope.m (revision 17686) @@ -42,5 +42,5 @@ %get nodes inside profile mesh.elementconnectivity=md.mesh.elementconnectivity; -if strcmp(md.mesh.meshxdim(),'2Dhorizontal'), +if strcmp(md.mesh.domaintype(),'2Dhorizontal'), mesh.elements=md.mesh.elements; mesh.x=md.mesh.x; Index: /issm/trunk-jpl/src/m/parameterization/contourenvelope.py =================================================================== --- /issm/trunk-jpl/src/m/parameterization/contourenvelope.py (revision 17685) +++ /issm/trunk-jpl/src/m/parameterization/contourenvelope.py (revision 17686) @@ -47,5 +47,5 @@ #get nodes inside profile elementconnectivity=copy.deepcopy(md.mesh.elementconnectivity) - if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): + if m.strcmp(md.mesh.domaintype(),'2Dhorizontal'): elements=copy.deepcopy(md.mesh.elements) x=copy.deepcopy(md.mesh.x) Index: /issm/trunk-jpl/src/m/parameterization/setflowequation.m =================================================================== --- /issm/trunk-jpl/src/m/parameterization/setflowequation.m (revision 17685) +++ /issm/trunk-jpl/src/m/parameterization/setflowequation.m (revision 17686) @@ -71,5 +71,5 @@ %Check that no L1L2 or HO or FS for 2d mesh -if strcmp(meshxdim(md.mesh),'2Dhorizontal') +if strcmp(domaintype(md.mesh),'2Dhorizontal') if any(L1L2flag | FSflag | HOflag) error('FS and HO elements not allowed in 2d mesh, extrude it first') Index: /issm/trunk-jpl/src/m/partition/AreaAverageOntoPartition.m =================================================================== --- /issm/trunk-jpl/src/m/partition/AreaAverageOntoPartition.m (revision 17685) +++ /issm/trunk-jpl/src/m/partition/AreaAverageOntoPartition.m (revision 17686) @@ -9,5 +9,5 @@ %some checks -if meshdim(md.mesh)==3, +if dimension(md.mesh)==3, if nargin~=3, error('layer should be provided onto which Area Averaging occurs'); @@ -51,5 +51,5 @@ %in 3D, restore 3D model: -if meshdim(md.mesh)==3, +if dimension(md.mesh)==3, md=md3d; end Index: /issm/trunk-jpl/src/m/partition/partitioner.m =================================================================== --- /issm/trunk-jpl/src/m/partition/partitioner.m (revision 17685) +++ /issm/trunk-jpl/src/m/partition/partitioner.m (revision 17686) @@ -30,5 +30,5 @@ recomputeadjacency=getfieldvalue(options,'recomputeadjacency'); -if(meshdim(md.mesh)==3), +if(dimension(md.mesh)==3), %partitioning essentially happens in 2D. So partition in 2D, then %extrude the partition vector vertically. @@ -100,5 +100,5 @@ %extrude if we are in 3D: -if meshdim(md.mesh)==3, +if dimension(md.mesh)==3, md3d.qmu.vertex_weight=md.qmu.vertex_weight; md3d.qmu.adjacency=md.qmu.adjacency; Index: /issm/trunk-jpl/src/m/plot/applyoptions.m =================================================================== --- /issm/trunk-jpl/src/m/plot/applyoptions.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/applyoptions.m (revision 17686) @@ -49,5 +49,5 @@ %view -if strcmp(meshxdim(md.mesh),'3D') & ~exist(options,'layer'), +if strcmp(domaintype(md.mesh),'3D') & ~exist(options,'layer'), view(getfieldvalue(options,'view',3)); else @@ -60,5 +60,5 @@ eval(['axis ' getfieldvalue(options,'axis')]); else - if strcmpi(meshxdim(md.mesh),'2Dhorizontal') | exist(options,'layer'), + if strcmpi(domaintype(md.mesh),'2Dhorizontal') | exist(options,'layer'), axis tight equal; else Index: /issm/trunk-jpl/src/m/plot/plot_basaldrag.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_basaldrag.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_basaldrag.m (revision 17686) @@ -9,5 +9,5 @@ %check layer -if meshdim(md.mesh)==3, +if dimension(md.mesh)==3, if getfieldvalue(options,'layer',1)~=1; disp('plot_basaldrag warning: basal drag is displayed in the lower layer') Index: /issm/trunk-jpl/src/m/plot/plot_edges.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_edges.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_edges.m (revision 17686) @@ -17,5 +17,5 @@ end -if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), +if (strcmp(domaintype(md.mesh),'2Dhorizontal')), %plot mesh A=elements(:,1); B=elements(:,2); C=elements(:,3); Index: /issm/trunk-jpl/src/m/plot/plot_icefront.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_icefront.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_icefront.m (revision 17686) @@ -19,5 +19,5 @@ elementzeroice=sum(zeroice(md.mesh.elements),2); -if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), +if (strcmp(domaintype(md.mesh),'2Dhorizontal')), icefront=(elementice & elementnoice) & ~(elementice==2 & elementzeroice); Index: /issm/trunk-jpl/src/m/plot/plot_penalties.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_penalties.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_penalties.m (revision 17686) @@ -21,5 +21,5 @@ end -if ~strcmp(meshxdim(md.mesh),'3D'), +if ~strcmp(domaintype(md.mesh),'3D'), error('no penalties to plot for ''2d'' model'); elseif isempty(md.penalties), Index: /issm/trunk-jpl/src/m/plot/plot_qmu_mass_flux_segments.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_qmu_mass_flux_segments.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_qmu_mass_flux_segments.m (revision 17686) @@ -13,5 +13,5 @@ allsegments=md.qmu.mass_flux_segments; -if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), +if (strcmp(domaintype(md.mesh),'2Dhorizontal')), %recover segments Index: /issm/trunk-jpl/src/m/plot/plot_referential.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_referential.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_referential.m (revision 17686) @@ -28,5 +28,5 @@ Yhat=cross(Zhat,Xhat); -if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), +if (strcmp(domaintype(md.mesh),'2Dhorizontal')), %plot mesh Index: /issm/trunk-jpl/src/m/plot/plot_section.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_section.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_section.m (revision 17686) @@ -203,12 +203,12 @@ %apply options options=addfielddefault(options,'title','Section value'); -if meshdim(md.mesh)==2 +if dimension(md.mesh)==2 options=addfielddefault(options,'colorbar',0); end -if ((meshdim(md.mesh)==2) | getfieldvalue(options,'view')==2 ) +if ((dimension(md.mesh)==2) | getfieldvalue(options,'view')==2 ) options=addfielddefault(options,'xlabel','Curvilinear coordinate'); options=addfielddefault(options,'axis','auto'); end -if (meshdim(md.mesh)==3 & getfieldvalue(options,'view')==2 ) +if (dimension(md.mesh)==3 & getfieldvalue(options,'view')==2 ) options=addfielddefault(options,'ylabel','z'); end Index: /issm/trunk-jpl/src/m/plot/plot_segments.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_segments.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_segments.m (revision 17686) @@ -14,5 +14,5 @@ segments=md.mesh.segments; -if (strcmp(meshxdim(md.mesh),'2Dhorizontal')), +if (strcmp(domaintype(md.mesh),'2Dhorizontal')), %plot mesh A=elements(:,1); B=elements(:,2); C=elements(:,3); Index: /issm/trunk-jpl/src/m/plot/plot_tensor_components.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_tensor_components.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_tensor_components.m (revision 17686) @@ -10,9 +10,9 @@ upperplots=fix((i-1)/width); if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end -if (strcmp(meshxdim(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes +if (strcmp(domaintype(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes index1=4*width*upperplots+2*leftplots+1; index2=index1+1; index3=index1+width*2; -elseif meshdim(md.mesh)==3%6 components -> 6 indexes +elseif dimension(md.mesh)==3%6 components -> 6 indexes index1=3*3*width*upperplots+3*leftplots+1; index2=index1+1; @@ -28,5 +28,5 @@ [tensor.yy datatype]=processdata(md,tensor.yy,options); [tensor.xy datatype]=processdata(md,tensor.xy,options); -if meshdim(md.mesh)==3 +if dimension(md.mesh)==3 [tensor.xz datatype]=processdata(md,tensor.xz,options); [tensor.yz datatype]=processdata(md,tensor.yz,options); @@ -34,5 +34,5 @@ end -if ((strcmp(meshxdim(md.mesh),'2Dhorizontal'))), +if ((strcmp(domaintype(md.mesh),'2Dhorizontal'))), subplot(2*width,2*width,index1), plot_unit(x,y,z,elements,tensor.xx,is2d,isplanet,datatype,options) Index: /issm/trunk-jpl/src/m/plot/plot_tensor_principal.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_tensor_principal.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_tensor_principal.m (revision 17686) @@ -10,5 +10,5 @@ upperplots=fix((i-1)/width); if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end -if (meshdim(md.mesh)==2)%3 components -> 3 indexes +if (dimension(md.mesh)==2)%3 components -> 3 indexes index1=4*width*upperplots+2*leftplots+1; index2=index1+1; @@ -16,5 +16,5 @@ index4=index3+1; newwidth=2*width; -elseif meshdim(md.mesh)==3%6 components -> 6 indexes +elseif dimension(md.mesh)==3%6 components -> 6 indexes index1=3*3*width*upperplots+3*leftplots+1; index2=index1+1; @@ -31,5 +31,5 @@ type2=[type 'axis2']; plot_tensor_principalaxis(md,options,newwidth,index2,tensor,type2,plot_options); -if meshdim(md.mesh)==3 +if dimension(md.mesh)==3 type3=[type 'axis3']; plot_tensor_principalaxis(md,options,newwidth,index3,tensor,type3,plot_options); @@ -40,9 +40,9 @@ [tensor.principalvalue1 datatype]=processdata(md,tensor.principalvalue1,options); [tensor.principalvalue2 datatype]=processdata(md,tensor.principalvalue2,options); -if meshdim(md.mesh)==3 +if dimension(md.mesh)==3 [tensor.principalvalue3 datatype]=processdata(md,tensor.principalvalue3,options); end -if meshdim(md.mesh)==2, +if dimension(md.mesh)==2, subplot(2*width,2*width,index3) plot_unit(x,y,z,elements,tensor.principalvalue1,is2d,isplanet,datatype,options) Index: /issm/trunk-jpl/src/m/plot/plot_tensor_principalaxis.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_tensor_principalaxis.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_tensor_principalaxis.m (revision 17686) @@ -13,5 +13,5 @@ [x y z elements is2d isplanet]=processmesh(md,[],options); -if meshdim(md.mesh)==2, +if dimension(md.mesh)==2, eval(['Vx=tensor.principalaxis' type(end) '(:,1); Vy=tensor.principalaxis' type(end) '(:,2);']) eval(['value=tensor.principalvalue' type(end) ';']); @@ -33,5 +33,5 @@ %plot quivers -if meshdim(md.mesh)==2, +if dimension(md.mesh)==2, %density Index: /issm/trunk-jpl/src/m/plot/plot_transient_results.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_transient_results.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/plot_transient_results.m (revision 17686) @@ -41,5 +41,5 @@ clear string; -if strcmp(meshxdim(md.mesh),'3D'), +if strcmp(domaintype(md.mesh),'3D'), string='plotmodel(md'; for i=1:length(md.results.transient), @@ -67,5 +67,5 @@ clear string; -if strcmp(meshxdim(md.mesh),'3D'), +if strcmp(domaintype(md.mesh),'3D'), string='plotmodel(md'; for i=2:length(md.results.transient), Index: /issm/trunk-jpl/src/m/plot/processdata.m =================================================================== --- /issm/trunk-jpl/src/m/plot/processdata.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/processdata.m (revision 17686) @@ -23,5 +23,5 @@ %special case for mesh 2dvertical -if strcmp(meshxdim(md.mesh),'2Dvertical'), +if strcmp(domaintype(md.mesh),'2Dvertical'), [data datatype] = processdata(md.mesh,md,data,options); return; @@ -56,5 +56,5 @@ %check length -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)) +if datasize(1)~=md.mesh.numberofvertices & datasize(1)~=md.mesh.numberofelements & datasize(1)~=md.mesh.numberofvertices*6 & (strcmp(md.mesh.domaintype(),'3D') & ~(datasize(1)==numberofelements2d | datasize(1)==numberofvertices2d)) error('plotmodel error message: data not supported yet'); end @@ -65,5 +65,5 @@ %check number of columns, add zeros if necessary, - if (strcmp(md.mesh.meshxdim(),'3D')) + if (strcmp(md.mesh.domaintype(),'3D')) if datasize(2)==2, data=[data, zeros(datasize(1),1)]; @@ -85,5 +85,5 @@ %treat the case datasize(1)=nodes2d -if (strcmp(md.mesh.meshxdim(),'3D') & datasize(1)==numberofvertices2d), +if (strcmp(md.mesh.domaintype(),'3D') & datasize(1)==numberofvertices2d), data=project3d(md,'vector',data,'type','node'); datasize(1)=md.mesh.numberofvertices; @@ -92,5 +92,5 @@ %treat the case datasize(1)=nodes2d -if (strcmp(md.mesh.meshxdim(),'3D') & datasize(1)==numberofelements2d), +if (strcmp(md.mesh.domaintype(),'3D') & datasize(1)==numberofelements2d), data=project3d(md,'vector',data,'type','element'); datasize(1)=md.mesh.numberofelements; Index: /issm/trunk-jpl/src/m/plot/processmesh.m =================================================================== --- /issm/trunk-jpl/src/m/plot/processmesh.m (revision 17685) +++ /issm/trunk-jpl/src/m/plot/processmesh.m (revision 17686) @@ -16,5 +16,5 @@ %special case for mesg 2dvertical -if strcmp(meshxdim(md.mesh),'2Dvertical'), +if strcmp(domaintype(md.mesh),'2Dvertical'), [x y z elements is2d isplanet] = processmesh(md.mesh,options); return; @@ -46,5 +46,5 @@ %is it a 2d plot? -if md.mesh.meshdim()==2, +if md.mesh.dimension()==2, is2d=1; else Index: /issm/trunk-jpl/src/m/plot/processmesh.py =================================================================== --- /issm/trunk-jpl/src/m/plot/processmesh.py (revision 17685) +++ /issm/trunk-jpl/src/m/plot/processmesh.py (revision 17686) @@ -42,7 +42,7 @@ #is it a 2D plot? - if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): + if m.strcmp(md.mesh.domaintype(),'2Dhorizontal'): is2d=1 - elif m.strcmp(md.mesh.meshxdim(),'3D'): + elif m.strcmp(md.mesh.domaintype(),'3D'): if options.getfieldvalue('layer',0)>=1: is2d=1 @@ -64,5 +64,5 @@ else: #Process mesh for plotting - if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'): + if m.strcmp(md.mesh.domaintype(),'2Dhorizontal'): is2d=1 else: Index: /issm/trunk-jpl/src/wrappers/MeshPartition/MeshPartition.cpp =================================================================== --- /issm/trunk-jpl/src/wrappers/MeshPartition/MeshPartition.cpp (revision 17685) +++ /issm/trunk-jpl/src/wrappers/MeshPartition/MeshPartition.cpp (revision 17686) @@ -19,5 +19,5 @@ /* required input: */ - int meshxdim; + int domaintype; int numberofelements; int numberofvertices; @@ -50,5 +50,5 @@ if(strcmp(mxGetClassName(MESH),"mesh3d")==0){ - meshxdim = Mesh3DEnum; + domaintype = Mesh3DEnum; FetchData(&numberofelements2d,mxGetAssignedField(MESH,0,"numberofelements2d")); FetchData(&numberofvertices2d,mxGetAssignedField(MESH,0,"numberofvertices2d")); @@ -57,9 +57,9 @@ } else if(strcmp(mxGetClassName(MESH),"mesh2dhorizontal")==0){ - meshxdim = Mesh2DhorizontalEnum; + domaintype = Mesh2DhorizontalEnum; numberoflayers=1; } else if(strcmp(mxGetClassName(MESH),"mesh2dvertical")==0){ - meshxdim = Mesh2DverticalEnum; + domaintype = Mesh2DverticalEnum; numberoflayers=1; } @@ -71,5 +71,5 @@ /*Run partitioning algorithm based on a "clever" use of the Metis partitioner: */ MeshPartitionx(&int_element_partitioning,&int_node_partitioning,numberofelements,numberofvertices,elements, - numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,meshxdim,numareas); + numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,domaintype,numareas); /*Post process node_partitioning and element_partitioning to be in double format. Metis needed them in int* format: */