Changeset 17674


Ignore:
Timestamp:
04/08/14 14:59:42 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: renamed meshtype->meshxdim (Extended Dimension) and added meshdim (2 or 3) and meshtype (Tria Penta Tetra)

Location:
issm/trunk-jpl/src
Files:
2 added
164 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp

    r17585 r17674  
    66
    77/*Model processor*/
    8 int  AdjointBalancethicknessAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  AdjointBalancethicknessAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    4949
    5050        /*Intermediaries*/
    51         int      meshtype;
     51        int      meshxdim;
    5252        Element* basalelement;
    5353
    5454        /*Get basal element*/
    55         element->FindParam(&meshtype,MeshTypeEnum);
    56         switch(meshtype){
     55        element->FindParam(&meshxdim,MeshXDimEnum);
     56        switch(meshxdim){
    5757                case Mesh2DhorizontalEnum:
    5858                        basalelement = element;
    … …  
    6262                        basalelement = element->SpawnBasalElement();
    6363                        break;
    64                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     64                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    6565        }
    6666
    … …  
    143143        xDelete<IssmDouble>(basis);
    144144        xDelete<IssmDouble>(dbasis);
    145         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     145        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    146146        delete gauss;
    147147        return pe;
    … …  
    152152void AdjointBalancethicknessAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    153153
    154         int meshtype;
    155         element->FindParam(&meshtype,MeshTypeEnum);
    156         switch(meshtype){
     154        int meshxdim;
     155        element->FindParam(&meshxdim,MeshXDimEnum);
     156        switch(meshxdim){
    157157                case Mesh2DhorizontalEnum:
    158158                        element->InputUpdateFromSolutionOneDof(solution,AdjointEnum);
    … …  
    161161                        element->InputUpdateFromSolutionOneDofCollapsed(solution,AdjointEnum);
    162162                        break;
    163                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     163                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    164164        }
    165165}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp

    r17609 r17674  
    66
    77/*Model processing*/
    8 int  AdjointHorizAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  AdjointHorizAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        _error_("not implemented");
    1010}/*}}}*/
    … …  
    5555
    5656        /*Intermediaries*/
    57         int      meshtype;
     57        int      meshxdim;
    5858        Element* basalelement;
    5959
    6060        /*Get basal element*/
    61         element->FindParam(&meshtype,MeshTypeEnum);
    62         switch(meshtype){
     61        element->FindParam(&meshxdim,MeshXDimEnum);
     62        switch(meshxdim){
    6363                case Mesh2DhorizontalEnum:
    6464                        basalelement = element;
    … …  
    6868                        basalelement = element->SpawnBasalElement();
    6969                        break;
    70                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     70                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    7171        }
    7272
    … …  
    8787        delete analysis;
    8888        if(incomplete_adjoint){
    89                 if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     89                if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    9090                return Ke;
    9191        }
    … …  
    136136        xDelete<IssmDouble>(dbasis);
    137137        xDelete<IssmDouble>(xyz_list);
    138         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     138        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    139139        return Ke;
    140140}/*}}}*/
    … …  
    304304
    305305        /*Intermediaries */
    306         int        num_responses,i,meshtype,dim;
     306        int        num_responses,i,meshxdim,dim;
    307307        IssmDouble Jdet,obs_velocity_mag,velocity_mag;
    308308        IssmDouble vx,vy,vxobs,vyobs,dux,duy,weight;
    … …  
    312312
    313313        /*Get problem dimension*/
    314         element->FindParam(&meshtype,MeshTypeEnum);
    315         switch(meshtype){
     314        element->FindParam(&meshxdim,MeshXDimEnum);
     315        switch(meshxdim){
    316316                case Mesh2DverticalEnum: dim = 2; break;
    317317                case Mesh3DEnum:         dim = 3; break;
    318                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     318                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    319319        }
    320320
    … …  
    684684
    685685        /*Intermediaries*/
    686         int      meshtype;
     686        int      meshxdim;
    687687        Element* basalelement;
    688688
    689689        /*Get basal element*/
    690         element->FindParam(&meshtype,MeshTypeEnum);
    691         switch(meshtype){
     690        element->FindParam(&meshxdim,MeshXDimEnum);
     691        switch(meshxdim){
    692692                case Mesh2DhorizontalEnum:
    693693                        basalelement = element;
    … …  
    697697                        basalelement = element->SpawnBasalElement();
    698698                        break;
    699                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     699                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    700700        }
    701701
    … …  
    875875        xDelete<IssmDouble>(xyz_list);
    876876        xDelete<IssmDouble>(basis);
    877         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     877        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    878878        delete gauss;
    879879        return pe;

  • issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/Analysis.h

    r17212 r17674  
    2525
    2626                /*Model processing*/
    27                 virtual int  DofsPerNode(int** doflist,int meshtype,int approximation)=0;
     27                virtual int  DofsPerNode(int** doflist,int meshxdim,int approximation)=0;
    2828                virtual void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum)=0;
    2929                virtual void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type)=0;

  • issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  BalancethicknessAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  BalancethicknessAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    4444        iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum);
    4545
    46         if(iomodel->meshtype==Mesh3DEnum){
     46        if(iomodel->meshxdim==Mesh3DEnum){
    4747                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4848                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    5555
    5656        /*Check in 3d*/
    57         if(stabilization==3 && iomodel->meshtype==Mesh3DEnum) _error_("DG 3d not implemented yet");
     57        if(stabilization==3 && iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet");
    5858
    5959        /*First fetch data: */
    60         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     60        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6161        if(stabilization!=3){
    6262                ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);
    … …  
    141141        }
    142142
    143         int meshtype;
    144         element->FindParam(&meshtype,MeshTypeEnum);
    145         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     143        int meshxdim;
     144        element->FindParam(&meshxdim,MeshXDimEnum);
     145        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    146146        return Ke;
    147147}/*}}}*/
    … …  
    150150        /*Intermediaries */
    151151        int        stabilization;
    152         int        meshtype;
     152        int        meshxdim;
    153153        IssmDouble Jdet,D_scalar,h;
    154154        IssmDouble vel,vx,vy,dvxdx,dvydy;
    … …  
    167167        /*Retrieve all inputs and parameters*/
    168168        element->GetVerticesCoordinates(&xyz_list);
    169         element->FindParam(&meshtype,MeshTypeEnum);
     169        element->FindParam(&meshxdim,MeshXDimEnum);
    170170        element->FindParam(&stabilization,BalancethicknessStabilizationEnum);
    171171        Input* vxaverage_input=NULL;
    172172        Input* vyaverage_input=NULL;
    173         if(meshtype==Mesh2DhorizontalEnum){
     173        if(meshxdim==Mesh2DhorizontalEnum){
    174174                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    175175                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    253253
    254254        /*Intermediaries */
    255         int        meshtype;
     255        int        meshxdim;
    256256        IssmDouble Jdet,D_scalar,vx,vy,dvxdx,dvydy,vel;
    257257        IssmDouble dvx[2],dvy[2];
    … …  
    269269        /*Retrieve all inputs and parameters*/
    270270        element->GetVerticesCoordinates(&xyz_list);
    271         element->FindParam(&meshtype,MeshTypeEnum);
     271        element->FindParam(&meshxdim,MeshXDimEnum);
    272272        Input* vxaverage_input=NULL;
    273273        Input* vyaverage_input=NULL;
    274         if(meshtype==Mesh2DhorizontalEnum){
     274        if(meshxdim==Mesh2DhorizontalEnum){
    275275                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    276276                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    333333        }
    334334
    335         int meshtype;
    336         element->FindParam(&meshtype,MeshTypeEnum);
    337         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     335        int meshxdim;
     336        element->FindParam(&meshxdim,MeshXDimEnum);
     337        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    338338        return pe;
    339339}/*}}}*/
    … …  
    480480void BalancethicknessAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    481481
    482         int meshtype;
    483         element->FindParam(&meshtype,MeshTypeEnum);
    484         switch(meshtype){
     482        int meshxdim;
     483        element->FindParam(&meshxdim,MeshXDimEnum);
     484        switch(meshxdim){
    485485                case Mesh2DhorizontalEnum:
    486486                        element->InputUpdateFromSolutionOneDof(solution,ThicknessEnum);
    … …  
    489489                        element->InputUpdateFromSolutionOneDofCollapsed(solution,ThicknessEnum);
    490490                        break;
    491                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     491                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    492492        }
    493493}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/BalancethicknessSoftAnalysis.cpp

    r17212 r17674  
    66
    77/*Model processing*/
    8 int  BalancethicknessSoftAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  BalancethicknessSoftAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        _error_("not implemented");
    1010}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/BalancethicknessSoftAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  BalancevelocityAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  BalancevelocityAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    3333        iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum);
    3434
    35         if(iomodel->meshtype==Mesh3DEnum){
     35        if(iomodel->meshxdim==Mesh3DEnum){
    3636                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3737                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    4141
    4242        /*Check in 3d*/
    43         if(iomodel->meshtype==Mesh3DEnum) _error_("DG 3d not implemented yet");
     43        if(iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet");
    4444
    4545        /*First fetch data: */
    … …  
    148148
    149149        /*Intermediaries*/
    150         int      meshtype;
     150        int      meshxdim;
    151151        Element* basalelement;
    152152
    153153        /*Get basal element*/
    154         element->FindParam(&meshtype,MeshTypeEnum);
    155         switch(meshtype){
     154        element->FindParam(&meshxdim,MeshXDimEnum);
     155        switch(meshxdim){
    156156                case Mesh2DhorizontalEnum:
    157157                        basalelement = element;
    … …  
    161161                        basalelement = element->SpawnBasalElement();
    162162                        break;
    163                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     163                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    164164        }
    165165
    … …  
    235235        xDelete<IssmDouble>(Ny);
    236236        delete gauss;
    237         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     237        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    238238        return pe;
    239239}/*}}}*/
    … …  
    243243void BalancevelocityAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    244244
    245         int meshtype;
    246         element->FindParam(&meshtype,MeshTypeEnum);
    247         switch(meshtype){
     245        int meshxdim;
     246        element->FindParam(&meshxdim,MeshXDimEnum);
     247        switch(meshxdim){
    248248                case Mesh2DhorizontalEnum:
    249249                        element->InputUpdateFromSolutionOneDof(solution,VelEnum);
    … …  
    252252                        element->InputUpdateFromSolutionOneDofCollapsed(solution,VelEnum);
    253253                        break;
    254                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     254                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    255255        }
    256256}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp

    r17646 r17674  
    66
    77/*Model processing*/
    8 int  DamageEvolutionAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  DamageEvolutionAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    6060        iomodel->FetchDataToInput(elements,VxEnum);
    6161        iomodel->FetchDataToInput(elements,VyEnum);
    62         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum);
     62        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum);
    6363        iomodel->FetchDataToInput(elements,DamageDEnum);
    6464        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    … …  
    7373void DamageEvolutionAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    7474
    75         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     75        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    7676        ::CreateNodes(nodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum);
    7777        iomodel->DeleteData(1,MeshVertexonbaseEnum);
    … …  
    109109        /*Intermediaries*/
    110110        Element*    basalelement;
    111         int         meshtype,dim;
     111        int         meshxdim,dim;
    112112        int         stabilization;
    113113        IssmDouble  Jdet,dt,D_scalar,h;
    … …  
    116116
    117117        /*Get problem dimension and basal element*/
    118         element->FindParam(&meshtype,MeshTypeEnum);
    119         switch(meshtype){
     118        element->FindParam(&meshxdim,MeshXDimEnum);
     119        switch(meshxdim){
    120120                case Mesh2DhorizontalEnum:
    121121                        basalelement = element;
    … …  
    127127                        dim = 2;
    128128                        break;
    129                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     129                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    130130        }
    131131
    … …  
    146146        Input* vxaverage_input=NULL;
    147147        Input* vyaverage_input=NULL;
    148         if(meshtype==Mesh2DhorizontalEnum){
     148        if(meshxdim==Mesh2DhorizontalEnum){
    149149                vxaverage_input=basalelement->GetInput(VxEnum); _assert_(vxaverage_input);
    150150                vyaverage_input=basalelement->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    249249        xDelete<IssmDouble>(D);
    250250        delete gauss;
    251         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     251        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    252252        return Ke;
    253253}/*}}}*/
    … …  
    258258
    259259        /*Intermediaries*/
    260         int      meshtype;
     260        int      meshxdim;
    261261        Element* basalelement;
    262262        IssmDouble  Jdet,dt;
    … …  
    265265
    266266        /*Get basal element*/
    267         element->FindParam(&meshtype,MeshTypeEnum);
    268         switch(meshtype){
     267        element->FindParam(&meshxdim,MeshXDimEnum);
     268        switch(meshxdim){
    269269                case Mesh2DhorizontalEnum:
    270270                        basalelement = element;
    … …  
    274274                        basalelement = element->SpawnBasalElement();
    275275                        break;
    276                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     276                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    277277        }
    278278
    … …  
    311311        xDelete<IssmDouble>(xyz_list);
    312312        xDelete<IssmDouble>(basis);
    313         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     313        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    314314        delete gauss;
    315315        return pe;
    … …  
    377377void DamageEvolutionAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    378378
    379         int meshtype;
     379        int meshxdim;
    380380        IssmDouble  max_damage;
    381381        int                     *doflist = NULL;
    382382        Element*   basalelement=NULL;
    383383
    384         element->FindParam(&meshtype,MeshTypeEnum);
    385         if(meshtype!=Mesh2DhorizontalEnum){
     384        element->FindParam(&meshxdim,MeshXDimEnum);
     385        if(meshxdim!=Mesh2DhorizontalEnum){
    386386                if(!element->IsOnBase()) return;
    387387                basalelement=element->SpawnBasalElement();
    … …  
    416416        xDelete<IssmDouble>(newdamage);
    417417        xDelete<int>(doflist);
    418         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     418        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    419419}/*}}}*/
    420420void DamageEvolutionAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/

  • issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.h

    r17391 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  DepthAverageAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  DepthAverageAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2222        }
    2323
    24         if(iomodel->meshtype==Mesh2DverticalEnum){
     24        if(iomodel->meshxdim==Mesh2DverticalEnum){
    2525                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    … …  
    5454
    5555        /*Get dimension*/
    56         int dim,meshtype;
    57         element->FindParam(&meshtype,MeshTypeEnum);
    58         switch(meshtype){
     56        int dim,meshxdim;
     57        element->FindParam(&meshxdim,MeshXDimEnum);
     58        switch(meshxdim){
    5959                case Mesh2DverticalEnum: dim = 2; break;
    6060                case Mesh3DEnum:         dim = 3; break;
    6161                case Mesh3DtetrasEnum:    dim = 3; break;
    62                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     62                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    6363        }
    6464

  • issm/trunk-jpl/src/c/analyses/DepthAverageAnalysis.h

    r17494 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  EnthalpyAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  EnthalpyAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2929
    3030        /*Now, is the model 3d? otherwise, do nothing: */
    31         if(iomodel->meshtype==Mesh2DhorizontalEnum)return;
     31        if(iomodel->meshxdim==Mesh2DhorizontalEnum)return;
    3232
    3333        /*Is enthalpy requested?*/
    … …  
    9494void EnthalpyAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    9595
    96         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     96        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    9797        ::CreateNodes(nodes,iomodel,EnthalpyAnalysisEnum,P1Enum);
    9898        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    117117
    118118        /*return if 2d mesh*/
    119         if(iomodel->meshtype==Mesh2DhorizontalEnum) return;
     119        if(iomodel->meshxdim==Mesh2DhorizontalEnum) return;
    120120
    121121        /*Fetch data: */

  • issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/EnumToAnalysis.h

    r17212 r17674  
    88#endif
    99                /*Model processing*/
    10                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     10                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1111                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1212                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp

    r17610 r17674  
    66#include "../solutionsequences/solutionsequences.h"
    77
    8 int ExtrapolationAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int ExtrapolationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}
    … …  
    3030                }
    3131        }
    32         if(iomodel->meshtype==Mesh3DEnum){
     32        if(iomodel->meshxdim==Mesh3DEnum){
    3333                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3434                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    3838void ExtrapolationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3939        int finiteelement=P1Enum;
    40         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     40        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4141        ::CreateNodes(nodes,iomodel,ExtrapolationAnalysisEnum,finiteelement);
    4242        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    8888
    8989        /*Intermediaries */
    90         int                meshtype,dim;
     90        int                meshxdim,dim;
    9191        int        i,row,col,stabilization;
    9292        bool       extrapolatebydiffusion = true;
    … …  
    9797
    9898        /*Get problem dimension*/
    99         basalelement->FindParam(&meshtype,MeshTypeEnum);
    100         switch(meshtype){
     99        basalelement->FindParam(&meshxdim,MeshXDimEnum);
     100        switch(meshxdim){
    101101                case Mesh2DverticalEnum:   dim = 1; break;
    102102                case Mesh2DhorizontalEnum: dim = 2; break;
    103103                case Mesh3DEnum:           dim = 2; break;
    104                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     104                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    105105        }
    106106
    … …  
    213213        xDelete<IssmDouble>(normal);
    214214        delete gauss;
    215         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     215        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    216216        return Ke;
    217217
    … …  
    223223
    224224        /*Intermediaries */
    225         int i, meshtype;
     225        int i, meshxdim;
    226226       
    227227        /*Fetch number of nodes */
    … …  
    233233                pe->values[i]=0.;
    234234
    235         basalelement->FindParam(&meshtype,MeshTypeEnum);
    236         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     235        basalelement->FindParam(&meshxdim,MeshXDimEnum);
     236        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    237237        return pe;
    238238}/*}}}*/
    … …  
    242242void ExtrapolationAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    243243
    244         int meshtype, extrapolationvariable;
    245         element->FindParam(&meshtype,MeshTypeEnum);
     244        int meshxdim, extrapolationvariable;
     245        element->FindParam(&meshxdim,MeshXDimEnum);
    246246        element->FindParam(&extrapolationvariable, ExtrapolationVariableEnum);
    247         switch(meshtype){
     247        switch(meshxdim){
    248248                case Mesh2DhorizontalEnum:
    249249                        element->InputUpdateFromSolutionOneDof(solution,extrapolationvariable);
    … …  
    252252                        element->InputUpdateFromSolutionOneDofCollapsed(solution,extrapolationvariable);
    253253                        break;
    254                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     254                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    255255        }
    256256}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.h

    r17212 r17674  
    1313 public:
    1414        /*Model processing*/
    15         int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15        int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616        void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717        void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  ExtrudeFromBaseAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  ExtrudeFromBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2222        }
    2323
    24         if(iomodel->meshtype==Mesh2DverticalEnum){
     24        if(iomodel->meshxdim==Mesh2DverticalEnum){
    2525                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    … …  
    6868
    6969        /*Get dimension*/
    70         int dim,meshtype;
    71         element->FindParam(&meshtype,MeshTypeEnum);
    72         switch(meshtype){
     70        int dim,meshxdim;
     71        element->FindParam(&meshxdim,MeshXDimEnum);
     72        switch(meshxdim){
    7373                case Mesh2DverticalEnum: dim = 2; break;
    7474                case Mesh3DEnum:         dim = 3; break;
    75                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     75                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    7676        }
    7777
    … …  
    120120
    121121        /*Get dimension*/
    122         int dim,meshtype;
    123         element->FindParam(&meshtype,MeshTypeEnum);
    124         switch(meshtype){
     122        int dim,meshxdim;
     123        element->FindParam(&meshxdim,MeshXDimEnum);
     124        switch(meshxdim){
    125125                case Mesh2DverticalEnum: dim = 2; break;
    126126                case Mesh3DEnum:         dim = 3; break;
    127                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     127                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    128128        }
    129129
    … …  
    170170
    171171        /*Get dimension*/
    172         int dim,meshtype;
    173         element->FindParam(&meshtype,MeshTypeEnum);
    174         switch(meshtype){
     172        int dim,meshxdim;
     173        element->FindParam(&meshxdim,MeshXDimEnum);
     174        switch(meshxdim){
    175175                case Mesh2DverticalEnum: dim = 2; break;
    176176                case Mesh3DEnum:         dim = 3; break;
    177                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     177                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    178178        }
    179179

  • issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  ExtrudeFromTopAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  ExtrudeFromTopAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2222        }
    2323
    24         if(iomodel->meshtype==Mesh2DverticalEnum){
     24        if(iomodel->meshxdim==Mesh2DverticalEnum){
    2525                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    … …  
    6464
    6565        /*Intermediaries */
    66         int         meshtype,dim;
     66        int         meshxdim,dim;
    6767        IssmDouble  Jdet,D;
    6868        IssmDouble *xyz_list = NULL;
    6969
    7070        /*Get dimension*/
    71         element->FindParam(&meshtype,MeshTypeEnum);
    72         switch(meshtype){
     71        element->FindParam(&meshxdim,MeshXDimEnum);
     72        switch(meshxdim){
    7373                case Mesh2DverticalEnum: dim = 2; break;
    7474                case Mesh3DEnum:         dim = 3; break;
    75                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     75                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    7676        }
    7777
    … …  
    120120
    121121        /*Get dimension*/
    122         int dim,meshtype;
    123         element->FindParam(&meshtype,MeshTypeEnum);
    124         switch(meshtype){
     122        int dim,meshxdim;
     123        element->FindParam(&meshxdim,MeshXDimEnum);
     124        switch(meshxdim){
    125125                case Mesh2DverticalEnum: dim = 2; break;
    126126                case Mesh3DEnum:         dim = 3; break;
    127                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     127                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    128128        }
    129129
    … …  
    170170
    171171        /*Get dimension*/
    172         int dim,meshtype;
    173         element->FindParam(&meshtype,MeshTypeEnum);
    174         switch(meshtype){
     172        int dim,meshxdim;
     173        element->FindParam(&meshxdim,MeshXDimEnum);
     174        switch(meshxdim){
    175175                case Mesh2DverticalEnum: dim = 2; break;
    176176                case Mesh3DEnum:         dim = 3; break;
    177                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     177                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    178178        }
    179179

  • issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  FreeSurfaceBaseAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  FreeSurfaceBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    1414
    1515        /*Now, is the model 3d? otherwise, do nothing: */
    16         if (iomodel->meshtype==Mesh2DhorizontalEnum)return;
     16        if (iomodel->meshxdim==Mesh2DhorizontalEnum)return;
    1717
    1818        /*Finite element type*/
    … …  
    3535        iomodel->FetchDataToInput(elements,VxEnum);
    3636        iomodel->FetchDataToInput(elements,VyEnum);
    37         if(iomodel->meshtype==Mesh3DEnum){
     37        if(iomodel->meshxdim==Mesh3DEnum){
    3838                iomodel->FetchDataToInput(elements,VzEnum);
    3939                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    … …  
    4343void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4444
    45         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     45        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4646        ::CreateNodes(nodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum);
    4747        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    6060        IssmDouble *nodeonbase=NULL;
    6161        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    62         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
     62        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    6363        for(int i=0;i<numvertex_pairing;i++){
    6464
    … …  
    6969
    7070                        /*Skip if one of the two is not on the bed*/
    71                         if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     71                        if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    7272                                if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
    7373                        }
    … …  
    105105
    106106        /*Intermediaries*/
    107         int         meshtype,dim,stabilization;
     107        int         meshxdim,dim,stabilization;
    108108        Element*    basalelement = NULL;
    109109        IssmDouble *xyz_list  = NULL;
    … …  
    112112
    113113        /*Get basal element*/
    114         element->FindParam(&meshtype,MeshTypeEnum);
    115         switch(meshtype){
     114        element->FindParam(&meshxdim,MeshXDimEnum);
     115        switch(meshxdim){
    116116                case Mesh2DhorizontalEnum:
    117117                        basalelement = element;
    … …  
    128128                        dim = 2;
    129129                        break;
    130                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     130                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    131131        }
    132132
    … …  
    223223        xDelete<IssmDouble>(D);
    224224        delete gauss;
    225         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     225        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    226226        return Ke;
    227227}/*}}}*/
    228228ElementVector* FreeSurfaceBaseAnalysis::CreatePVector(Element* element){/*{{{*/
    229229        /*Intermediaries*/
    230         int         meshtype,dim;
     230        int         meshxdim,dim;
    231231        IssmDouble  Jdet,dt;
    232232        IssmDouble  mb,mb_correction,bed,vz;
    … …  
    235235
    236236        /*Get basal element*/
    237         element->FindParam(&meshtype,MeshTypeEnum);
    238         switch(meshtype){
     237        element->FindParam(&meshxdim,MeshXDimEnum);
     238        switch(meshxdim){
    239239                case Mesh2DhorizontalEnum:
    240240                        basalelement = element;
    … …  
    251251                        dim = 2;
    252252                        break;
    253                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     253                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    254254        }
    255255
    … …  
    298298        xDelete<IssmDouble>(basis);
    299299        delete gauss;
    300         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     300        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    301301        return pe;
    302302

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  FreeSurfaceTopAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    1414
    1515        /*Now, is the model 3d? otherwise, do nothing: */
    16         if (iomodel->meshtype==Mesh2DhorizontalEnum)return;
     16        if (iomodel->meshxdim==Mesh2DhorizontalEnum)return;
    1717
    1818        int smb_model;
    … …  
    3535        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    3636        iomodel->FetchDataToInput(elements,VxEnum);
    37         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
    38         if(iomodel->meshtype==Mesh3DEnum){
     37        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
     38        if(iomodel->meshxdim==Mesh3DEnum){
    3939                iomodel->FetchDataToInput(elements,VzEnum);
    4040                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    … …  
    5252void FreeSurfaceTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    5353
    54         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     54        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    5555        ::CreateNodes(nodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum);
    5656        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    6969        IssmDouble *nodeonsurface=NULL;
    7070        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    71         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum);
     71        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum);
    7272        for(int i=0;i<numvertex_pairing;i++){
    7373
    … …  
    7878
    7979                        /*Skip if one of the two is not on the bed*/
    80                         if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     80                        if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    8181                                if(!(reCast<bool>(nodeonsurface[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonsurface[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
    8282                        }
    … …  
    114114
    115115        /*Intermediaries*/
    116         int         meshtype,dim,stabilization;
     116        int         meshxdim,dim,stabilization;
    117117        Element*    topelement = NULL;
    118118        IssmDouble *xyz_list  = NULL;
    … …  
    121121
    122122        /*Get top element*/
    123         element->FindParam(&meshtype,MeshTypeEnum);
    124         switch(meshtype){
     123        element->FindParam(&meshxdim,MeshXDimEnum);
     124        switch(meshxdim){
    125125                case Mesh2DhorizontalEnum:
    126126                        topelement = element;
    … …  
    137137                        dim = 2;
    138138                        break;
    139                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     139                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    140140        }
    141141
    … …  
    232232        xDelete<IssmDouble>(D);
    233233        delete gauss;
    234         if(meshtype!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
     234        if(meshxdim!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
    235235        return Ke;
    236236}/*}}}*/
    237237ElementVector* FreeSurfaceTopAnalysis::CreatePVector(Element* element){/*{{{*/
    238238        /*Intermediaries*/
    239         int         meshtype,dim;
     239        int         meshxdim,dim;
    240240        IssmDouble  Jdet,dt;
    241241        IssmDouble  ms,surface,vz;
    … …  
    244244
    245245        /*Get top element*/
    246         element->FindParam(&meshtype,MeshTypeEnum);
    247         switch(meshtype){
     246        element->FindParam(&meshxdim,MeshXDimEnum);
     247        switch(meshxdim){
    248248                case Mesh2DhorizontalEnum:
    249249                        topelement = element;
    … …  
    260260                        dim = 2;
    261261                        break;
    262                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     262                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    263263        }
    264264
    … …  
    302302        xDelete<IssmDouble>(basis);
    303303        delete gauss;
    304         if(meshtype!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
     304        if(meshxdim!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
    305305        return pe;
    306306

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/GiaAnalysis.cpp

    r17212 r17674  
    66
    77/*Model processing*/
    8 int  GiaAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  GiaAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/GiaAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  HydrologyDCEfficientAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  HydrologyDCEfficientAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    5656        iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum);
    5757        iomodel->FetchDataToInput(elements,HydrologydcEplThicknessEnum);
    58         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
     58        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    5959       
    6060        //      elements->InputDuplicate(HydrologydcEplInitialThicknessEnum,HydrologydcEplThicknessEnum);
    … …  
    7373        if(!isefficientlayer) return;
    7474
    75         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     75        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    7676        ::CreateNodes(nodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum);
    7777        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    111111        /*Intermediaries*/
    112112        bool     active_element;
    113         int      meshtype;
     113        int      meshxdim;
    114114        Element* basalelement;
    115115
    116116        /*Get basal element*/
    117         element->FindParam(&meshtype,MeshTypeEnum);
    118         switch(meshtype){
     117        element->FindParam(&meshxdim,MeshXDimEnum);
     118        switch(meshxdim){
    119119                case Mesh2DhorizontalEnum:
    120120                        basalelement = element;
    … …  
    124124                        basalelement = element->SpawnBasalElement();
    125125                        break;
    126                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     126                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    127127        }
    128128
    … …  
    132132        /*Check that all nodes are active, else return empty matrix*/
    133133        if(!active_element) {
    134         if(meshtype!=Mesh2DhorizontalEnum){
     134        if(meshxdim!=Mesh2DhorizontalEnum){
    135135                        basalelement->DeleteMaterials();
    136136                        delete basalelement;
    … …  
    207207        xDelete<IssmDouble>(B);
    208208        delete gauss;
    209         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     209        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    210210        return Ke;
    211211
    … …  
    215215        /*Intermediaries*/
    216216        bool     active_element;
    217         int      meshtype;
     217        int      meshxdim;
    218218        Element* basalelement;
    219219
    220220        /*Get basal element*/
    221         element->FindParam(&meshtype,MeshTypeEnum);
    222         switch(meshtype){
     221        element->FindParam(&meshxdim,MeshXDimEnum);
     222        switch(meshxdim){
    223223                case Mesh2DhorizontalEnum:
    224224                        basalelement = element;
    … …  
    228228                        basalelement = element->SpawnBasalElement();
    229229                        break;
    230                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     230                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    231231        }
    232232
    … …  
    236236        /*Check that all nodes are active, else return empty matrix*/
    237237        if(!active_element) {
    238         if(meshtype!=Mesh2DhorizontalEnum){
     238        if(meshxdim!=Mesh2DhorizontalEnum){
    239239                        basalelement->DeleteMaterials();
    240240                        delete basalelement;
    … …  
    309309        xDelete<IssmDouble>(basis);
    310310        delete gauss;
    311         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     311        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    312312        return pe;
    313313}/*}}}*/
    … …  
    317317void HydrologyDCEfficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    318318
    319         int meshtype,i;
     319        int meshxdim,i;
    320320        Element*   basalelement=NULL;
    321321
    322         element->FindParam(&meshtype,MeshTypeEnum);
    323 
    324         if(meshtype!=Mesh2DhorizontalEnum){
     322        element->FindParam(&meshxdim,MeshXDimEnum);
     323
     324        if(meshxdim!=Mesh2DhorizontalEnum){
    325325                if(!element->IsOnBase()) return;
    326326                basalelement=element->SpawnBasalElement();
    … …  
    351351        xDelete<IssmDouble>(eplHeads);
    352352        xDelete<int>(doflist);
    353         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     353        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    354354} /*}}}*/
    355355void HydrologyDCEfficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
    … …  
    481481
    482482        bool        active_element;
    483         int         meshtype;
     483        int         meshxdim;
    484484        IssmDouble  dt,A,B;
    485485        IssmDouble  EPLgrad2;
    486486        IssmDouble  EPL_N;
    487487
    488         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     488        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    489489
    490490        for(int j=0;j<femmodel->elements->Size();j++){
    … …  
    492492                Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
    493493               
    494                 switch(meshtype){
     494                switch(meshxdim){
    495495                case Mesh2DhorizontalEnum:
    496496                        if(!element->IsOnBase()) return;                       
    … …  
    602602        bool        active_element;
    603603        int         i,j;
    604         int         meshtype;
     604        int         meshxdim;
    605605        IssmDouble  h_max;
    606606        IssmDouble  sedheadmin;
    … …  
    608608
    609609        /*Get basal element*/
    610         element->FindParam(&meshtype,MeshTypeEnum);
    611         switch(meshtype){
     610        element->FindParam(&meshxdim,MeshXDimEnum);
     611        switch(meshxdim){
    612612                case Mesh2DhorizontalEnum:
    613613                        basalelement = element;
    … …  
    617617                        basalelement = element->SpawnBasalElement();
    618618                        break;
    619                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     619                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    620620        }
    621621
    … …  
    673673                }
    674674        }
    675         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     675        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    676676        xDelete<IssmDouble>(epl_thickness);
    677677        xDelete<IssmDouble>(old_active);
    … …  
    684684        /*Constants*/
    685685
    686         int      meshtype;
     686        int      meshxdim;
    687687        Element*   basalelement=NULL;
    688688
    689689        /*Get basal element*/
    690         element->FindParam(&meshtype,MeshTypeEnum);
    691         switch(meshtype){
     690        element->FindParam(&meshxdim,MeshXDimEnum);
     691        switch(meshxdim){
    692692                case Mesh2DhorizontalEnum:
    693693                        basalelement = element;
    … …  
    697697                        basalelement = element->SpawnBasalElement();
    698698                        break;
    699                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     699                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    700700        }
    701701       
    … …  
    716716                /*Do not do anything: at least one node is active for this element but this element is not solved for*/
    717717        }
    718         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     718        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    719719        xDelete<IssmDouble>(active);
    720720}

  • issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.h

    r17375 r17674  
    1414        public:
    1515                /*Model processing*/
    16                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     16                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1717                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1818                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp

    r17610 r17674  
    77
    88/*Model processing*/
    9 int  HydrologyDCInefficientAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     9int  HydrologyDCInefficientAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    1010        return 1;
    1111}/*}}}*/
    … …  
    8888        iomodel->FetchDataToInput(elements,SedimentHeadEnum);
    8989        iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum);
    90         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
     90        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    9191
    9292        if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveNodeEnum);
    … …  
    101101        if(hydrology_model!=HydrologydcEnum) return;
    102102
    103         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     103        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    104104        ::CreateNodes(nodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum);
    105105        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    121121        if(hydrology_model!=HydrologydcEnum) return;
    122122
    123         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     123        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    124124
    125125        //create penalties for nodes: no node can have water above the max
    126126        CreateSingleNodeToElementConnectivity(iomodel);
    127127        for(int i=0;i<iomodel->numberofvertices;i++){
    128                 if (iomodel->meshtype!=Mesh3DEnum){
     128                if (iomodel->meshxdim!=Mesh3DEnum){
    129129                        /*keep only this partition's nodes:*/
    130130                        if(iomodel->my_vertices[i]){
    … …  
    155155
    156156        /*Intermediaries*/
    157         int      meshtype;
     157        int      meshxdim;
    158158        Element* basalelement;
    159159
    160160        /*Get basal element*/
    161         element->FindParam(&meshtype,MeshTypeEnum);
    162         switch(meshtype){
     161        element->FindParam(&meshxdim,MeshXDimEnum);
     162        switch(meshxdim){
    163163                case Mesh2DhorizontalEnum:
    164164                        basalelement = element;
    … …  
    168168                        basalelement = element->SpawnBasalElement();
    169169                        break;
    170                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     170                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    171171        }
    172172
    … …  
    254254        xDelete<IssmDouble>(basis);
    255255        delete gauss;
    256         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     256        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    257257        return Ke;
    258258}/*}}}*/
    … …  
    260260
    261261        /*Intermediaries*/
    262         int      meshtype;
     262        int      meshxdim;
    263263        Element* basalelement;
    264264
    265265        /*Get basal element*/
    266         element->FindParam(&meshtype,MeshTypeEnum);
    267         switch(meshtype){
     266        element->FindParam(&meshxdim,MeshXDimEnum);
     267        switch(meshxdim){
    268268                case Mesh2DhorizontalEnum:
    269269                        basalelement = element;
    … …  
    273273                        basalelement = element->SpawnBasalElement();
    274274                        break;
    275                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     275                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    276276        }
    277277
    … …  
    357357        xDelete<IssmDouble>(basis);
    358358        delete gauss;
    359         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     359        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    360360        return pe;
    361361}/*}}}*/
    … …  
    392392void HydrologyDCInefficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    393393
    394         int        meshtype;
     394        int        meshxdim;
    395395        bool       converged;
    396396        int*       doflist=NULL;
    397397        Element*   basalelement=NULL;
    398398
    399         element->FindParam(&meshtype,MeshTypeEnum);
    400         if(meshtype!=Mesh2DhorizontalEnum){
     399        element->FindParam(&meshxdim,MeshXDimEnum);
     400        if(meshxdim!=Mesh2DhorizontalEnum){
    401401                if(!element->IsOnBase()) return;
    402402                basalelement=element->SpawnBasalElement();
    … …  
    446446        xDelete<IssmDouble>(residual);
    447447        xDelete<int>(doflist);
    448         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     448        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    449449}/*}}}*/
    450450void HydrologyDCInefficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/

  • issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.h

    r17555 r17674  
    1414        public:
    1515                /*Model processing*/
    16                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     16                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1717                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1818                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  HydrologyShreveAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  HydrologyShreveAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    6262        if(hydrology_model!=HydrologyshreveEnum) return;
    6363
    64         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     64        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6565        ::CreateNodes(nodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
    6666        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);

  • issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  L2ProjectionBaseAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  L2ProjectionBaseAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2626        iomodel->FetchDataToInput(elements,BaseEnum);
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    28         if(iomodel->meshtype==Mesh3DEnum){
     28        if(iomodel->meshxdim==Mesh3DEnum){
    2929                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    32         if(iomodel->meshtype==Mesh2DverticalEnum){
     32        if(iomodel->meshxdim==Mesh2DverticalEnum){
    3333                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    … …  
    3636void L2ProjectionBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737
    38         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
     38        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){
    3939                iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4040        }
    41         else if(iomodel->meshtype==Mesh2DverticalEnum){
     41        else if(iomodel->meshxdim==Mesh2DverticalEnum){
    4242                iomodel->FetchData(1,MeshVertexonbaseEnum);
    4343        }
    … …  
    6868
    6969        /*Intermediaries*/
    70         int      meshtype;
     70        int      meshxdim;
    7171        Element* basalelement;
    7272
    7373        /*Get basal element*/
    74         element->FindParam(&meshtype,MeshTypeEnum);
    75         switch(meshtype){
     74        element->FindParam(&meshxdim,MeshXDimEnum);
     75        switch(meshxdim){
    7676                case Mesh2DhorizontalEnum:
    7777                        basalelement = element;
    … …  
    8989                        basalelement = element->SpawnBasalElement();
    9090                        break;
    91                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     91                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    9292        }
    9393
    … …  
    125125        xDelete<IssmDouble>(basis);
    126126        delete gauss;
    127         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     127        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    128128        return Ke;
    129129}/*}}}*/
    … …  
    131131
    132132        /*Intermediaries*/
    133         int      meshtype;
     133        int      meshxdim;
    134134        Element* basalelement;
    135135
    136136        /*Get basal element*/
    137         element->FindParam(&meshtype,MeshTypeEnum);
    138         switch(meshtype){
     137        element->FindParam(&meshxdim,MeshXDimEnum);
     138        switch(meshxdim){
    139139                case Mesh2DhorizontalEnum:
    140140                        basalelement = element;
    … …  
    152152                        basalelement = element->SpawnBasalElement();
    153153                        break;
    154                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     154                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    155155        }
    156156
    … …  
    204204        xDelete<IssmDouble>(basis);
    205205        delete gauss;
    206         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     206        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    207207        return pe;
    208208}/*}}}*/
    … …  
    212212void L2ProjectionBaseAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    213213
    214         int inputenum,meshtype;
     214        int inputenum,meshxdim;
    215215
    216216        element->FindParam(&inputenum,InputToL2ProjectEnum);
    217         element->FindParam(&meshtype,MeshTypeEnum);
    218         switch(meshtype){
     217        element->FindParam(&meshxdim,MeshXDimEnum);
     218        switch(meshxdim){
    219219                case Mesh2DhorizontalEnum:
    220220                        element->InputUpdateFromSolutionOneDof(solution,inputenum);
    … …  
    227227                        element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum);
    228228                        break;
    229                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     229                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    230230        }
    231231}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  L2ProjectionEPLAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  L2ProjectionEPLAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    3636        iomodel->FetchDataToInput(elements,EplHeadEnum);
    3737        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    38         if(iomodel->meshtype==Mesh3DEnum){
     38        if(iomodel->meshxdim==Mesh3DEnum){
    3939                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4040        }
    … …  
    5151        if(!isefficientlayer) return;
    5252
    53         if(iomodel->meshtype==Mesh3DEnum){
     53        if(iomodel->meshxdim==Mesh3DEnum){
    5454                iomodel->FetchData(1,MeshVertexonbaseEnum);
    5555        }
    56         else if(iomodel->meshtype==Mesh2DverticalEnum){
     56        else if(iomodel->meshxdim==Mesh2DverticalEnum){
    5757                iomodel->FetchData(1,MeshVertexonbaseEnum);
    5858        }
    … …  
    8383
    8484        /*Intermediaries*/
    85         int      meshtype;
     85        int      meshxdim;
    8686        bool     active_element;
    8787        Element* basalelement;
    8888
    8989        /*Get basal element*/
    90         element->FindParam(&meshtype,MeshTypeEnum);
    91         switch(meshtype){
     90        element->FindParam(&meshxdim,MeshXDimEnum);
     91        switch(meshxdim){
    9292                case Mesh2DhorizontalEnum:
    9393                        basalelement = element;
    … …  
    101101                        basalelement = element->SpawnBasalElement();
    102102                        break;
    103                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     103                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    104104        }
    105105
    … …  
    109109        /* Check that all nodes are active, else return empty matrix */
    110110        if(!active_element){
    111                 if(meshtype!=Mesh2DhorizontalEnum){
     111                if(meshxdim!=Mesh2DhorizontalEnum){
    112112                        basalelement->DeleteMaterials();
    113113                        delete basalelement;
    … …  
    149149        xDelete<IssmDouble>(basis);
    150150        delete gauss;
    151         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     151        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    152152        return Ke;
    153153}/*}}}*/
    … …  
    155155
    156156        /*Intermediaries*/
    157         int      meshtype;
     157        int      meshxdim;
    158158        bool     active_element;
    159159        Element* basalelement;
    160160
    161161        /*Get basal element*/
    162         element->FindParam(&meshtype,MeshTypeEnum);
    163         switch(meshtype){
     162        element->FindParam(&meshxdim,MeshXDimEnum);
     163        switch(meshxdim){
    164164                case Mesh2DhorizontalEnum:
    165165                        basalelement = element;
    … …  
    169169                        basalelement = element->SpawnBasalElement();
    170170                        break;
    171                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     171                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    172172        }
    173173
    … …  
    177177        /*Check that all nodes are active, else return empty matrix*/
    178178        if(!active_element) {
    179                 if(meshtype!=Mesh2DhorizontalEnum){
     179                if(meshxdim!=Mesh2DhorizontalEnum){
    180180                        basalelement->DeleteMaterials();
    181181                        delete basalelement;
    … …  
    222222        xDelete<IssmDouble>(basis);
    223223        delete gauss;
    224         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     224        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    225225        return pe;
    226226}/*}}}*/
    … …  
    229229}/*}}}*/
    230230void L2ProjectionEPLAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    231         int inputenum,meshtype;
     231        int inputenum,meshxdim;
    232232
    233233        element->FindParam(&inputenum,InputToL2ProjectEnum);
    234         element->FindParam(&meshtype,MeshTypeEnum);
    235         switch(meshtype){
     234        element->FindParam(&meshxdim,MeshXDimEnum);
     235        switch(meshxdim){
    236236                case Mesh2DhorizontalEnum:
    237237                        element->InputUpdateFromSolutionOneDof(solution,inputenum);
    … …  
    243243                        element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum);
    244244                        break;
    245                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     245                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    246246        }
    247247}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp

    r17626 r17674  
    1111#include "../solutionsequences/solutionsequences.h"
    1212
    13 int LevelsetAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     13int LevelsetAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    1414        return 1;
    1515}
    … …  
    4343void LevelsetAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4444        int finiteelement=P1Enum;
    45         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     45        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4646        ::CreateNodes(nodes,iomodel,LevelsetAnalysisEnum,finiteelement);
    4747        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    9393
    9494        /*Intermediaries */
    95         int  dim, meshtype;
     95        int  dim, meshxdim;
    9696        int i, row, col;
    9797        IssmDouble kappa;
    … …  
    103103
    104104        /*Get problem dimension*/
    105         basalelement->FindParam(&meshtype,MeshTypeEnum);
    106         switch(meshtype){
     105        basalelement->FindParam(&meshxdim,MeshXDimEnum);
     106        switch(meshxdim){
    107107                case Mesh2DverticalEnum:   dim = 1; break;
    108108                case Mesh2DhorizontalEnum: dim = 2; break;
    109109                case Mesh3DEnum:           dim = 2; break;
    110                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     110                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    111111        }
    112112
    … …  
    130130        Input* vx_input=NULL;
    131131        Input* vy_input=NULL;
    132         if(meshtype==Mesh2DhorizontalEnum){
     132        if(meshxdim==Mesh2DhorizontalEnum){
    133133                vx_input=basalelement->GetInput(VxEnum); _assert_(vx_input);
    134134                vy_input=basalelement->GetInput(VyEnum); _assert_(vy_input);
    … …  
    253253        xDelete<IssmDouble>(dlsf);
    254254        delete gauss;
    255         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     255        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    256256        return Ke;
    257257}/*}}}*/
    … …  
    262262
    263263        /*Intermediaries */
    264         int i, ig, meshtype;
     264        int i, ig, meshxdim;
    265265        IssmDouble  Jdet,dt;
    266266        IssmDouble  lsf;
    … …  
    298298                xDelete<IssmDouble>(xyz_list);
    299299                xDelete<IssmDouble>(basis);
    300                 basalelement->FindParam(&meshtype,MeshTypeEnum);
    301                 if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     300                basalelement->FindParam(&meshxdim,MeshXDimEnum);
     301                if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    302302                delete gauss;
    303303        }
    … …  
    310310void LevelsetAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    311311
    312         int meshtype;
    313         element->FindParam(&meshtype,MeshTypeEnum);
    314         switch(meshtype){
     312        int meshxdim;
     313        element->FindParam(&meshxdim,MeshXDimEnum);
     314        switch(meshxdim){
    315315                case Mesh2DhorizontalEnum:
    316316                        element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum);
    … …  
    319319                        element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum);
    320320                        break;
    321                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     321                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    322322        }
    323323}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.h

    r17626 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/LsfReinitializationAnalysis.cpp

    r17610 r17674  
    1010
    1111/*Model processing*/
    12 int  LsfReinitializationAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     12int  LsfReinitializationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    1313        return 1;
    1414}/*}}}*/
    … …  
    3636void LsfReinitializationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737        int finiteelement=P1Enum;
    38         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     38        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    3939        ::CreateNodes(nodes,iomodel,LsfReinitializationAnalysisEnum,finiteelement);
    4040        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    252252
    253253        IssmDouble   lsf;
    254         int          meshtype,dim,dofpernode;
     254        int          meshxdim,dim,dofpernode;
    255255        int*         doflist = NULL;
    256256
    257257        /*Get some parameters*/
    258         element->FindParam(&meshtype,MeshTypeEnum);
    259         switch(meshtype){
     258        element->FindParam(&meshxdim,MeshXDimEnum);
     259        switch(meshxdim){
    260260                case Mesh2DhorizontalEnum: dim = 2; dofpernode = 1; break;
    261261                case Mesh2DverticalEnum:   dim = 2; dofpernode = 1; break;
    262262                case Mesh3DEnum:           dim = 3; dofpernode = 1; break;
    263263                case Mesh3DtetrasEnum:     dim = 3; dofpernode = 1; break;
    264                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     264                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    265265        }
    266266
    … …  
    294294void LsfReinitializationAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    295295
    296         int meshtype;
    297         element->FindParam(&meshtype,MeshTypeEnum);
    298         switch(meshtype){
     296        int meshxdim;
     297        element->FindParam(&meshxdim,MeshXDimEnum);
     298        switch(meshxdim){
    299299                case Mesh2DhorizontalEnum:
    300300                        element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum);
    … …  
    303303                        element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum);
    304304                        break;
    305                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     305                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    306306        }
    307307}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/LsfReinitializationAnalysis.h

    r17503 r17674  
    1313public:
    1414        /*Model processing*/
    15         int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15        int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616        void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717        void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  MasstransportAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  MasstransportAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    8383        }
    8484
    85         if(iomodel->meshtype==Mesh3DEnum){
     85        if(iomodel->meshxdim==Mesh3DEnum){
    8686                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    8787                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    9090        if(islevelset){
    9191                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    92                 if(iomodel->meshtype!=Mesh2DhorizontalEnum)
     92                if(iomodel->meshxdim!=Mesh2DhorizontalEnum)
    9393                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    9494        }
    … …  
    132132
    133133        /*Check in 3d*/
    134         if(stabilization==3 && iomodel->meshtype==Mesh3DEnum) _error_("DG 3d not implemented yet");
     134        if(stabilization==3 && iomodel->meshxdim==Mesh3DEnum) _error_("DG 3d not implemented yet");
    135135
    136136        /*Create Nodes either DG or CG depending on stabilization*/
    137         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     137        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    138138        if(stabilization!=3){
    139139                ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1Enum);
    … …  
    195195        IssmDouble *nodeonbase=NULL;
    196196        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    197         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
     197        if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    198198
    199199        for(int i=0;i<numvertex_pairing;i++){
    … …  
    205205
    206206                        /*Skip if one of the two is not on the bed*/
    207                         if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     207                        if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    208208                                if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
    209209                        }
    … …  
    259259        }
    260260
    261         int meshtype;
    262         element->FindParam(&meshtype,MeshTypeEnum);
    263         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     261        int meshxdim;
     262        element->FindParam(&meshxdim,MeshXDimEnum);
     263        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    264264        return Ke;
    265265}/*}}}*/
    … …  
    271271        /*Intermediaries */
    272272        int        stabilization;
    273         int        meshtype,dim;
     273        int        meshxdim,dim;
    274274        IssmDouble Jdet,D_scalar,dt,h;
    275275        IssmDouble vel,vx,vy,dvxdx,dvydy;
    … …  
    278278
    279279        /*Get problem dimension*/
    280         element->FindParam(&meshtype,MeshTypeEnum);
    281         switch(meshtype){
     280        element->FindParam(&meshxdim,MeshXDimEnum);
     281        switch(meshxdim){
    282282                case Mesh2DverticalEnum:   dim = 1; break;
    283283                case Mesh2DhorizontalEnum: dim = 2; break;
    284284                case Mesh3DEnum:           dim = 2; break;
    285                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     285                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    286286        }
    287287
    … …  
    299299        element->GetVerticesCoordinates(&xyz_list);
    300300        element->FindParam(&dt,TimesteppingTimeStepEnum);
    301         element->FindParam(&meshtype,MeshTypeEnum);
     301        element->FindParam(&meshxdim,MeshXDimEnum);
    302302        element->FindParam(&stabilization,MasstransportStabilizationEnum);
    303303        Input* vxaverage_input=NULL;
    304304        Input* vyaverage_input=NULL;
    305         if(meshtype==Mesh2DhorizontalEnum){
     305        if(meshxdim==Mesh2DhorizontalEnum){
    306306                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    307307                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    415415
    416416        /*Intermediaries */
    417         int        meshtype;
     417        int        meshxdim;
    418418        IssmDouble Jdet,D_scalar,dt,vx,vy;
    419419        IssmDouble* xyz_list = NULL;
    … …  
    432432        element->GetVerticesCoordinates(&xyz_list);
    433433        element->FindParam(&dt,TimesteppingTimeStepEnum);
    434         element->FindParam(&meshtype,MeshTypeEnum);
     434        element->FindParam(&meshxdim,MeshXDimEnum);
    435435        Input* vxaverage_input=NULL;
    436436        Input* vyaverage_input=NULL;
    437         if(meshtype==Mesh2DhorizontalEnum){
     437        if(meshxdim==Mesh2DhorizontalEnum){
    438438                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    439439                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    505505        }
    506506
    507         int meshtype;
    508         element->FindParam(&meshtype,MeshTypeEnum);
    509         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     507        int meshxdim;
     508        element->FindParam(&meshxdim,MeshXDimEnum);
     509        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    510510        return pe;
    511511}/*}}}*/
    … …  
    670670void MasstransportAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    671671
    672         int        i,hydroadjustment,meshtype;
     672        int        i,hydroadjustment,meshxdim;
    673673        int*       doflist=NULL;
    674674        IssmDouble rho_ice,rho_water,minthickness;
    675675        Element*   basalelement=NULL;
    676676
    677         element->FindParam(&meshtype,MeshTypeEnum);
    678         if(meshtype!=Mesh2DhorizontalEnum){
     677        element->FindParam(&meshxdim,MeshXDimEnum);
     678        if(meshxdim!=Mesh2DhorizontalEnum){
    679679                if(!element->IsOnBase()) return;
    680680                basalelement=element->SpawnBasalElement();
    … …  
    750750        xDelete<IssmDouble>(phi);
    751751        xDelete<int>(doflist);
    752         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     752        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    753753}/*}}}*/
    754754void MasstransportAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/

  • issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.h

    r17331 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  MeltingAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  MeltingAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    1414
    1515        /*Now, is the model 3d? otherwise, do nothing: */
    16         if(iomodel->meshtype==Mesh2DhorizontalEnum)return;
     16        if(iomodel->meshxdim==Mesh2DhorizontalEnum)return;
    1717
    1818        /*Update elements: */
    … …  
    4444void MeltingAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4545
    46         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     46        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4747        ::CreateNodes(nodes,iomodel,MeltingAnalysisEnum,P1Enum);
    4848        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    5454
    5555        /*if 2d: Error*/
    56         if(iomodel->meshtype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
     56        if(iomodel->meshxdim==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
    5757
    5858        //create penalties for nodes: no node can have a temperature over the melting point

  • issm/trunk-jpl/src/c/analyses/MeltingAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.cpp

    r17212 r17674  
    66
    77/*Model processing*/
    8 int  MeshdeformationAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  MeshdeformationAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        _error_("not implemented");
    1010}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  SmoothedSurfaceSlopeXAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  SmoothedSurfaceSlopeXAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2626        iomodel->FetchDataToInput(elements,BaseEnum);
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    28         if(iomodel->meshtype==Mesh3DEnum){
     28        if(iomodel->meshxdim==Mesh3DEnum){
    2929                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    32         if(iomodel->meshtype==Mesh2DverticalEnum){
     32        if(iomodel->meshxdim==Mesh2DverticalEnum){
    3333                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    3636void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    37         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     37        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    3838        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum);
    39         if(iomodel->meshtype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
     39        if(iomodel->meshxdim==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
    4040}/*}}}*/
    4141void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    105105
    106106        /*Intermediaries*/
    107         int      meshtype;
     107        int      meshxdim;
    108108        Element* basalelement;
    109109
    110110        /*Get basal element*/
    111         element->FindParam(&meshtype,MeshTypeEnum);
    112         switch(meshtype){
     111        element->FindParam(&meshxdim,MeshXDimEnum);
     112        switch(meshxdim){
    113113                case Mesh2DhorizontalEnum:
    114114                        basalelement = element;
    … …  
    118118                        basalelement = element->SpawnBasalElement();
    119119                        break;
    120                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     120                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    121121        }
    122122
    … …  
    169169        xDelete<IssmDouble>(basis);
    170170        delete gauss;
    171         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     171        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    172172        return pe;
    173173}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  SmoothedSurfaceSlopeYAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  SmoothedSurfaceSlopeYAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    2626        iomodel->FetchDataToInput(elements,BaseEnum);
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    28         if(iomodel->meshtype==Mesh3DEnum){
     28        if(iomodel->meshxdim==Mesh3DEnum){
    2929                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    32         if(iomodel->meshtype==Mesh2DverticalEnum){
     32        if(iomodel->meshxdim==Mesh2DverticalEnum){
    3333                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    3636void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    37         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     37        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    3838        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum);
    39         if(iomodel->meshtype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
     39        if(iomodel->meshxdim==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
    4040}/*}}}*/
    4141void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    105105
    106106        /*Intermediaries*/
    107         int      meshtype;
     107        int      meshxdim;
    108108        Element* basalelement;
    109109
    110110        /*Get basal element*/
    111         element->FindParam(&meshtype,MeshTypeEnum);
    112         switch(meshtype){
     111        element->FindParam(&meshxdim,MeshXDimEnum);
     112        switch(meshxdim){
    113113                case Mesh2DhorizontalEnum:
    114114                        basalelement = element;
    … …  
    118118                        basalelement = element->SpawnBasalElement();
    119119                        break;
    120                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     120                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    121121        }
    122122
    … …  
    169169        xDelete<IssmDouble>(basis);
    170170        delete gauss;
    171         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     171        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    172172        return pe;
    173173}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

    r17659 r17674  
    1010
    1111/*Model processing*/
    12 int  StressbalanceAnalysis::DofsPerNode(int** pdoftype,int meshtype,int approximation){/*{{{*/
     12int  StressbalanceAnalysis::DofsPerNode(int** pdoftype,int meshxdim,int approximation){/*{{{*/
    1313
    1414        /*output*/
    … …  
    1818        switch(approximation){
    1919                case SSAApproximationEnum:
    20                          switch(meshtype){
     20                         switch(meshxdim){
    2121                                 case Mesh3DEnum:           numdofs=2; break;
    2222                                 case Mesh3DtetrasEnum:     numdofs=2; break;
    … …  
    2828                case L1L2ApproximationEnum: numdofs =2; break;
    2929                case HOApproximationEnum:   
    30                          switch(meshtype){
     30                         switch(meshxdim){
    3131                                 case Mesh3DEnum:         numdofs=2; break;
    3232                                 case Mesh3DtetrasEnum:   numdofs=2; break;
    … …  
    3737                case SIAApproximationEnum:  numdofs =2; break;
    3838                case FSvelocityEnum:
    39                          switch(meshtype){
     39                         switch(meshxdim){
    4040                                 case Mesh3DEnum:         numdofs=3; break;
    4141                                 case Mesh3DtetrasEnum:   numdofs=3; break;
    … …  
    4646                case FSpressureEnum: numdofs=1; break;
    4747                case NoneApproximationEnum:
    48                          switch(meshtype){
     48                         switch(meshxdim){
    4949                                 case Mesh3DEnum:         numdofs=4; break;
    5050                                 case Mesh3DtetrasEnum:   numdofs=4; break;
    … …  
    218218        iomodel->FetchDataToInput(elements,DamageDEnum);
    219219
    220         if(iomodel->meshtype==Mesh3DEnum){
     220        if(iomodel->meshxdim==Mesh3DEnum){
    221221                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    222222                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    227227                if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum);
    228228        }
    229         if(iomodel->meshtype==Mesh3DtetrasEnum){
     229        if(iomodel->meshxdim==Mesh3DtetrasEnum){
    230230                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    231231                iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
    … …  
    235235                if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum);
    236236        }
    237         if(iomodel->meshtype==Mesh2DverticalEnum){
     237        if(iomodel->meshxdim==Mesh2DverticalEnum){
    238238                iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
    239239        }
    … …  
    245245        if(islevelset){
    246246                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    247                 if(iomodel->meshtype!=Mesh2DhorizontalEnum)
     247                if(iomodel->meshxdim!=Mesh2DhorizontalEnum)
    248248                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    249249        }
    … …  
    299299                }
    300300                iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    301                 if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
     301                if(iomodel->meshxdim!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
    302302                ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
    303303                iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    … …  
    431431                        iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    432432                        iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    433                         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
     433                        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){
    434434                                iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    435435                        }
    436                         else if (iomodel->meshtype==Mesh2DverticalEnum){
     436                        else if (iomodel->meshxdim==Mesh2DverticalEnum){
    437437                                iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvyEnum);
    438438                        }
    … …  
    440440                                _error_("not supported yet");
    441441                        }
    442                         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
     442                        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum){
    443443                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0);
    444444                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1);
    … …  
    446446                                iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    447447                        }
    448                         else if (iomodel->meshtype==Mesh2DverticalEnum){
     448                        else if (iomodel->meshxdim==Mesh2DverticalEnum){
    449449                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0);
    450450                                IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,finiteelement,1);
    … …  
    507507                else{
    508508                        IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0);
    509                         if(iomodel->meshtype!=Mesh2DverticalEnum){
     509                        if(iomodel->meshxdim!=Mesh2DverticalEnum){
    510510                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1);
    511511                        }
    … …  
    520520        iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    521521        iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum);
    522         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
    523         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    524         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    525         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
     522        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
     523        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
     524        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
     525        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    526526        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    527527        iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum);
    … …  
    750750        iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    751751        iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum);
    752         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
    753         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    754         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
    755         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
     752        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
     753        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
     754        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
     755        if(iomodel->meshxdim==Mesh3DEnum || iomodel->meshxdim==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
    756756        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);
    757757        iomodel->DeleteData(surface,SurfaceEnum);
    … …  
    835835        bool isSSA,isL1L2,isHO,isFS;
    836836        bool conserve_loads = true;
    837         int  newton,meshtype,fe_FS;
     837        int  newton,meshxdim,fe_FS;
    838838
    839839        /* recover parameters:*/
    … …  
    843843        femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);
    844844        femmodel->parameters->FindParam(&fe_FS,FlowequationFeFSEnum);
    845         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     845        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    846846        femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
    847847
    … …  
    866866                 solutionsequence_nonlinear(femmodel,conserve_loads);
    867867
    868                 if(meshtype==Mesh2DverticalEnum && isSSA){
     868                if(meshxdim==Mesh2DverticalEnum && isSSA){
    869869                        femmodel->parameters->SetParam(VxEnum,InputToExtrudeEnum);
    870870                        extrudefrombase_core(femmodel);
    … …  
    989989
    990990        IssmDouble   vx,vy;
    991         int          meshtype,dim,approximation,dofpernode;
     991        int          meshxdim,dim,approximation,dofpernode;
    992992        int*         doflist = NULL;
    993993
    994994        /*Get some parameters*/
    995         element->FindParam(&meshtype,MeshTypeEnum);
    996         switch(meshtype){
     995        element->FindParam(&meshxdim,MeshXDimEnum);
     996        switch(meshxdim){
    997997                case Mesh2DhorizontalEnum: dim = 2; dofpernode = 2; break;
    998998                case Mesh2DverticalEnum:   dim = 2; dofpernode = 1; break;
    999999                case Mesh3DEnum:           dim = 3; dofpernode = 2; break;
    10001000                case Mesh3DtetrasEnum:     dim = 3; dofpernode = 2; break;
    1001                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1001                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    10021002        }
    10031003
    … …  
    10141014        Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    10151015        Input* vy_input=NULL;
    1016         if(meshtype!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);}
     1016        if(meshxdim!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);}
    10171017
    10181018        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    10831083
    10841084        /*Intermediaries*/
    1085         int      meshtype;
     1085        int      meshxdim;
    10861086        Element* basalelement;
    10871087
    10881088        /*Get basal element*/
    1089         element->FindParam(&meshtype,MeshTypeEnum);
    1090         switch(meshtype){
     1089        element->FindParam(&meshxdim,MeshXDimEnum);
     1090        switch(meshxdim){
    10911091                case Mesh2DhorizontalEnum:
    10921092                        basalelement = element;
    … …  
    10961096                        basalelement = element->SpawnBasalElement();
    10971097                        break;
    1098                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1098                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    10991099        }
    11001100
    … …  
    11591159
    11601160        /*clean-up and return*/
    1161         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1161        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    11621162        return Ke;
    11631163
    … …  
    11691169
    11701170        /*Intermediaries*/
    1171         int      meshtype;
     1171        int      meshxdim;
    11721172        Element* basalelement;
    11731173
    11741174        /*Get basal element*/
    1175         element->FindParam(&meshtype,MeshTypeEnum);
    1176         switch(meshtype){
     1175        element->FindParam(&meshxdim,MeshXDimEnum);
     1176        switch(meshxdim){
    11771177                case Mesh2DhorizontalEnum:
    11781178                        basalelement = element;
    … …  
    11821182                        basalelement = element->SpawnBasalElement();
    11831183                        break;
    1184                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1184                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    11851185        }
    11861186
    … …  
    11911191
    11921192        /*clean-up and return*/
    1193         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1193        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    11941194        delete Ke1;
    11951195        delete Ke2;
    … …  
    12021202
    12031203        /*Intermediaries*/
    1204         int         dim,meshtype;
     1204        int         dim,meshxdim;
    12051205        bool        mainlyfloating;
    12061206        int         migration_style,point1;
    … …  
    12111211
    12121212        /*Get problem dimension*/
    1213         element->FindParam(&meshtype,MeshTypeEnum);
    1214         switch(meshtype){
     1213        element->FindParam(&meshxdim,MeshXDimEnum);
     1214        switch(meshxdim){
    12151215                case Mesh2DverticalEnum:   dim = 1;break;
    12161216                case Mesh2DhorizontalEnum: dim = 2;break;
    12171217                case Mesh3DEnum:           dim = 2;break;
    12181218                case Mesh3DtetrasEnum:     dim = 2;break;
    1219                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1219                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    12201220        }
    12211221
    … …  
    12901290
    12911291        /*Intermediaries*/
    1292         int         dim,meshtype,bsize;
     1292        int         dim,meshxdim,bsize;
    12931293        IssmDouble  viscosity,newviscosity,oldviscosity;
    12941294        IssmDouble  viscosity_overshoot,thickness,Jdet;
    … …  
    12971297
    12981298        /*Get problem dimension*/
    1299         element->FindParam(&meshtype,MeshTypeEnum);
    1300         switch(meshtype){
     1299        element->FindParam(&meshxdim,MeshXDimEnum);
     1300        switch(meshxdim){
    13011301                case Mesh2DverticalEnum:   dim = 1; bsize = 1; break;
    13021302                case Mesh2DhorizontalEnum: dim = 2; bsize = 3; break;
    13031303                case Mesh3DEnum:           dim = 2; bsize = 3; break;
    13041304                case Mesh3DtetrasEnum:     dim = 2; bsize = 3; break;
    1305                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1305                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    13061306        }
    13071307
    … …  
    13721372
    13731373        /*Intermediaries*/
    1374         int      meshtype;
     1374        int      meshxdim;
    13751375        Element* basalelement;
    13761376
    13771377        /*Get basal element*/
    1378         element->FindParam(&meshtype,MeshTypeEnum);
    1379         switch(meshtype){
     1378        element->FindParam(&meshxdim,MeshXDimEnum);
     1379        switch(meshxdim){
    13801380                case Mesh2DhorizontalEnum:
    13811381                        basalelement = element;
    … …  
    13851385                        basalelement = element->SpawnBasalElement();
    13861386                        break;
    1387                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1387                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    13881388        }
    13891389
    … …  
    13941394
    13951395        /*clean-up and return*/
    1396         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1396        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    13971397        delete pe1;
    13981398        delete pe2;
    … …  
    14051405
    14061406        /*Intermediaries */
    1407         int         dim,meshtype;
     1407        int         dim,meshxdim;
    14081408        IssmDouble  thickness,Jdet,slope[2];
    14091409        IssmDouble* xyz_list = NULL;
    14101410
    14111411        /*Get problem dimension*/
    1412         element->FindParam(&meshtype,MeshTypeEnum);
    1413         switch(meshtype){
     1412        element->FindParam(&meshxdim,MeshXDimEnum);
     1413        switch(meshxdim){
    14141414                case Mesh2DverticalEnum:   dim = 1;break;
    14151415                case Mesh2DhorizontalEnum: dim = 2;break;
    14161416                case Mesh3DEnum:           dim = 2;break;
    14171417                case Mesh3DtetrasEnum:     dim = 2;break;
    1418                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1418                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    14191419        }
    14201420
    … …  
    14681468
    14691469        /*Intermediaries*/
    1470         int         dim,meshtype;
     1470        int         dim,meshxdim;
    14711471        IssmDouble  Jdet,thickness,bed,water_pressure,ice_pressure;
    14721472        IssmDouble  surface_under_water,base_under_water,pressure;
    … …  
    14761476
    14771477        /*Get problem dimension*/
    1478         element->FindParam(&meshtype,MeshTypeEnum);
    1479         switch(meshtype){
     1478        element->FindParam(&meshxdim,MeshXDimEnum);
     1479        switch(meshxdim){
    14801480                case Mesh2DverticalEnum:   dim = 1;break;
    14811481                case Mesh2DhorizontalEnum: dim = 2;break;
    14821482                case Mesh3DEnum:           dim = 2;break;
    14831483                case Mesh3DtetrasEnum:     dim = 2;break;
    1484                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1484                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    14851485        }
    14861486
    … …  
    16541654void StressbalanceAnalysis::InputUpdateFromSolutionSSA(IssmDouble* solution,Element* element){/*{{{*/
    16551655
    1656         int         i,dim,meshtype;
     1656        int         i,dim,meshxdim;
    16571657        IssmDouble  rho_ice,g;
    16581658        int*        doflist=NULL;
    … …  
    16661666        IssmDouble* surface   = xNew<IssmDouble>(numvertices);
    16671667
    1668         element->FindParam(&meshtype,MeshTypeEnum);
     1668        element->FindParam(&meshxdim,MeshXDimEnum);
    16691669        rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    16701670        g       =element->GetMaterialParameter(ConstantsGEnum);
    1671         switch(meshtype){
     1671        switch(meshxdim){
    16721672                case Mesh2DhorizontalEnum:
    16731673                        element->GetInputListOnVertices(thickness,ThicknessEnum);
    … …  
    16871687                        dim=1;
    16881688                        break;
    1689                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1689                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    16901690        }
    16911691        element->AddInput(PressureEnum,pressure,P1Enum);
    … …  
    16951695
    16961696        /*Get basal element*/
    1697         switch(meshtype){
     1697        switch(meshxdim){
    16981698                case Mesh2DhorizontalEnum:
    16991699                        basalelement = element;
    … …  
    17031703                        basalelement=element->SpawnBasalElement();
    17041704                        break;
    1705                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1705                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    17061706        }
    17071707
    … …  
    17631763        xDelete<IssmDouble>(xyz_list);
    17641764        xDelete<int>(doflist);
    1765         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1765        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    17661766}/*}}}*/
    17671767
    … …  
    18521852
    18531853        /*Intermediaries*/
    1854         int      meshtype;
     1854        int      meshxdim;
    18551855        Element* basalelement;
    18561856
    18571857        /*Get basal element*/
    1858         element->FindParam(&meshtype,MeshTypeEnum);
    1859         switch(meshtype){
     1858        element->FindParam(&meshxdim,MeshXDimEnum);
     1859        switch(meshxdim){
    18601860                case Mesh2DhorizontalEnum:
    18611861                        basalelement = element;
    … …  
    18651865                        basalelement = element->SpawnBasalElement();
    18661866                        break;
    1867                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1867                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    18681868        }
    18691869
    … …  
    18741874
    18751875        /*clean-up and return*/
    1876         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1876        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    18771877        delete pe1;
    18781878        delete pe2;
    … …  
    19881988void StressbalanceAnalysis::InputUpdateFromSolutionL1L2(IssmDouble* solution,Element* element){/*{{{*/
    19891989
    1990         int         i,meshtype;
     1990        int         i,meshxdim;
    19911991        IssmDouble  rho_ice,g;
    19921992        int*        doflist=NULL;
    … …  
    20002000        IssmDouble* surface   = xNew<IssmDouble>(numvertices);
    20012001
    2002         element->FindParam(&meshtype,MeshTypeEnum);
     2002        element->FindParam(&meshxdim,MeshXDimEnum);
    20032003        rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    20042004        g       =element->GetMaterialParameter(ConstantsGEnum);
    2005         switch(meshtype){
     2005        switch(meshxdim){
    20062006                case Mesh2DhorizontalEnum:
    20072007                        element->GetInputListOnVertices(thickness,ThicknessEnum);
    … …  
    20132013                        for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
    20142014                        break;
    2015                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2015                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    20162016        }
    20172017        element->AddInput(PressureEnum,pressure,P1Enum);
    … …  
    20212021
    20222022        /*Get basal element*/
    2023         switch(meshtype){
     2023        switch(meshxdim){
    20242024                case Mesh2DhorizontalEnum:
    20252025                        basalelement = element;
    … …  
    20292029                        basalelement=element->SpawnBasalElement();
    20302030                        break;
    2031                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2031                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    20322032        }
    20332033
    … …  
    20492049        /*Transform solution in Cartesian Space*/
    20502050        basalelement->TransformSolutionCoord(&values[0],XYEnum);
    2051         basalelement->FindParam(&meshtype,MeshTypeEnum);
     2051        basalelement->FindParam(&meshxdim,MeshXDimEnum);
    20522052
    20532053        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    20832083        xDelete<IssmDouble>(xyz_list);
    20842084        xDelete<int>(doflist);
    2085         if(meshtype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     2085        if(meshxdim!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    20862086}/*}}}*/
    20872087
    … …  
    21692169
    21702170        /*Intermediaries*/
    2171         int         dim,meshtype,bsize;
     2171        int         dim,meshxdim,bsize;
    21722172        IssmDouble  viscosity,newviscosity,oldviscosity;
    21732173        IssmDouble  viscosity_overshoot,thickness,Jdet;
    … …  
    21762176
    21772177        /*Get problem dimension*/
    2178         element->FindParam(&meshtype,MeshTypeEnum);
    2179         switch(meshtype){
     2178        element->FindParam(&meshxdim,MeshXDimEnum);
     2179        switch(meshxdim){
    21802180                case Mesh2DverticalEnum: dim = 2; bsize = 2; break;
    21812181                case Mesh3DEnum:         dim = 3; bsize = 5; break;
    21822182                case Mesh3DtetrasEnum:   dim = 3; bsize = 5; break;
    2183                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2183                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    21842184        }
    21852185
    … …  
    22472247
    22482248        /*Intermediaries*/
    2249         int         dim,meshtype;
     2249        int         dim,meshxdim;
    22502250        bool        mainlyfloating;
    22512251        int         migration_style,point1;
    … …  
    22562256
    22572257        /*Get problem dimension*/
    2258         element->FindParam(&meshtype,MeshTypeEnum);
    2259         switch(meshtype){
     2258        element->FindParam(&meshxdim,MeshXDimEnum);
     2259        switch(meshxdim){
    22602260                case Mesh2DverticalEnum: dim = 2; break;
    22612261                case Mesh3DEnum:         dim = 3; break;
    22622262                case Mesh3DtetrasEnum:   dim = 3; break;
    2263                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2263                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    22642264        }
    22652265
    … …  
    23362336
    23372337        /*Intermediaries */
    2338         int         dim,meshtype;
     2338        int         dim,meshxdim;
    23392339        IssmDouble  x_coord,y_coord,z_coord;
    23402340        IssmDouble  Jdet,forcex,forcey,forcez;
    … …  
    23422342
    23432343        /*Get problem dimension*/
    2344         element->FindParam(&meshtype,MeshTypeEnum);
    2345         switch(meshtype){
     2344        element->FindParam(&meshxdim,MeshXDimEnum);
     2345        switch(meshxdim){
    23462346                case Mesh2DverticalEnum: dim = 2; break;
    23472347                case Mesh3DEnum:         dim = 3; break;
    23482348                case Mesh3DtetrasEnum:   dim = 3; break;
    2349                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2349                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    23502350        }
    23512351
    … …  
    24142414
    24152415        /*Intermediaries */
    2416         int         dim,meshtype;
     2416        int         dim,meshxdim;
    24172417        IssmDouble  Jdet,slope[3];
    24182418        IssmDouble* xyz_list = NULL;
    24192419
    24202420        /*Get problem dimension*/
    2421         element->FindParam(&meshtype,MeshTypeEnum);
    2422         switch(meshtype){
     2421        element->FindParam(&meshxdim,MeshXDimEnum);
     2422        switch(meshxdim){
    24232423                case Mesh2DverticalEnum: dim = 2; break;
    24242424                case Mesh3DEnum:         dim = 3; break;
    24252425                case Mesh3DtetrasEnum:   dim = 3; break;
    2426                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2426                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    24272427        }
    24282428
    … …  
    24722472
    24732473        /*Intermediaries*/
    2474         int         dim,meshtype;
     2474        int         dim,meshxdim;
    24752475        IssmDouble  Jdet,surface,z,water_pressure,ice_pressure;
    24762476        IssmDouble  surface_under_water,base_under_water,pressure;
    … …  
    24812481
    24822482        /*Get problem dimension*/
    2483         element->FindParam(&meshtype,MeshTypeEnum);
    2484         switch(meshtype){
     2483        element->FindParam(&meshxdim,MeshXDimEnum);
     2484        switch(meshxdim){
    24852485                case Mesh2DverticalEnum: dim = 2; break;
    24862486                case Mesh3DEnum:         dim = 3; break;
    24872487                case Mesh3DtetrasEnum:   dim = 3; break;
    2488                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2488                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    24892489        }
    24902490
    … …  
    26752675void StressbalanceAnalysis::InputUpdateFromSolutionHO(IssmDouble* solution,Element* element){/*{{{*/
    26762676
    2677         int         i,dim,meshtype;
     2677        int         i,dim,meshxdim;
    26782678        int*        doflist=NULL;
    26792679        IssmDouble* xyz_list=NULL;
    26802680
    26812681        /*Get mesh dimension*/
    2682         element->FindParam(&meshtype,MeshTypeEnum);
    2683         switch(meshtype){
     2682        element->FindParam(&meshxdim,MeshXDimEnum);
     2683        switch(meshxdim){
    26842684                case Mesh2DverticalEnum: dim = 2; break;
    26852685                case Mesh3DEnum:         dim = 3; break;
    26862686                case Mesh3DtetrasEnum:   dim = 3; break;
    2687                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2687                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    26882688        }
    26892689
    … …  
    27652765ElementVector* StressbalanceAnalysis::CreateDVectorFS(Element* element){/*{{{*/
    27662766
    2767         int         meshtype,dim;
     2767        int         meshxdim,dim;
    27682768
    27692769        /*Get problem dimension*/
    2770         element->FindParam(&meshtype,MeshTypeEnum);
    2771         switch(meshtype){
     2770        element->FindParam(&meshxdim,MeshXDimEnum);
     2771        switch(meshxdim){
    27722772                case Mesh2DverticalEnum: dim = 2; break;
    27732773                case Mesh3DEnum:         dim = 3; break;
    27742774                case Mesh3DtetrasEnum:   dim = 3; break;
    2775                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2775                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    27762776        }
    27772777
    … …  
    29042904
    29052905        /*Intermediaries*/
    2906         int         i,meshtype,dim,epssize;
     2906        int         i,meshxdim,dim,epssize;
    29072907        IssmDouble  r,FSreconditioning,Jdet;
    29082908        IssmDouble *xyz_list = NULL;
    29092909
    29102910        /*Get problem dimension*/
    2911         element->FindParam(&meshtype,MeshTypeEnum);
     2911        element->FindParam(&meshxdim,MeshXDimEnum);
    29122912        element->FindParam(&r,AugmentedLagrangianREnum);
    2913         switch(meshtype){
     2913        switch(meshxdim){
    29142914                case Mesh2DverticalEnum: dim = 2; epssize = 3; break;
    29152915                case Mesh3DEnum:         dim = 3; epssize = 6; break;
    29162916                case Mesh3DtetrasEnum:   dim = 3; epssize = 6; break;
    2917                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2917                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    29182918        }
    29192919
    … …  
    29772977
    29782978        /*Intermediaries*/
    2979         int         i,meshtype,dim,epssize;
     2979        int         i,meshxdim,dim,epssize;
    29802980        IssmDouble  viscosity,FSreconditioning,Jdet;
    29812981        IssmDouble *xyz_list = NULL;
    29822982
    29832983        /*Get problem dimension*/
    2984         element->FindParam(&meshtype,MeshTypeEnum);
    2985         switch(meshtype){
     2984        element->FindParam(&meshxdim,MeshXDimEnum);
     2985        switch(meshxdim){
    29862986                case Mesh2DverticalEnum: dim = 2; epssize = 3; break;
    29872987                case Mesh3DEnum:         dim = 3; epssize = 6; break;
    29882988                case Mesh3DtetrasEnum:   dim = 3; epssize = 6; break;
    2989                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     2989                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    29902990        }
    29912991
    … …  
    30603060        /*Intermediaries*/
    30613061        bool        mainlyfloating;
    3062         int         j,i,meshtype,dim;
     3062        int         j,i,meshxdim,dim;
    30633063        IssmDouble  Jdet,slope2,scalar,dt;
    30643064        IssmDouble  slope[3];
    … …  
    30683068
    30693069        /*Get problem dimension*/
    3070         element->FindParam(&meshtype,MeshTypeEnum);
    3071         switch(meshtype){
     3070        element->FindParam(&meshxdim,MeshXDimEnum);
     3071        switch(meshxdim){
    30723072                case Mesh2DverticalEnum: dim = 2;break;
    30733073                case Mesh3DEnum:         dim = 3;break;
    30743074                case Mesh3DtetrasEnum:   dim = 3;break;
    3075                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3075                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    30763076        }
    30773077
    … …  
    31323132
    31333133        /*Intermediaries*/
    3134         int         i,meshtype,dim;
     3134        int         i,meshxdim,dim;
    31353135        IssmDouble  alpha2,Jdet;
    31363136        IssmDouble  x_coord,y_coord,z_coord;
    … …  
    31393139
    31403140        /*Get problem dimension*/
    3141         element->FindParam(&meshtype,MeshTypeEnum);
    3142         switch(meshtype){
     3141        element->FindParam(&meshxdim,MeshXDimEnum);
     3142        switch(meshxdim){
    31433143                case Mesh2DverticalEnum: dim = 2;break;
    31443144                case Mesh3DEnum:         dim = 3;break;
    31453145                case Mesh3DtetrasEnum:   dim = 3;break;
    3146                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3146                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    31473147        }
    31483148
    … …  
    31973197ElementVector* StressbalanceAnalysis::CreatePVectorFS(Element* element){/*{{{*/
    31983198
    3199         int         i,meshtype,dim,fe_FS;
     3199        int         i,meshxdim,dim,fe_FS;
    32003200        IssmDouble  x_coord,y_coord,z_coord;
    32013201        IssmDouble  Jdet,forcex,forcey,forcez;
    … …  
    32033203
    32043204        element->FindParam(&fe_FS,FlowequationFeFSEnum);
    3205         element->FindParam(&meshtype,MeshTypeEnum);
    3206         switch(meshtype){
     3205        element->FindParam(&meshxdim,MeshXDimEnum);
     3206        switch(meshxdim){
    32073207                case Mesh2DverticalEnum: dim = 2; break;
    32083208                case Mesh3DEnum:         dim = 3; break;
    32093209                case Mesh3DtetrasEnum:   dim = 3; break;
    3210                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3210                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    32113211        }
    32123212
    … …  
    32813281        /*Intermediaries*/
    32823282        bool        mainlyfloating;
    3283         int         i,meshtype,dim,epssize;
     3283        int         i,meshxdim,dim,epssize;
    32843284        int         migration_style,point1;
    32853285        IssmDouble  alpha2,Jdet,fraction1,fraction2;
    … …  
    32893289
    32903290        /*Get problem dimension*/
    3291         element->FindParam(&meshtype,MeshTypeEnum);
    3292         switch(meshtype){
     3291        element->FindParam(&meshxdim,MeshXDimEnum);
     3292        switch(meshxdim){
    32933293                case Mesh2DverticalEnum: dim = 2;break;
    32943294                case Mesh3DEnum:         dim = 3;break;
    32953295                case Mesh3DtetrasEnum:   dim = 3;break;
    3296                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3296                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    32973297        }
    32983298
    … …  
    33223322        if(migration_style==SubelementMigrationEnum) phi=element->GetGroundedPortion(xyz_list_base);
    33233323        if(migration_style==SubelementMigration2Enum){
    3324                 if(meshtype==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline");
     3324                if(meshxdim==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline");
    33253325                gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    33263326                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    … …  
    33993399ElementVector* StressbalanceAnalysis::CreatePVectorFSViscous(Element* element){/*{{{*/
    34003400
    3401         int         i,meshtype,dim;
     3401        int         i,meshxdim,dim;
    34023402        IssmDouble  Jdet,forcex,forcey,forcez;
    34033403        IssmDouble *xyz_list = NULL;
    34043404
    34053405        /*Get problem dimension*/
    3406         element->FindParam(&meshtype,MeshTypeEnum);
    3407         switch(meshtype){
     3406        element->FindParam(&meshxdim,MeshXDimEnum);
     3407        switch(meshxdim){
    34083408                case Mesh2DverticalEnum: dim = 2; break;
    34093409                case Mesh3DEnum:         dim = 3; break;
    34103410                case Mesh3DtetrasEnum:   dim = 3; break;
    3411                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3411                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    34123412        }
    34133413
    … …  
    34743474ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousXTH(Element* element){/*{{{*/
    34753475
    3476         int         i,tausize,meshtype,dim;
     3476        int         i,tausize,meshxdim,dim;
    34773477        IssmDouble  Jdet,r;
    34783478        IssmDouble  epsxx,epsyy,epszz,epsxy,epsxz,epsyz;
    … …  
    34823482
    34833483        /*Get problem dimension*/
    3484         element->FindParam(&meshtype,MeshTypeEnum);
    3485         switch(meshtype){
     3484        element->FindParam(&meshxdim,MeshXDimEnum);
     3485        switch(meshxdim){
    34863486                case Mesh2DverticalEnum: dim = 2; tausize = 3; break;
    34873487                case Mesh3DEnum:         dim = 3; tausize = 6; break;
    34883488                case Mesh3DtetrasEnum:   dim = 3; tausize = 6; break;
    3489                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3489                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    34903490        }
    34913491
    … …  
    36503650ElementVector* StressbalanceAnalysis::CreatePVectorFSShelf(Element* element){/*{{{*/
    36513651
    3652         int         i,meshtype,dim;
     3652        int         i,meshxdim,dim;
    36533653        IssmDouble  Jdet,water_pressure,bed;
    36543654        IssmDouble      normal[3];
    … …  
    36593659
    36603660        /*Get problem dimension*/
    3661         element->FindParam(&meshtype,MeshTypeEnum);
    3662         switch(meshtype){
     3661        element->FindParam(&meshxdim,MeshXDimEnum);
     3662        switch(meshxdim){
    36633663                case Mesh2DverticalEnum: dim = 2; break;
    36643664                case Mesh3DEnum:         dim = 3; break;
    36653665                case Mesh3DtetrasEnum:   dim = 3; break;
    3666                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3666                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    36673667        }
    36683668
    … …  
    37253725
    37263726        /*Intermediaries*/
    3727         int         i,meshtype,dim;
     3727        int         i,meshxdim,dim;
    37283728        IssmDouble  Jdet,pressure,surface,z;
    37293729        IssmDouble      normal[3];
    … …  
    37363736
    37373737        /*Get problem dimension*/
    3738         element->FindParam(&meshtype,MeshTypeEnum);
    3739         switch(meshtype){
     3738        element->FindParam(&meshxdim,MeshXDimEnum);
     3739        switch(meshxdim){
    37403740                case Mesh2DverticalEnum: dim = 2; break;
    37413741                case Mesh3DEnum:         dim = 3; break;
    37423742                case Mesh3DtetrasEnum:   dim = 3; break;
    3743                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     3743                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    37443744        }
    37453745
    … …  
    40834083        int*         pdoflist=NULL;
    40844084        Input*       vz_input=NULL;
    4085         int          meshtype,dim;
     4085        int          meshxdim,dim;
    40864086        IssmDouble   vx,vy,vz,p;
    40874087        IssmDouble   FSreconditioning;
    40884088
    40894089        /*Get some parameters*/
    4090         element->FindParam(&meshtype,MeshTypeEnum);
     4090        element->FindParam(&meshxdim,MeshXDimEnum);
    40914091        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    4092         switch(meshtype){
     4092        switch(meshxdim){
    40934093                case Mesh2DverticalEnum: dim = 2; break;
    40944094                case Mesh3DEnum:         dim = 3; break;
    40954095                case Mesh3DtetrasEnum:   dim = 3; break;
    4096                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     4096                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    40974097        }
    40984098
    … …  
    41504150
    41514151        /*Intermediaries*/
    4152         int        meshtype,dim;
     4152        int        meshxdim,dim;
    41534153        IssmDouble dvx[3],dvy[3],dvz[3];
    41544154        IssmDouble viscosity;
    … …  
    41564156
    41574157        /*Get problem dimension*/
    4158         parameters->FindParam(&meshtype,MeshTypeEnum);
    4159         switch(meshtype){
     4158        parameters->FindParam(&meshxdim,MeshXDimEnum);
     4159        switch(meshxdim){
    41604160                case Mesh2DverticalEnum: dim = 2; break;
    41614161                case Mesh3DEnum:         dim = 3; break;
    41624162                case Mesh3DtetrasEnum:   dim = 3; break;
    4163                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     4163                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    41644164        }
    41654165
    … …  
    42354235
    42364236        bool         results_on_nodes;
    4237         int          i,dim,meshtype;
     4237        int          i,dim,meshxdim;
    42384238        int*         vdoflist=NULL;
    42394239        int*         pdoflist=NULL;
    42404240        IssmDouble   FSreconditioning;
    42414241
    4242         element->FindParam(&meshtype,MeshTypeEnum);
     4242        element->FindParam(&meshxdim,MeshXDimEnum);
    42434243        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    42444244        element->FindParam(&results_on_nodes,SettingsResultsOnNodesEnum);
    4245         switch(meshtype){
     4245        switch(meshxdim){
    42464246                case Mesh2DverticalEnum: dim = 2; break;
    42474247                case Mesh3DEnum:         dim = 3; break;
    42484248                case Mesh3DtetrasEnum:   dim = 3; break;
    4249                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     4249                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    42504250        }
    42514251
    … …  
    43314331
    43324332        /*Intermediaries*/
    4333         int         dim,tausize,meshtype;
     4333        int         dim,tausize,meshxdim;
    43344334        IssmDouble  epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar;
    43354335        IssmDouble  epsxx_old,epsyy_old,epszz_old,epsxy_old,epsxz_old,epsyz_old;
    … …  
    43404340
    43414341        parameters->FindParam(&r,AugmentedLagrangianREnum);
    4342         parameters->FindParam(&meshtype,MeshTypeEnum);
    4343         switch(meshtype){
     4342        parameters->FindParam(&meshxdim,MeshXDimEnum);
     4343        switch(meshxdim){
    43444344                case Mesh2DverticalEnum: dim = 2; tausize = 3; break;
    43454345                case Mesh3DEnum:         dim = 3; tausize = 6; break;
    43464346                case Mesh3DtetrasEnum:   dim = 3; tausize = 6; break;
    4347                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     4347                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    43484348        }
    43494349
    … …  
    45454545
    45464546        /*Intermediaries*/
    4547         int         dim,tausize,meshtype;
     4547        int         dim,tausize,meshxdim;
    45484548        IssmDouble  epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar;
    45494549        IssmDouble  d_xx,d_yy,d_zz,d_xy,d_xz,d_yz;
    … …  
    45544554
    45554555        parameters->FindParam(&r,AugmentedLagrangianREnum);
    4556         parameters->FindParam(&meshtype,MeshTypeEnum);
    4557         switch(meshtype){
     4556        parameters->FindParam(&meshxdim,MeshXDimEnum);
     4557        switch(meshxdim){
    45584558                case Mesh2DverticalEnum: dim = 2; tausize = 3; break;
    45594559                case Mesh3DEnum:         dim = 3; tausize = 6; break;
    45604560                case Mesh3DtetrasEnum:   dim = 3; tausize = 6; break;
    4561                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     4561                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    45624562        }
    45634563
    … …  
    63406340void StressbalanceAnalysis::InputUpdateFromSolutionSSAHO(IssmDouble* solution,Element* element){/*{{{*/
    63416341
    6342         int         i,meshtype;
     6342        int         i,meshxdim;
    63436343        IssmDouble  rho_ice,g;
    63446344        int*        SSAdoflist = NULL;

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h

    r17653 r17674  
    1313  public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp

    r17610 r17674  
    77
    88/*Model processing*/
    9 int  StressbalanceSIAAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     9int  StressbalanceSIAAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    1010        return 2;
    1111}/*}}}*/
    … …  
    4242        if(islevelset){
    4343                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    44                 if(iomodel->meshtype!=Mesh2DhorizontalEnum)
     44                if(iomodel->meshxdim!=Mesh2DhorizontalEnum)
    4545                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    4646        }
    … …  
    6464        int    lid=0;
    6565        iomodel->FetchData(4,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    66         if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     66        if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    6767                iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6868        }
    … …  
    163163        if(!element->IsIceInElement()) return NULL;
    164164
    165         int meshtype;
    166         element->FindParam(&meshtype,MeshTypeEnum);
    167         switch(meshtype){
     165        int meshxdim;
     166        element->FindParam(&meshxdim,MeshXDimEnum);
     167        switch(meshxdim){
    168168                case Mesh2DhorizontalEnum:
    169169                        return CreateKMatrix2D(element);
    170170                case Mesh3DEnum:
    171171                        return CreateKMatrix3D(element);
    172                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     172                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    173173        }
    174174}/*}}}*/
    … …  
    266266        if(!element->IsIceInElement()) return NULL;
    267267
    268         int meshtype;
    269         element->FindParam(&meshtype,MeshTypeEnum);
    270         switch(meshtype){
     268        int meshxdim;
     269        element->FindParam(&meshxdim,MeshXDimEnum);
     270        switch(meshxdim){
    271271                case Mesh2DhorizontalEnum:
    272272                        return CreatePVector2D(element);
    273273                case Mesh3DEnum:
    274274                        return CreatePVector3D(element);
    275                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     275                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    276276        }
    277277}/*}}}*/
    … …  
    495495void StressbalanceSIAAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    496496
    497         int         i,meshtype;
     497        int         i,meshxdim;
    498498        IssmDouble  rho_ice,g;
    499499        int*        doflist=NULL;
    … …  
    539539        rho_ice  = element->GetMaterialParameter(MaterialsRhoIceEnum);
    540540        g        = element->GetMaterialParameter(ConstantsGEnum);
    541         element->FindParam(&meshtype,MeshTypeEnum);
    542         switch(meshtype){
     541        element->FindParam(&meshxdim,MeshXDimEnum);
     542        switch(meshxdim){
    543543                case Mesh2DhorizontalEnum:
    544544                        element->GetInputListOnNodes(&thickness[0],ThicknessEnum);
    … …  
    550550                        for(i=0;i<numnodes;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
    551551                        break;
    552                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     552                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    553553        }
    554554

  • issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp

    r17610 r17674  
    77
    88/*Model processing*/
    9 int  StressbalanceVerticalAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     9int  StressbalanceVerticalAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    1010        return 1;
    1111}/*}}}*/
    … …  
    1818
    1919        /*return if not 3d mesh*/
    20         if(iomodel->meshtype!=Mesh3DEnum) return;
     20        if(iomodel->meshxdim!=Mesh3DEnum) return;
    2121
    2222        /*Update elements: */
    … …  
    4343
    4444        /*return if not 3d mesh*/
    45         if(iomodel->meshtype!=Mesh3DEnum) return;
     45        if(iomodel->meshxdim!=Mesh3DEnum) return;
    4646
    4747        iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    … …  
    5959
    6060        /*return if not 3d mesh*/
    61         if(iomodel->meshtype!=Mesh3DEnum) return;
     61        if(iomodel->meshxdim!=Mesh3DEnum) return;
    6262
    6363        /*Fetch data: */

  • issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp

    r17610 r17674  
    66
    77/*Model processing*/
    8 int  ThermalAnalysis::DofsPerNode(int** doflist,int meshtype,int approximation){/*{{{*/
     8int  ThermalAnalysis::DofsPerNode(int** doflist,int meshxdim,int approximation){/*{{{*/
    99        return 1;
    1010}/*}}}*/
    … …  
    3131
    3232        /*Now, is the model 3d? otherwise, do nothing: */
    33         if(iomodel->meshtype==Mesh2DhorizontalEnum)return;
     33        if(iomodel->meshxdim==Mesh2DhorizontalEnum)return;
    3434
    3535        /*Update elements: */
    … …  
    8383void ThermalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    8484
    85         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     85        if(iomodel->meshxdim==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    8686        ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P1Enum);
    8787        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    9090
    9191        /*Only 3d mesh supported*/
    92         if(iomodel->meshtype==Mesh3DEnum){
     92        if(iomodel->meshxdim==Mesh3DEnum){
    9393                IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P1Enum);
    9494        }
    … …  
    9797void ThermalAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    9898
    99         if(iomodel->meshtype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
     99        if(iomodel->meshxdim==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
    100100
    101101        /*create penalties for nodes: no node can have a temperature over the melting point*/

  • issm/trunk-jpl/src/c/analyses/ThermalAnalysis.h

    r17212 r17674  
    1313        public:
    1414                /*Model processing*/
    15                 int  DofsPerNode(int** doflist,int meshtype,int approximation);
     15                int  DofsPerNode(int** doflist,int meshxdim,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1717                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);

  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r17671 r17674  
    101101        _assert_(this->inputs);
    102102       
    103         int meshtype;
    104         parameters->FindParam(&meshtype,MeshTypeEnum);
    105         switch(meshtype){
     103        int meshxdim;
     104        parameters->FindParam(&meshxdim,MeshXDimEnum);
     105        switch(meshxdim){
    106106                case Mesh2DhorizontalEnum:
    107107                        this->inputs->AddInput(new TriaInput(input_enum,values,interpolation_enum));
    … …  
    123123                        }
    124124                        break;
    125                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     125                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    126126        }
    127127
    … …  
    461461
    462462        bool              mainlyfloating = true;
    463         int               meshtype,index1,index2;
     463        int               meshxdim,index1,index2;
    464464        const IssmPDouble epsilon        = 1.e-15;
    465465        IssmDouble        phi,s1,s2,area_init,area_grounded;
    … …  
    468468
    469469        /*Recover parameters and values*/
    470         parameters->FindParam(&meshtype,MeshTypeEnum);
     470        parameters->FindParam(&meshxdim,MeshXDimEnum);
    471471        GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    472472
    … …  
    476476        if(gl[2]==0.) gl[2]=gl[2]+epsilon;
    477477
    478         if(meshtype==Mesh2DverticalEnum){
     478        if(meshxdim==Mesh2DverticalEnum){
    479479                this->EdgeOnBaseIndices(&index1,&index2);
    480480                if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded
    … …  
    488488
    489489        }
    490         else if(meshtype==Mesh2DhorizontalEnum || meshtype==Mesh3DEnum){
     490        else if(meshxdim==Mesh2DhorizontalEnum || meshxdim==Mesh3DEnum){
    491491                /*Check that not all nodes are grounded or floating*/
    492492                if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All grounded
    … …  
    568568                }
    569569        }
    570         else _error_("mesh type "<<EnumToStringx(meshtype)<<"not supported yet ");
     570        else _error_("mesh type "<<EnumToStringx(meshxdim)<<"not supported yet ");
    571571
    572572        if(phi>1 || phi<0) _error_("Error. Problem with portion of grounded element: value should be between 0 and 1");
    … …  
    11101110bool Tria::IsOnBase(){
    11111111
    1112         int meshtype;
    1113         this->parameters->FindParam(&meshtype,MeshTypeEnum);
    1114         switch(meshtype){
     1112        int meshxdim;
     1113        this->parameters->FindParam(&meshxdim,MeshXDimEnum);
     1114        switch(meshxdim){
    11151115                case Mesh2DverticalEnum:
    11161116                        return HasEdgeOnBase();
    11171117                case Mesh2DhorizontalEnum:
    11181118                        return true;
    1119                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1119                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    11201120        }
    11211121}
    … …  
    11241124bool Tria::IsOnSurface(){
    11251125
    1126         int meshtype;
    1127         this->parameters->FindParam(&meshtype,MeshTypeEnum);
    1128         switch(meshtype){
     1126        int meshxdim;
     1127        this->parameters->FindParam(&meshxdim,MeshXDimEnum);
     1128        switch(meshxdim){
    11291129                case Mesh2DverticalEnum:
    11301130                        return HasEdgeOnSurface();
    11311131                case Mesh2DhorizontalEnum:
    11321132                        return true;
    1133                 default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     1133                default: _error_("mesh "<<EnumToStringx(meshxdim)<<" not supported yet");
    11341134        }
    11351135}
    … …  
    17881788
    17891789        int index1,index2;
    1790         int meshtype;
    1791 
    1792         this->parameters->FindParam(&meshtype,MeshTypeEnum);
    1793         switch(meshtype){
     1790        int meshxdim;
     1791
     1792        this->parameters->FindParam(&meshxdim,MeshXDimEnum);
     1793        switch(meshxdim){
    17941794                case Mesh2DhorizontalEnum:
    17951795                        return this;
    … …  
    18071807
    18081808        int index1,index2;
    1809         int meshtype;
    1810 
    1811         this->parameters->FindParam(&meshtype,MeshTypeEnum);
    1812         switch(meshtype){
     1809        int meshxdim;
     1810
     1811        this->parameters->FindParam(&meshxdim,MeshXDimEnum);
     1812        switch(meshxdim){
    18131813                case Mesh2DhorizontalEnum:
    18141814                        return this;
    … …  
    21662166
    21672167        /*Return: */
    2168         int meshtype;
    2169         parameters->FindParam(&meshtype,MeshTypeEnum);
    2170         if(meshtype==Mesh2DverticalEnum){
     2168        int meshxdim;
     2169        parameters->FindParam(&meshxdim,MeshXDimEnum);
     2170        if(meshxdim==Mesh2DverticalEnum){
    21712171          return base;
    21722172        }
    … …  
    22102210IssmDouble Tria::MassFlux( IssmDouble x1, IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){
    22112211
    2212         int        meshtype;
     2212        int        meshxdim;
    22132213        IssmDouble mass_flux=0.;
    22142214        IssmDouble xyz_list[NUMVERTICES][3];
    … …  
    22412241
    22422242        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    2243         this->parameters->FindParam(&meshtype,MeshTypeEnum);
     2243        this->parameters->FindParam(&meshxdim,MeshXDimEnum);
    22442244        Input* vx_input=NULL;
    22452245        Input* vy_input=NULL;
    2246         if(meshtype==Mesh2DhorizontalEnum){
     2246        if(meshxdim==Mesh2DhorizontalEnum){
    22472247                vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    22482248                vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    22742274IssmDouble Tria::MassFlux( IssmDouble* segment){
    22752275
    2276         int        meshtype;
     2276        int        meshxdim;
    22772277        IssmDouble mass_flux=0.;
    22782278        IssmDouble xyz_list[NUMVERTICES][3];
    … …  
    23082308
    23092309        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    2310         this->parameters->FindParam(&meshtype,MeshTypeEnum);
     2310        this->parameters->FindParam(&meshxdim,MeshXDimEnum);
    23112311        Input* vx_input=NULL;
    23122312        Input* vy_input=NULL;
    2313         if(meshtype==Mesh2DhorizontalEnum){
     2313        if(meshxdim==Mesh2DhorizontalEnum){
    23142314                vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    23152315                vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);

  • issm/trunk-jpl/src/c/classes/IoModel.cpp

    r17660 r17674  
    3030        this->my_vertices=NULL;
    3131
    32         this->meshtype=-1;
     32        this->meshxdim=-1;
    3333        this->numberofvertices=-1;
    3434        this->numberofelements=-1;
    … …  
    7575        this->my_vertices = NULL;
    7676
    77         FetchData(&this->meshtype,MeshTypeEnum);
     77        FetchData(&this->meshxdim,MeshXDimEnum);
    7878        FetchData(&this->numberofvertices,MeshNumberofverticesEnum);
    7979        FetchData(&this->numberofelements,MeshNumberofelementsEnum);

  • issm/trunk-jpl/src/c/classes/IoModel.h

    r17122 r17674  
    3131
    3232                /*Mesh properties and connectivity tables*/
    33                 int  meshtype;
     33                int  meshxdim;
    3434                int  numberofvertices;
    3535                int  numberofelements;

  • issm/trunk-jpl/src/c/classes/Node.cpp

    r17610 r17674  
    4343
    4444        Analysis* analysis = EnumToAnalysis(analysis_enum);
    45         int numdofs        = analysis->DofsPerNode(&doftypes,iomodel->meshtype,in_approximation);
     45        int numdofs        = analysis->DofsPerNode(&doftypes,iomodel->meshxdim,in_approximation);
    4646        indexing.Init(numdofs,doftypes);
    4747        xDelete<int>(doftypes);
    … …  
    6161                _assert_(sqrt( coord_system[0][0]*coord_system[0][0] + coord_system[1][0]*coord_system[1][0]) >1.e-4);
    6262
    63                 if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     63                if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    6464                        /*We have a  3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    6565                        _assert_(iomodel->Data(MeshVertexonbaseEnum));
    … …  
    101101                                analysis_enum==ExtrapolationAnalysisEnum
    102102                                ){
    103                 if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     103                if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    104104                        /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    105105                        _assert_(iomodel->Data(MeshVertexonbaseEnum));
    … …  
    112112                                analysis_enum==FreeSurfaceTopAnalysisEnum
    113113                                ){
    114                 if(iomodel->meshtype!=Mesh2DhorizontalEnum){
     114                if(iomodel->meshxdim!=Mesh2DhorizontalEnum){
    115115                        /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    116116                        _assert_(iomodel->Data(MeshVertexonsurfaceEnum));

  • issm/trunk-jpl/src/c/classes/Vertex.cpp

    r17555 r17674  
    3232        this->y            = iomodel->Data(MeshYEnum)[i];
    3333        this->z            = iomodel->Data(MeshZEnum)[i];
    34         this->meshtype     = iomodel->meshtype;
     34        this->meshxdim     = iomodel->meshxdim;
    3535
    3636        _assert_(iomodel->Data(BaseEnum) && iomodel->Data(ThicknessEnum) && iomodel->numbernodetoelementconnectivity);
    37         switch(iomodel->meshtype){
     37        switch(iomodel->meshxdim){
    3838                case Mesh3DEnum:
    3939                case Mesh2DhorizontalEnum:
    … …  
    132132
    133133        /*sigma remains constant. z=bed+sigma*thickness*/
    134         switch(this->meshtype){
     134        switch(this->meshxdim){
    135135                case Mesh2DhorizontalEnum:
    136136                        /*Nothing*/

  • issm/trunk-jpl/src/c/classes/Vertex.h

    r16447 r17674  
    2121        public:
    2222                bool       clone;
    23                 int        meshtype;
     23                int        meshxdim;
    2424                int        id;           // random index
    2525                int        sid;          // "serial" id (rank of this vertex if the dataset was on 1 cpu)

  • issm/trunk-jpl/src/c/cores/bedslope_core.cpp

    r16529 r17674  
    1414        /*parameters: */
    1515        bool save_results;
    16         int  meshtype;
     16        int  meshxdim;
    1717
    1818        /*Recover some parameters: */
    1919        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    20         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     20        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    2121
    2222        if(VerboseSolution()) _printf0_("   computing slope\n");
    … …  
    2828        solutionsequence_linear(femmodel);
    2929
    30         if(meshtype!=Mesh2DverticalEnum){
     30        if(meshxdim!=Mesh2DverticalEnum){
    3131                femmodel->parameters->SetParam(BedSlopeYEnum,InputToL2ProjectEnum);
    3232                solutionsequence_linear(femmodel);
    … …  
    3535        if(save_results){
    3636                if(VerboseSolution()) _printf0_("   saving results\n");
    37                 if(meshtype!=Mesh2DverticalEnum){
     37                if(meshxdim!=Mesh2DverticalEnum){
    3838                        int outputs[2] = {BedSlopeXEnum,BedSlopeYEnum};
    3939                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2);

  • issm/trunk-jpl/src/c/cores/levelsetfunctionslope_core.cpp

    r17274 r17674  
    1414        /*parameters: */
    1515        bool save_results;
    16         int  meshtype;
     16        int  meshxdim;
    1717
    1818        /*Recover some parameters: */
    1919        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    20         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     20        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    2121
    2222        if(VerboseSolution()) _printf0_("computing slope of levelset function...\n");
    … …  
    2828        solutionsequence_linear(femmodel);
    2929
    30         if(meshtype!=Mesh2DverticalEnum){
     30        if(meshxdim!=Mesh2DverticalEnum){
    3131                femmodel->parameters->SetParam(LevelsetfunctionSlopeYEnum,InputToL2ProjectEnum);
    3232                solutionsequence_linear(femmodel);
    3333        }
    34         if(meshtype==Mesh2DverticalEnum){
     34        if(meshxdim==Mesh2DverticalEnum){
    3535              femmodel->parameters->SetParam(LevelsetfunctionSlopeXEnum,InputToExtrudeEnum);
    3636                extrudefrombase_core(femmodel);
    … …  
    3939        if(save_results){
    4040                if(VerboseSolution()) _printf0_("saving results:\n");
    41                 if(meshtype!=Mesh2DverticalEnum){
     41                if(meshxdim!=Mesh2DverticalEnum){
    4242                        int outputs[2] = {LevelsetfunctionSlopeXEnum,LevelsetfunctionSlopeYEnum};
    4343                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2);

  • issm/trunk-jpl/src/c/cores/masstransport_core.cpp

    r17555 r17674  
    1414        /*parameters: */
    1515        int    i;
    16         int    numoutputs,meshtype;
     16        int    numoutputs,meshxdim;
    1717        bool   save_results;
    1818        bool   issmbgradients,ispdd,isdelta18o,isFS,isfreesurface,dakota_analysis;
    … …  
    2929        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    3030        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    31         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     31        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    3232        femmodel->parameters->FindParam(&numoutputs,MasstransportNumRequestedOutputsEnum);
    3333        if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,MasstransportRequestedOutputsEnum);
    … …  
    4848                femmodel->SetCurrentConfiguration(FreeSurfaceBaseAnalysisEnum);
    4949                solutionsequence_linear(femmodel);
    50                 if(meshtype!=Mesh2DhorizontalEnum){
     50                if(meshxdim!=Mesh2DhorizontalEnum){
    5151                        femmodel->parameters->SetParam(BaseEnum,InputToExtrudeEnum);
    5252                        extrudefrombase_core(femmodel);
    … …  
    5454                femmodel->SetCurrentConfiguration(FreeSurfaceTopAnalysisEnum);
    5555                solutionsequence_linear(femmodel);
    56                 if(meshtype!=Mesh2DhorizontalEnum){
     56                if(meshxdim!=Mesh2DhorizontalEnum){
    5757                        femmodel->parameters->SetParam(SurfaceEnum,InputToExtrudeEnum);
    5858                        extrudefromtop_core(femmodel);
    … …  
    6262                if(VerboseSolution()) _printf0_("   call computational core\n");
    6363                solutionsequence_linear(femmodel);
    64                 if(meshtype==Mesh2DverticalEnum){
     64                if(meshxdim==Mesh2DverticalEnum){
    6565                        femmodel->parameters->SetParam(ThicknessEnum,InputToExtrudeEnum);
    6666                        extrudefrombase_core(femmodel);

  • issm/trunk-jpl/src/c/cores/stressbalance_core.cpp

    r17322 r17674  
    1515        /*parameters: */
    1616        bool       dakota_analysis;
    17         int        meshtype;
     17        int        meshxdim;
    1818        bool       isSIA,isSSA,isL1L2,isHO,isFS;
    1919        bool       save_results;
    … …  
    2424
    2525        /* recover parameters:*/
    26         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     26        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    2727        femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum);
    2828        femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum);
    … …  
    4040                InputDuplicatex(femmodel,QmuVxEnum,VxEnum);
    4141                InputDuplicatex(femmodel,QmuVyEnum,VyEnum);
    42                 if(meshtype==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
     42                if(meshxdim==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
    4343                if(isFS) InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum);
    4444        }
    4545
    4646        /*Compute slopes if necessary */
    47         if(isSIA || (isFS && meshtype==Mesh2DverticalEnum)) surfaceslope_core(femmodel);
     47        if(isSIA || (isFS && meshxdim==Mesh2DverticalEnum)) surfaceslope_core(femmodel);
    4848        if(isFS){
    4949                bedslope_core(femmodel);
    … …  
    7474
    7575        /*Compute vertical velocities*/
    76         if (meshtype==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){
     76        if (meshxdim==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){
    7777                analysis = new StressbalanceVerticalAnalysis();
    7878                analysis->Core(femmodel);

  • issm/trunk-jpl/src/c/cores/surfaceslope_core.cpp

    r17511 r17674  
    1414        /*parameters: */
    1515        bool save_results;
    16         int  meshtype;
     16        int  meshxdim;
    1717
    1818        /*Recover some parameters: */
    1919        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    20         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     20        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    2121
    2222        if(VerboseSolution()) _printf0_("computing slope...\n");
    … …  
    2828        solutionsequence_linear(femmodel);
    2929
    30         if(meshtype!=Mesh2DverticalEnum){
     30        if(meshxdim!=Mesh2DverticalEnum){
    3131                femmodel->parameters->SetParam(SurfaceSlopeYEnum,InputToL2ProjectEnum);
    3232                solutionsequence_linear(femmodel);
    3333        }
    34         if(meshtype==Mesh2DverticalEnum){
     34        if(meshxdim==Mesh2DverticalEnum){
    3535                femmodel->parameters->SetParam(SurfaceSlopeXEnum,InputToExtrudeEnum);
    3636                extrudefrombase_core(femmodel);
    … …  
    3939        if(save_results){
    4040                if(VerboseSolution()) _printf0_("saving results:\n");
    41                 if(meshtype!=Mesh2DverticalEnum){
     41                if(meshxdim!=Mesh2DverticalEnum){
    4242                        int outputs[2] = {SurfaceSlopeXEnum,SurfaceSlopeYEnum};
    4343                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2);

  • issm/trunk-jpl/src/c/cores/transient_core.cpp

    r17642 r17674  
    2626        bool   time_adapt=false;
    2727        int    output_frequency;
    28         int    meshtype,groundingline_migration,smb_model;
     28        int    meshxdim,groundingline_migration,smb_model;
    2929        int    numoutputs         = 0;
    3030  Analysis *analysis = NULL;
    … …  
    3737
    3838        //first recover parameters common to all solutions
    39         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     39        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    4040        femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    4141        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    … …  
    6666                        InputDuplicatex(femmodel,QmuVxEnum,VxEnum);
    6767                        InputDuplicatex(femmodel,QmuVyEnum,VyEnum);
    68                         if(meshtype==Mesh3DEnum){
     68                        if(meshxdim==Mesh3DEnum){
    6969                                InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
    7070                                if(isFS)InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum);
    … …  
    7878                }
    7979                if(isgroundingline) InputDuplicatex(femmodel,QmuMaskGroundediceLevelsetEnum,MaskGroundediceLevelsetEnum);
    80                 if(isthermal && meshtype==Mesh3DEnum){
     80                if(isthermal && meshxdim==Mesh3DEnum){
    8181                        //Update Vertex Position after updating Thickness and Bed
    8282                        femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum);
    … …  
    114114                femmodel->parameters->SetParam(save_results,SaveResultsEnum);
    115115
    116                 if(isthermal && meshtype==Mesh3DEnum){
     116                if(isthermal && meshxdim==Mesh3DEnum){
    117117                        if(VerboseSolution()) _printf0_("   computing thermal regime\n");
    118118                        thermal_core(femmodel);

  • issm/trunk-jpl/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp

    r17561 r17674  
    5151                        break;
    5252                case P1bubbleEnum:
    53                         switch(iomodel->meshtype){
     53                        switch(iomodel->meshxdim){
    5454                                case Mesh2DhorizontalEnum: elementnbv = 3; break;
    5555                                case Mesh2DverticalEnum:   elementnbv = 3; break;
    … …  
    7373                case P2Enum:
    7474                        EdgesPartitioning(&my_edges,iomodel);
    75               if(iomodel->meshtype==Mesh3DEnum){
     75              if(iomodel->meshxdim==Mesh3DEnum){
    7676                                FacesPartitioning(&my_faces,iomodel);
    7777                        }
    … …  
    118118                                        }
    119119                                }
    120                                 if(iomodel->meshtype==Mesh3DEnum){
     120                                if(iomodel->meshxdim==Mesh3DEnum){
    121121                                        for(i=0;i<iomodel->numberoffaces;i++){
    122122                                                if(iomodel->faces[i*6+5]==2){/*Vertical quads*/

  • issm/trunk-jpl/src/c/modules/MeshPartitionx/MeshPartitionx.h

    r17472 r17674  
    1111template <class doubletype>
    1212int MeshPartitionx(int** pepart, int** pnpart, int numberofelements,int numberofnodes,int* elements,
    13                 int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int meshtype,int num_procs){
     13                int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int meshxdim,int num_procs){
    1414
    1515        int noerr=1;
    … …  
    3131        int  edgecut=1;
    3232
    33         switch(meshtype){
     33        switch(meshxdim){
    3434                case Mesh2DhorizontalEnum:
    3535                case Mesh2DverticalEnum:
    … …  
    111111                        break;
    112112                default:
    113                         _error_("mesh type "<<EnumToStringx(meshtype)<<" not supported yet");
     113                        _error_("mesh type "<<EnumToStringx(meshxdim)<<" not supported yet");
    114114        }
    115115

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateEdges.cpp

    r17490 r17674  
    2323
    2424        /*Mesh dependent variables*/
    25         if(iomodel->meshtype==Mesh2DhorizontalEnum){
     25        if(iomodel->meshxdim==Mesh2DhorizontalEnum){
    2626                elementnbv = 3;
    2727                elementnbe = 3;
    … …  
    3232                elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1;
    3333        }
    34         else if(iomodel->meshtype==Mesh2DverticalEnum){
     34        else if(iomodel->meshxdim==Mesh2DverticalEnum){
    3535                elementnbv = 3;
    3636                elementnbe = 3;
    … …  
    4141                elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1;
    4242        }
    43         else if(iomodel->meshtype==Mesh3DtetrasEnum){
     43        else if(iomodel->meshxdim==Mesh3DtetrasEnum){
    4444                elementnbv = 4;
    4545                elementnbe = 6;
    … …  
    5353                elementedges[2*5+0] = 2; elementedges[2*5+1] = 3; elementedges_markers[5] = 1;
    5454        }
    55         else if(iomodel->meshtype==Mesh3DEnum){
     55        else if(iomodel->meshxdim==Mesh3DEnum){
    5656                elementnbv = 6;
    5757                elementnbe = 9;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp

    r17555 r17674  
    2626        /*Create elements*/
    2727        if(control_analysis)iomodel->FetchData(3,InversionControlParametersEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
    28         switch(iomodel->meshtype){
     28        switch(iomodel->meshxdim){
    2929                case Mesh2DhorizontalEnum:
    3030                        for(i=0;i<iomodel->numberofelements;i++){
    … …  
    5959                        iomodel->FetchDataToInput(elements,DamageDEnum);
    6060                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    61                         switch(iomodel->meshtype){
     61                        switch(iomodel->meshxdim){
    6262                                case Mesh2DhorizontalEnum: case Mesh2DverticalEnum:
    6363                                        elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateFaces.cpp

    r17561 r17674  
    1717
    1818        /*Check Iomodel properties*/
    19         if(iomodel->meshtype==Mesh2DhorizontalEnum || iomodel->meshtype==Mesh2DverticalEnum){
     19        if(iomodel->meshxdim==Mesh2DhorizontalEnum || iomodel->meshxdim==Mesh2DverticalEnum){
    2020                /*Keep going*/
    2121        }
    22         else if(iomodel->meshtype==Mesh3DEnum){
     22        else if(iomodel->meshxdim==Mesh3DEnum){
    2323                CreateFaces3d(iomodel);
    2424                return;
    … …  
    144144
    145145        /*Mesh specific face indexing per element*/
    146         if(iomodel->meshtype==Mesh3DEnum){
     146        if(iomodel->meshxdim==Mesh3DEnum){
    147147                elementnbv = 6; /*Number of vertices per element*/
    148148                elementnbf = 5; /*Number of faces per element*/
    … …  
    243243
    244244        int numbervertices;
    245         if(iomodel->meshtype==Mesh3DEnum){
     245        if(iomodel->meshxdim==Mesh3DEnum){
    246246                if((iomodel->faces[6*facenumber+5])==1){
    247247                        numbervertices=3;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNodes.cpp

    r17525 r17674  
    144144                        }
    145145                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    146               if(iomodel->meshtype==Mesh3DEnum){
     146              if(iomodel->meshxdim==Mesh3DEnum){
    147147                                FacesPartitioning(&my_faces,iomodel);
    148148                                for(i=0;i<iomodel->numberoffaces;i++){
    … …  
    309309                        }
    310310                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    311               if(iomodel->meshtype==Mesh3DEnum){
     311              if(iomodel->meshxdim==Mesh3DEnum){
    312312                                FacesPartitioning(&my_faces,iomodel);
    313313                                for(i=0;i<iomodel->numberoffaces;i++){
    … …  
    328328
    329329                        /*P1 pressure*/
    330               if(iomodel->meshtype==Mesh3DEnum){
     330              if(iomodel->meshxdim==Mesh3DEnum){
    331331                                numberoffaces=iomodel->numberoffaces;
    332332                        }

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp

    r17472 r17674  
    3636
    3737        /*Get element width*/
    38         switch(iomodel->meshtype){
     38        switch(iomodel->meshxdim){
    3939                case Mesh2DhorizontalEnum: elementswidth=3; break;
    4040                case Mesh2DverticalEnum:   elementswidth=3; break;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp

    r17642 r17674  
    1919
    2020        int         i,j,m,k;
    21         int         numoutputs,meshtype,smb_model;
     21        int         numoutputs,meshxdim,smb_model;
    2222        char**      requestedoutputs = NULL;
    2323        IssmDouble  time;
    … …  
    4141
    4242        /*Copy some constants from iomodel */
    43         parameters->AddObject(iomodel->CopyConstantObject(MeshTypeEnum));
     43        parameters->AddObject(iomodel->CopyConstantObject(MeshXDimEnum));
    4444        parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum));
    4545        parameters->AddObject(iomodel->CopyConstantObject(SteadystateReltolEnum));
    … …  
    8484        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceReltolEnum));
    8585        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceAbstolEnum));
    86         if(iomodel->meshtype==Mesh3DEnum)
     86        if(iomodel->meshxdim==Mesh3DEnum)
    8787         parameters->AddObject(iomodel->CopyConstantObject(MeshNumberoflayersEnum));
    8888

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp

    r16637 r17674  
    3030
    3131        /*Get element width (3 or 6)*/
    32         switch(iomodel->meshtype){
     32        switch(iomodel->meshxdim){
    3333                case Mesh2DhorizontalEnum: elementswidth=3; break;
    3434                case Mesh2DverticalEnum  : elementswidth=3; break;
    3535                case Mesh3DEnum          : elementswidth=6; break;
    36                 default:  _error_("mesh type "<<EnumToStringx(iomodel->meshtype)<<" not supported yet");
     36                default:  _error_("mesh type "<<EnumToStringx(iomodel->meshxdim)<<" not supported yet");
    3737        }
    3838

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/EdgesPartitioning.cpp

    r17490 r17674  
    1818
    1919        /*Mesh dependent variables*/
    20         if(iomodel->meshtype==Mesh2DhorizontalEnum){
     20        if(iomodel->meshxdim==Mesh2DhorizontalEnum){
    2121                elementnbe = 3;
    2222        }
    23         else if(iomodel->meshtype==Mesh2DverticalEnum){
     23        else if(iomodel->meshxdim==Mesh2DverticalEnum){
    2424                elementnbe = 3;
    2525        }
    26         else if(iomodel->meshtype==Mesh3DtetrasEnum){
     26        else if(iomodel->meshxdim==Mesh3DtetrasEnum){
    2727                elementnbe = 6;
    2828        }
    29         else if(iomodel->meshtype==Mesh3DEnum){
     29        else if(iomodel->meshxdim==Mesh3DEnum){
    3030                elementnbe = 9;
    3131        }

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp

    r17487 r17674  
    5151        /*Number of vertices per elements, needed to correctly retrieve data: */
    5252        /*Determine parallel partitioning of elements: we use Metis for now. First load the data, then partition*/
    53         switch(iomodel->meshtype){
     53        switch(iomodel->meshxdim){
    5454                case Mesh2DhorizontalEnum:
    5555                        elements_width=3;
    … …  
    8181        }
    8282
    83         MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->meshtype,num_procs);
     83        MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->meshxdim,num_procs);
    8484
    8585        /*Free elements2d: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/FacesPartitioning.cpp

    r17122 r17674  
    1818
    1919        /*Mesh dependent variables*/
    20         if(iomodel->meshtype==Mesh2DhorizontalEnum){
     20        if(iomodel->meshxdim==Mesh2DhorizontalEnum){
    2121                elementnbf = 3;
    2222        }
    23         else if(iomodel->meshtype==Mesh2DverticalEnum){
     23        else if(iomodel->meshxdim==Mesh2DverticalEnum){
    2424                elementnbf = 3;
    2525        }
    26         else if(iomodel->meshtype==Mesh3DEnum){
     26        else if(iomodel->meshxdim==Mesh3DEnum){
    2727                elementnbf = 5;
    2828        }

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp

    r17642 r17674  
    5959
    6060                /*Hack for trasient runs (FIXME: to be improved)*/
    61                 if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
    62                 if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
    63                 if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
     61                if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum  && iomodel->meshxdim==Mesh2DhorizontalEnum) continue;
     62                if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum  && iomodel->meshxdim==Mesh2DhorizontalEnum) continue;
     63                if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->meshxdim==Mesh2DhorizontalEnum) continue;
    6464                if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum && isthermal==false) continue;
    6565                if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum && isthermal==false) continue;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

    r16291 r17674  
    6565
    6666        /*First: add all the nodes of all the elements belonging to this cpu*/
    67         if(iomodel->meshtype==Mesh2DhorizontalEnum){
     67        if(iomodel->meshxdim==Mesh2DhorizontalEnum){
    6868                for (i=0;i<iomodel->numberofelements;i++){
    6969                        if (my_elements[i]){

  • issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp

    r17610 r17674  
    1515        /* intermediaries */
    1616        bool solvein2d=false;
    17         int i,in,meshtype,analysis_type;
     17        int i,in,meshxdim,analysis_type;
    1818        Elements* elements = femmodel->elements;
    1919
    2020        /* find parameters */
    21         femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
     21        femmodel->parameters->FindParam(&meshxdim,MeshXDimEnum);
    2222
    2323        for(i=0;i<elements->Size();i++){
    … …  
    5050
    5151                /* if solving 2d problem on vertically extende mesh, solve on basal layer only*/
    52                 if(meshtype!=Mesh2DhorizontalEnum){
     52                if(meshxdim!=Mesh2DhorizontalEnum){
    5353                        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    5454                        if(

  • issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

    r17651 r17674  
    211211        MeshYEnum,
    212212        MeshZEnum,
     213        MeshXDimEnum,
     214        MeshDimEnum,
    213215        MeshTypeEnum,
    214216        Mesh2DhorizontalEnum,

  • issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

    r17651 r17674  
    219219                case MeshYEnum : return "MeshY";
    220220                case MeshZEnum : return "MeshZ";
     221                case MeshXDimEnum : return "MeshXDim";
     222                case MeshDimEnum : return "MeshDim";
    221223                case MeshTypeEnum : return "MeshType";
    222224                case Mesh2DhorizontalEnum : return "Mesh2Dhorizontal";

  • issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

    r17651 r17674  
    222222              else if (strcmp(name,"MeshY")==0) return MeshYEnum;
    223223              else if (strcmp(name,"MeshZ")==0) return MeshZEnum;
     224              else if (strcmp(name,"MeshXDim")==0) return MeshXDimEnum;
     225              else if (strcmp(name,"MeshDim")==0) return MeshDimEnum;
    224226              else if (strcmp(name,"MeshType")==0) return MeshTypeEnum;
    225227              else if (strcmp(name,"Mesh2Dhorizontal")==0) return Mesh2DhorizontalEnum;
    … …  
    258260              else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum;
    259261              else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum;
    260               else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;
    261               else if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum;
    262262         else stage=3;
    263263   }
    264264   if(stage==3){
    265               if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum;
     265              if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;
     266              else if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum;
     267              else if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum;
    266268              else if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum;
    267269              else if (strcmp(name,"SteadystateReltol")==0) return SteadystateReltolEnum;
    … …  
    381383              else if (strcmp(name,"FSpressure")==0) return FSpressureEnum;
    382384              else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    383               else if (strcmp(name,"Loads")==0) return LoadsEnum;
    384               else if (strcmp(name,"Materials")==0) return MaterialsEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"Nodes")==0) return NodesEnum;
     388              if (strcmp(name,"Loads")==0) return LoadsEnum;
     389              else if (strcmp(name,"Materials")==0) return MaterialsEnum;
     390              else if (strcmp(name,"Nodes")==0) return NodesEnum;
    389391              else if (strcmp(name,"Contours")==0) return ContoursEnum;
    390392              else if (strcmp(name,"Parameters")==0) return ParametersEnum;
    … …  
    504506              else if (strcmp(name,"VxPicard")==0) return VxPicardEnum;
    505507              else if (strcmp(name,"VyAverage")==0) return VyAverageEnum;
    506               else if (strcmp(name,"Vy")==0) return VyEnum;
    507               else if (strcmp(name,"VyPicard")==0) return VyPicardEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"Vz")==0) return VzEnum;
     511              if (strcmp(name,"Vy")==0) return VyEnum;
     512              else if (strcmp(name,"VyPicard")==0) return VyPicardEnum;
     513              else if (strcmp(name,"Vz")==0) return VzEnum;
    512514              else if (strcmp(name,"VzSSA")==0) return VzSSAEnum;
    513515              else if (strcmp(name,"VzHO")==0) return VzHOEnum;
    … …  
    627629              else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum;
    628630              else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum;
    629               else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;
    630               else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;
    631631         else stage=6;
    632632   }
    633633   if(stage==6){
    634               if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
     634              if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;
     635              else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;
     636              else if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
    635637              else if (strcmp(name,"Adjoint")==0) return AdjointEnum;
    636638              else if (strcmp(name,"Colinear")==0) return ColinearEnum;

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m

    r17071 r17674  
    3838
    3939%First find segments that are not completely on the front
    40 if strcmp(meshtype(md.mesh),'3D'),
     40if strcmp(meshtype(md.mesh),'Penta'),
    4141        numbernodesfront=4;
    42 elseif strcmp(meshtype(md.mesh),'2Dhorizontal'),
     42elseif strcmp(meshtype(md.mesh),'Tria'),
    4343        numbernodesfront=2;
    4444else

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py

    r17480 r17674  
    4444
    4545        #First find segments that are not completely on the front
    46         if m.strcmp(md.mesh.meshtype(),'3D'):
     46        if m.strcmp(md.mesh.meshtype(),'Penta'):
    4747                numbernodesfront=4;
    48         elif m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     48        elif m.strcmp(md.mesh.meshtype(),'Tria'):
    4949                numbernodesfront=2;
    5050        else:

  • issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m

    r17475 r17674  
    5252
    5353%First find segments that are not completely on the front
    54 if ~strcmp(md.mesh.meshtype(),'3D'),
     54if ~strcmp(md.mesh.meshxdim(),'3D'),
    5555        numbernodesfront=2;
    5656else

  • issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py

    r17480 r17674  
    5353
    5454        #First find segments that are not completely on the front
    55         if not m.strcmp(md.mesh.meshtype(),'3D'):
     55        if not m.strcmp(md.mesh.meshxdim(),'3D'):
    5656                numbernodesfront=2
    5757        else:

  • issm/trunk-jpl/src/m/classes/damage.m

    r17644 r17674  
    117117                function list=defaultoutputs(self,md) % {{{
    118118
    119                         if strcmp(meshtype(md.mesh),'3D'),
    120                                 list = {'DamageD',};
    121                         elseif strcmp(meshtype(md.mesh),'2Dhorizontal'),
    122                                 list = {'DamageD'};
    123                         elseif strcmp(meshtype(md.mesh),'2Dvertical'),
    124                                 list = {'DamageD'};
    125                         else
    126                                 error('mesh type not supported yet');
    127                         end
     119                        list = {'DamageD'};
    128120
    129121                end % }}}

  • issm/trunk-jpl/src/m/classes/damage.py

    r17632 r17674  
    110110        def defaultoutputs(self,md): # {{{
    111111
    112                 if m.strcmp(md.mesh.meshtype(),'3D'):
    113                         list = ['DamageD']
    114                 elif m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
    115                         list = ['DamageD']
    116                 elif m.strcmp(md.mesh.meshtype(),'2Dvertical'):
    117                         list = ['DamageD']
    118                 else:
    119                         raise TypeError('mesh type not supported yet')
     112                list = ['DamageD']
    120113                return list
    121114

  • issm/trunk-jpl/src/m/classes/flowequation.m

    r17659 r17674  
    9595                                md = checkfield(md,'fieldname','flowequation.borderHO','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    9696                                md = checkfield(md,'fieldname','flowequation.borderFS','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    97                                 if strcmp(meshtype(md.mesh),'2Dhorizontal')
     97                                if strcmp(meshxdim(md.mesh),'2Dhorizontal')
    9898                                        md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[1:2]);
    9999                                        md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[1:2]);
    100                                 elseif strcmp(meshtype(md.mesh),'2Dvertical')
     100                                elseif strcmp(meshxdim(md.mesh),'2Dvertical')
    101101                                        md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[2:4]);
    102102                                        md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[2:4]);
    103                                 elseif strcmp(meshtype(md.mesh),'3D'),
     103                                elseif strcmp(meshxdim(md.mesh),'3D'),
    104104                                        md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[0:8]);
    105105                                        md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[0:8]);

  • issm/trunk-jpl/src/m/classes/flowequation.py

    r17659 r17674  
    8484                        md = checkfield(md,'fieldname','flowequation.XTH_r','numel',[1],'>',0.)
    8585                        md = checkfield(md,'fieldname','flowequation.XTH_theta','numel',[1],'>=',0.,'<',.5)
    86                         if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     86                        if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'):
    8787                                md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',[1,2])
    8888                                md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements],'values',[1,2])
    89                         elif m.strcmp(md.mesh.meshtype(),'3D'):
     89                        elif m.strcmp(md.mesh.meshxdim(),'3D'):
    9090                                md = checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',numpy.arange(0,8+1))
    9191                                md = checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements],'values',numpy.arange(0,8+1))

  • issm/trunk-jpl/src/m/classes/initialization.m

    r17523 r17674  
    5252                                md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
    5353                                md = checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
    54                                 if strcmp(meshtype(md.mesh),'3D')
     54                                if meshdim(md.mesh)==3
    5555                                        md = checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices 1]);
    5656                                end

  • issm/trunk-jpl/src/m/classes/initialization.py

    r17480 r17674  
    6666                        md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
    6767                        md = checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])
    68                         if m.strcmp(md.mesh.meshtype(),'3D'):
     68                        if md.mesh.meshdim()==3:
    6969                                md = checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices])
    7070                        md = checkfield(md,'fieldname','initialization.pressure','NaN',1,'size',[md.mesh.numberofvertices])

  • issm/trunk-jpl/src/m/classes/mesh2d.m

    r17562 r17674  
    105105                end % }}}
    106106                function marshall(obj,md,fid) % {{{
    107                         WriteData(fid,'enum',MeshTypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');
     107                        WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer');
    108108                        WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
    109109                        WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
    … …  
    114114                        WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
    115115                end % }}}
    116                 function t = meshtype(obj) % {{{
     116                function t = meshxdim(obj) % {{{
    117117                        t = '2Dhorizontal';
     118                end % }}}
     119                function d = meshdim(obj) % {{{
     120                        d = 2;
     121                end % }}}
     122                function s = meshtype(obj) % {{{
     123                        s = 'Tria';
    118124                end % }}}
    119125        end

  • issm/trunk-jpl/src/m/classes/mesh2d.py

    r17562 r17674  
    9898                return md
    9999        # }}}
    100         def meshtype(self): # {{{
     100        def meshxdim(self): # {{{
    101101                return "2Dhorizontal"
    102102        #}}}
     103        def meshdim(self): # {{{
     104                return 2
     105        #}}}
     106        def meshtype(self): # {{{
     107                return "Tria"
     108        #}}}
    103109        def marshall(self,md,fid):    # {{{
    104                 WriteData(fid,'enum',MeshTypeEnum(),'data',StringToEnum("Mesh"+self.meshtype())[0],'format','Integer');
     110                WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum("Mesh"+self.meshxdim())[0],'format','Integer');
    105111                WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1)
    106112                WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1)

  • issm/trunk-jpl/src/m/classes/mesh2dvertical.m

    r17610 r17674  
    104104                end % }}}
    105105                function marshall(obj,md,fid) % {{{
    106                         WriteData(fid,'enum',MeshTypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');
     106                        WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer');
    107107                        WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
    108108                        WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
    … …  
    115115                        WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
    116116                end % }}}
    117                 function t = meshtype(obj) % {{{
     117                function t = meshxdim(obj) % {{{
    118118                        t = '2Dvertical';
     119                end % }}}
     120                function d = meshdim(obj) % {{{
     121                        d = 2;
     122                end % }}}
     123                function s = meshtype(obj) % {{{
     124                        s = 'Tria';
    119125                end % }}}
    120126                function flags = vertexflags(self,value) % {{{

  • issm/trunk-jpl/src/m/classes/mesh3dprisms.m

    r17610 r17674  
    135135                end % }}}
    136136                function marshall(obj,md,fid) % {{{
    137                         WriteData(fid,'enum',MeshTypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');
     137                        WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum(['Mesh' meshxdim(obj)]),'format','Integer');
    138138                        WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
    139139                        WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
    … …  
    154154                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer');
    155155                end % }}}
    156                 function type = meshtype(obj) % {{{
     156                function type = meshxdim(obj) % {{{
    157157                        type = '3D';
     158                end % }}}
     159                function d = meshdim(obj) % {{{
     160                        d = 3;
     161                end % }}}
     162                function s = meshtype(obj) % {{{
     163                        s = 'Penta';
    158164                end % }}}
    159165        end

  • issm/trunk-jpl/src/m/classes/mesh3dprisms.py

    r17610 r17674  
    130130                return md
    131131        # }}}
    132         def meshtype(self): # {{{
     132        def meshxdim(self): # {{{
    133133                return "3D"
    134134        #}}}
     135        def meshdim(self): # {{{
     136                return 3
     137        #}}}
     138        def meshtype(self): # {{{
     139                return "Penta"
     140        #}}}
    135141        def marshall(self,md,fid):    # {{{
    136                 WriteData(fid,'enum',MeshTypeEnum(),'data',StringToEnum("Mesh"+self.meshtype())[0],'format','Integer');
     142                WriteData(fid,'enum',MeshXDimEnum(),'data',StringToEnum("Mesh"+self.meshxdim())[0],'format','Integer');
    137143                WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1)
    138144                WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1)

  • issm/trunk-jpl/src/m/classes/mesh3dtetras.m

    r17610 r17674  
    129129                end % }}}
    130130                function marshall(obj,md,fid) % {{{
    131                         WriteData(fid,'enum',MeshTypeEnum(),'data',Mesh3DtetrasEnum,'format','Integer');
     131                        WriteData(fid,'enum',MeshXDimEnum(),'data',Mesh3DtetrasEnum,'format','Integer');
    132132                        WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
    133133                        WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
    … …  
    146146                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer');
    147147                end % }}}
    148                 function type = meshtype(obj) % {{{
    149                         type = '3D';
     148                function t = meshxdim(obj) % {{{
     149                        t = '3D';
     150                end % }}}
     151                function d = meshdim(obj) % {{{
     152                        d = 3;
     153                end % }}}
     154                function s = meshtype(obj) % {{{
     155                        s = 'Tetra';
    150156                end % }}}
    151157        end

  • issm/trunk-jpl/src/m/classes/model.m

    r17610 r17674  
    156156
    157157                        %Check that the model is really a 3d model
    158                         if ~strcmp(md.mesh.meshtype(),'3D'),
     158                        if ~strcmp(md.mesh.meshxdim(),'3D'),
    159159                                error('collapse error message: only 3d mesh can be collapsed')
    160160                        end
    … …  
    426426
    427427                        %Edges
    428                         if(strcmp(meshtype(md.mesh),'2Dhorizontal')),
     428                        if(meshdim(md.mesh)==2),
    429429                                if size(md2.mesh.edges,2)>1, %do not use ~isnan because there are some NaNs...
    430430                                        %renumber first two columns
    … …  
    608608                                error('number of layers should be at least 2');
    609609                        end
    610                         if strcmp(md.mesh.meshtype(),'3D')
     610                        if strcmp(md.mesh.meshxdim(),'3D')
    611611                                error('Cannot extrude a 3d mesh (extrude cannot be called more than once)');
    612612                        end

  • issm/trunk-jpl/src/m/classes/model.py

    r17610 r17674  
    327327
    328328                #Edges
    329                 if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     329                if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'):
    330330                        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...
    331331                                #renumber first two columns

  • issm/trunk-jpl/src/m/classes/modellist.m

    r17559 r17674  
    3232
    3333                        %2D or 3D?
    34                         if strcmp(meshtype(md.mesh),'3D'),
     34                        if meshdim(md.mesh)==3,
    3535                                numberofelements=md.mesh.numberofelements2d; %this will be forgotten when we get out.
    3636                                flags=project2d(md,flags,1);
    … …  
    8484                        for i=1:size(flag_list,1),
    8585                                disp(['   ' num2str(i) '/' num2str(size(flag_list,1))]);
    86                                 if strcmp(meshtype(md.mesh),'3D'),
     86                                if meshdim(md.mesh)==3,
    8787                                        flags2d=flag_list{i};
    8888                                        realflags=project3d(md,flags2d,'element');

  • issm/trunk-jpl/src/m/classes/rifts.m

    r17559 r17674  
    2828                        end
    2929                        if numrifts,
    30                                 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),
     30                                if ~(strcmp(meshxdim(md.mesh),'2Dhorizontal')),
    3131                                        md = checkmessage(md,['models with rifts are only supported in 2d for now!']);
    3232                                end

  • issm/trunk-jpl/src/m/classes/rifts.py

    r17563 r17674  
    4040
    4141                if numrifts:
    42                         if not m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     42                        if not m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'):
    4343                                md.checkmessage("models with rifts are only supported in 2d for now!")
    4444                        if not isinstance(self.riftstruct,list):

  • issm/trunk-jpl/src/m/classes/stressbalance.m

    r17610 r17674  
    112112                        end
    113113                        %CHECK THAT NO rotation specified for FS Grounded ice at base
    114                         if strcmp(meshtype(md.mesh),'3D') & md.flowequation.isFS,
     114                        if strcmp(meshxdim(md.mesh),'3D') & md.flowequation.isFS,
    115115                                pos=find(md.mask.groundedice_levelset>0. & md.mesh.vertexonbase);
    116116                                if any(~isnan(md.stressbalance.referential(pos,:))),
    … …  
    122122                function list=defaultoutputs(self,md) % {{{
    123123
    124                         if strcmp(meshtype(md.mesh),'3D'),
     124                        if meshdim(md.mesh)==3,
    125125                                list = {'Vx','Vy','Vz','Vel','Pressure'};
    126                         elseif strcmp(meshtype(md.mesh),'2Dhorizontal'),
    127                                 list = {'Vx','Vy','Vel','Pressure'};
    128                         elseif strcmp(meshtype(md.mesh),'2Dvertical'),
     126                        elseif meshdim(md.mesh)==2,
    129127                                list = {'Vx','Vy','Vel','Pressure'};
    130128                        else

  • issm/trunk-jpl/src/m/classes/stressbalance.py

    r17610 r17674  
    110110        def defaultoutputs(self,md): # {{{
    111111
    112                 if m.strcmp(md.mesh.meshtype(),'3D'):
     112                if md.mesh.meshdim==3:
    113113                        list = ['Vx','Vy','Vz','Vel','Pressure']
    114                 elif m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     114                else:
    115115                        list = ['Vx','Vy','Vel','Pressure']
    116                 elif m.strcmp(md.mesh.meshtype(),'2Dvertical'):
    117                         list = ['Vx','Vy','Vel','Pressure']
    118                 else:
    119                         raise TypeError('mesh type not supported yet');
    120116                return list
    121117
    … …  
    129125                md = checkfield(md,'fieldname','stressbalance.spcvx','forcing',1)
    130126                md = checkfield(md,'fieldname','stressbalance.spcvy','forcing',1)
    131                 if m.strcmp(md.mesh.meshtype(),'3D'):
     127                if m.strcmp(md.mesh.meshxdim(),'3D'):
    132128                        md = checkfield(md,'fieldname','stressbalance.spcvz','forcing',1)
    133129                md = checkfield(md,'fieldname','stressbalance.restol','size',[1],'>',0)
    … …  
    161157                                        md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
    162158                #CHECK THAT NO rotation specified for FS Grounded ice at base
    163                 if m.strcmp(md.mesh.meshtype(),'3D') and md.flowequation.isFS:
     159                if m.strcmp(md.mesh.meshxdim(),'3D') and md.flowequation.isFS:
    164160                        pos=numpy.nonzero(numpy.logical_and(md.mask.groundedice_levelset,md.mesh.vertexonbase))
    165161                        if numpy.any(numpy.logical_not(numpy.isnan(md.stressbalance.referential[pos,:]))):

  • issm/trunk-jpl/src/m/classes/thermal.m

    r17559 r17674  
    6464                        md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0 1 2]);
    6565                        md = checkfield(md,'fieldname','thermal.spctemperature','forcing',1);
    66                         if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & strcmp(meshtype(md.mesh),'3D')),
     66                        if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & meshdim(md.mesh)==3),
    6767                                pos=find(md.thermal.spctemperature(1:md.mesh.numberofvertices,:)~=NaN);
    6868                                replicate=repmat(md.geometry.surface-md.mesh.z,1,size(md.thermal.spctemperature,2));

  • issm/trunk-jpl/src/m/classes/thermal.py

    r17563 r17674  
    8282                md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0,1,2])
    8383                md = checkfield(md,'fieldname','thermal.spctemperature','forcing',1)
    84                 if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and m.strcmp(md.mesh.meshtype(),'3D'):
     84                if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and md.mesh.meshdim()==3:
    8585                        pos=numpy.nonzero(numpy.logical_not(numpy.isnan(md.thermal.spctemperature[0:md.mesh.numberofvertices])))
    8686                        replicate=numpy.tile(md.geometry.surface-md.mesh.z,(1,numpy.size(md.thermal.spctemperature,axis=1)))

  • issm/trunk-jpl/src/m/contrib/ecco/PropagateFlagsUntilDistance.m

    r17559 r17674  
    1010
    1111%make 3d work in 2d:
    12 if strcmp(meshtype(md.mesh),'3D'),
     12if strcmp(meshxdim(md.mesh),'3D'),
    1313        md.mesh.x=md.mesh.x2d;
    1414        md.mesh.y=md.mesh.y2d;

  • issm/trunk-jpl/src/m/contrib/hack/tres.m

    r17559 r17674  
    99
    1010if strcmpi(string,'stressbalance'),
    11         if strcmp(meshtype(md.mesh),'2Dhorizontal'),
     11        if strcmp(meshxdim(md.mesh),'2Dhorizontal'),
    1212                md.initialization.vx=md.results.StressbalanceSolution.Vx;
    1313                md.initialization.vy=md.results.StressbalanceSolution.Vy;

  • issm/trunk-jpl/src/m/contrib/massbalance/divergence.m

    r17559 r17674  
    55%      div=divergence(md,a,b)
    66
    7 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     7if (meshdim(md.mesh)==2),
    88        numberofelements=md.mesh.numberofelements;
    99        numberofnodes=md.mesh.numberofvertices;

  • issm/trunk-jpl/src/m/contrib/massbalance/outflux.m

    r17559 r17674  
    1616
    1717if nargin==1,
    18         if strcmp(meshtype(md.mesh),'3D'),
     18        if meshdim(md.mesh)==3,
    1919                vxa=DepthAverage(md,md.initialization.vx);
    2020                vya=DepthAverage(md,md.initialization.vy);
    … …  
    2828else
    2929        step=varargin{1};
    30         if strcmp(meshtype(md.mesh),'3D'),
     30        if meshdim(md.mesh)==3,
    3131                vxa=DepthAverage(md,md.results.TransientSolution(step).Vx);
    3232                vya=DepthAverage(md,md.results.TransientSolution(step).Vy);

  • issm/trunk-jpl/src/m/enum/EnumDefinitions.py

    r17651 r17674  
    211211def MeshYEnum(): return StringToEnum("MeshY")[0]
    212212def MeshZEnum(): return StringToEnum("MeshZ")[0]
     213def MeshXDimEnum(): return StringToEnum("MeshXDim")[0]
     214def MeshDimEnum(): return StringToEnum("MeshDim")[0]
    213215def MeshTypeEnum(): return StringToEnum("MeshType")[0]
    214216def Mesh2DhorizontalEnum(): return StringToEnum("Mesh2Dhorizontal")[0]

  • issm/trunk-jpl/src/m/exp/contourlevelzero.m

    r17559 r17674  
    1010
    1111%process data
    12 if strcmp(meshtype(md.mesh),'3D'),
     12if meshdim(md.mesh)==3,
    1313        error('contourlevelzero error message: routine not supported for 3d meshes, project on a layer');
    1414end

  • issm/trunk-jpl/src/m/extrusion/DepthAverage.m

    r17510 r17674  
    99
    1010%check that the model given in input is 3d
    11 if ~strcmp(md.mesh.meshtype,'3D');
     11if ~strcmp(md.mesh.meshxdim,'3D');
    1212        error('DepthAverage error message: the model given in input must be 3d')
    1313end

  • issm/trunk-jpl/src/m/extrusion/project2d.m

    r17510 r17674  
    2020end
    2121
    22 if ~strcmp(md3d.mesh.meshtype,'3D');
     22if ~strcmp(md3d.mesh.meshxdim,'3D');
    2323        error('wrong model type ... should be ''3d''');
    2424end

  • issm/trunk-jpl/src/m/extrusion/project3d.m

    r17465 r17674  
    2323        error('bad usage');
    2424end
    25 if ~strcmp(meshtype(md.mesh),'3D')
     25if ~strcmp(meshtype(md.mesh),'Penta')
    2626        error('input model is not 3d');
    2727end

  • issm/trunk-jpl/src/m/extrusion/project3d.py

    r17480 r17674  
    2727        if not md:
    2828                raise TypeError("bad usage")
    29         if not m.strcmp(md.mesh.meshtype(),'3D'):
     29        if not m.strcmp(md.mesh.meshtype(),'Penta'):
    3030                raise TypeError("input model is not 3d")
    3131

  • issm/trunk-jpl/src/m/geometry/slope.m

    r17559 r17674  
    77
    88%load some variables (it is much faster if the variab;es are loaded from md once for all)
    9 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     9if meshdim(md.mesh)==2,
    1010        numberofelements=md.mesh.numberofelements;
    1111        numberofnodes=md.mesh.numberofvertices;
    … …  
    3030s=sqrt(sx.^2+sy.^2);
    3131
    32 if strcmp(meshtype(md.mesh),'3D'),
     32if meshdim(md.mesh)==3,
    3333        sx=project3d(md,'vector',sx,'type','element');
    3434        sy=project3d(md,'vector',sy,'type','element');

  • issm/trunk-jpl/src/m/geometry/slope.py

    r17559 r17674  
    1212
    1313        #load some variables (it is much faster if the variables are loaded from md once for all)
    14         if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     14        if md.mesh.meshdim()==2:
    1515                numberofelements=md.mesh.numberofelements
    1616                numberofnodes=md.mesh.numberofvertices
    … …  
    3939        s=npy.sqrt(sx**2+sy**2)
    4040
    41         if m.strcmp(md.mesh.meshtype(),'3D'):
     41        if md.mesh.meshdim()==3:
    4242                sx=project3d(md,'vector',sx,'type','element')
    4343                sy=project3d(md,'vector',sy,'type','element')

  • issm/trunk-jpl/src/m/interp/SectionValues.m

    r17590 r17674  
    2929        error('SectionValues error message: wrong resolution type. Resolution must be an array [horizontal_resolution vertical_resolution]')
    3030end
    31 if strcmp(meshtype(md.mesh),'3D')
     31if meshdim(md.mesh)==3
    3232        if (length(resolution)==2 & isnumeric(resolution(2)))
    3333                res_v=resolution(2);
    … …  
    7878
    7979%New mesh and Data interpolation
    80 if (strcmp(meshtype(md.mesh),'2Dhorizontal'))
     80if (meshdim(md.mesh)==2)
    8181
    8282        %Interpolation of data on specified points

  • issm/trunk-jpl/src/m/interp/averaging.m

    r17559 r17674  
    2525        error('averaging error message: data not supported yet');
    2626end
    27 if strcmp(meshtype(md.mesh),'3D') & nargin==4,
     27if meshdim(md.mesh)==3 & nargin==4,
    2828        if varargin{1}<=0 | varargin{1}>md.mesh.numberoflayers,
    2929                error('layer should be between 1 and md.mesh.numberoflayers');
    … …  
    5656%build some variables
    5757line=index(:);
    58 if strcmp(meshtype(md.mesh),'3D') & layer==0,
     58if meshdim(md.mesh)==3 & layer==0,
    5959        rep=6;
    6060        areas=GetAreas(index,md.mesh.x,md.mesh.y,md.mesh.z);
    61 elseif strcmp(meshtype(md.mesh),'2Dhorizontal'),
     61elseif meshdim(md.mesh)==2,
    6262        rep=3;
    6363        areas=GetAreas(index,md.mesh.x,md.mesh.y);

  • issm/trunk-jpl/src/m/interp/averaging.py

    r17642 r17674  
    2828        if len(data)!=md.mesh.numberofelements and len(data)!=md.mesh.numberofvertices:
    2929                raise StandardError('averaging error message: data not supported yet')
    30         if m.strcmp(md.mesh.meshtype(),'3D') and layer!=0:
     30        if md.mesh.meshdim()==3 and layer!=0:
    3131                if layer<=0 or layer>md.mesh.numberoflayers:
    3232                        raise ValueError('layer should be between 1 and md.mesh.numberoflayers')
    … …  
    5454       
    5555        #build some variables
    56         if m.strcmp(md.mesh.meshtype(),'3D') and layer==0:
     56        if md.mesh.meshdim()==3 and layer==0:
    5757                rep=6
    5858                areas=GetAreas(index,md.mesh.x,md.mesh.y,md.mesh.z)
    59         elif m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     59        elif md.mesh.meshdim()==2:
    6060                rep=3
    6161                areas=GetAreas(index,md.mesh.x,md.mesh.y)

  • issm/trunk-jpl/src/m/inversions/velocitymisfit.m

    r17559 r17674  
    99%
    1010
    11 if strcmp(meshtype(md.mesh),'2Dhorizontal'),
     11if meshdim(md.mesh)==2,
    1212        elements=md.mesh.elements;
    1313        x=md.mesh.x;

  • issm/trunk-jpl/src/m/mech/analyticaldamage.m

    r17559 r17674  
    4848        error(['md.results.strainrate is not present.  Calculate using md=mechanicalproperties(md,vx,vy)']);
    4949end
    50 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),
     50if meshdim(md.mesh)~=2,
    5151        error('only 2d model supported currently');
    5252end

  • issm/trunk-jpl/src/m/mech/backstressfrominversion.m

    r17559 r17674  
    4141        error(['md.results.strainrate is not present.  Calculate using md=mechanicalproperties(md,vx,vy)']);
    4242end
    43 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),
     43if meshdim(md.mesh)~=2,
    4444        error('only 2d model supported currently');
    4545end

  • issm/trunk-jpl/src/m/mech/damagefrominversion.m

    r17559 r17674  
    2121        error(['md.results.strainrate is not present.  Calculate using md=mechanicalproperties(md,vx,vy)']);
    2222end
    23 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal')),
     23if meshdim(md.mesh)~=2,
    2424        error('only 2d model supported currently');
    2525end

  • issm/trunk-jpl/src/m/mech/mechanicalproperties.m

    r17559 r17674  
    1717        %error(['the input velocity should be of size ' num2str(md.mesh.numberofvertices) '!'])
    1818end
    19 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal'))
     19if meshdim(md.mesh)~=2
    2020        error('only 2d model supported yet');
    2121end

  • issm/trunk-jpl/src/m/mech/strainrateuncert.m

    r17559 r17674  
    3232        error(['the velocity error dvy should be of size ' num2str(md.mesh.numberofelements) ' or 1!'])
    3333end
    34 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal'))
     34if meshdim(md.mesh)~=2,
    3535        error('only 2d model supported yet');
    3636end

  • issm/trunk-jpl/src/m/mech/thomasparams.m

    r17559 r17674  
    5151        error(['md.results.strainrate is not present.  Calculate using md=mechanicalproperties(md,vx,vy)'])
    5252end
    53 if ~(strcmp(meshtype(md.mesh),'2Dhorizontal'))
     53if meshdim(md.mesh)~=2,
    5454        error('only 2d model supported currently');
    5555end

  • issm/trunk-jpl/src/m/mesh/bamg.m

    r17559 r17674  
    284284%}}}
    285285% Bamg Mesh parameters {{{
    286 if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & strcmp(meshtype(md.mesh),'2Dhorizontal')),
     286if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & strcmp(meshtype(md.mesh),'Tria')),
    287287
    288288        if isstruct(md.private.bamg) & isfield(md.private.bamg,'mesh'),

  • issm/trunk-jpl/src/m/mesh/bamg.py

    r17559 r17674  
    272272        #}}}
    273273        # Bamg Mesh parameters {{{
    274         if not options.exist('domain') and md.mesh.numberofvertices and m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     274        if not options.exist('domain') and md.mesh.numberofvertices and m.strcmp(md.mesh.meshtype(),'Tria'):
    275275
    276276                if isinstance(md.private.bamg,dict) and 'mesh' in md.private.bamg:

  • issm/trunk-jpl/src/m/miscellaneous/vorticity.m

    r17575 r17674  
    99
    1010%load some variables (it is much faster if the variab;es are loaded from md once for all)
    11 if ~strcmpi(md.mesh.meshtype(),'3D'),
     11if ~strcmpi(md.mesh.meshxdim(),'3D'),
    1212        numberofelements=md.mesh.numberofelements;
    1313        numberofnodes=md.mesh.numberofvertices;

  • issm/trunk-jpl/src/m/parameterization/contourenvelope.m

    r17558 r17674  
    4242%get nodes inside profile
    4343mesh.elementconnectivity=md.mesh.elementconnectivity;
    44 if strcmp(md.mesh.meshtype(),'2Dhorizontal'),
     44if strcmp(md.mesh.meshxdim(),'2Dhorizontal'),
    4545        mesh.elements=md.mesh.elements;
    4646        mesh.x=md.mesh.x;

  • issm/trunk-jpl/src/m/parameterization/contourenvelope.py

    r17602 r17674  
    4747        #get nodes inside profile
    4848        elementconnectivity=copy.deepcopy(md.mesh.elementconnectivity)
    49         if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     49        if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'):
    5050                elements=copy.deepcopy(md.mesh.elements)
    5151                x=copy.deepcopy(md.mesh.x)

  • issm/trunk-jpl/src/m/parameterization/setflowequation.m

    r16317 r17674  
    7171
    7272%Check that no L1L2 or HO or FS for 2d mesh
    73 if strcmp(meshtype(md.mesh),'2Dhorizontal')
     73if meshdim(md.mesh)==2
    7474        if any(L1L2flag | FSflag | HOflag)
    7575                error('FS and HO elements not allowed in 2d mesh, extrude it first')

  • issm/trunk-jpl/src/m/partition/AreaAverageOntoPartition.m

    r17559 r17674  
    99
    1010%some checks
    11 if strcmp(meshtype(md.mesh),'3D'),
     11if meshdim(md.mesh)==3,
    1212        if nargin~=3,
    1313                error('layer should be provided onto which Area Averaging occurs');
    … …  
    5151
    5252%in 3D, restore 3D model:
    53 if strcmp(meshtype(md.mesh),'3D'),
     53if meshdim(md.mesh)==3,
    5454        md=md3d;
    5555end

  • issm/trunk-jpl/src/m/partition/partitioner.m

    r17559 r17674  
    3030recomputeadjacency=getfieldvalue(options,'recomputeadjacency');
    3131
    32 if(strcmp(meshtype(md.mesh),'3D')),
     32if(meshdim(md.mesh)==3),
    3333        %partitioning essentially happens in 2D. So partition in 2D, then
    3434        %extrude the partition vector vertically.
    … …  
    100100
    101101%extrude if we are in 3D:
    102 if strcmp(meshtype(md.mesh),'3D'),
     102if meshdim(md.mesh)==3,
    103103        md3d.qmu.vertex_weight=md.qmu.vertex_weight;
    104104        md3d.qmu.adjacency=md.qmu.adjacency;

  • issm/trunk-jpl/src/m/plot/applyoptions.m

    r17568 r17674  
    4949
    5050%view
    51 if strcmp(meshtype(md.mesh),'3D') & ~exist(options,'layer'),
     51if strcmp(meshxdim(md.mesh),'3D') & ~exist(options,'layer'),
    5252        view(getfieldvalue(options,'view',3));
    5353else
    … …  
    6060        eval(['axis ' getfieldvalue(options,'axis')]);
    6161else
    62         if strcmpi(meshtype(md.mesh),'2Dhorizontal') | exist(options,'layer'),
     62        if strcmpi(meshxdim(md.mesh),'2Dhorizontal') | exist(options,'layer'),
    6363                axis tight equal;
    6464        else

  • issm/trunk-jpl/src/m/plot/plot_basaldrag.m

    r17590 r17674  
    99
    1010%check layer
    11 if strcmp(meshtype(md.mesh),'3D'),
     11if meshdim(md.mesh)==3,
    1212        if getfieldvalue(options,'layer',1)~=1;
    1313                disp('plot_basaldrag warning: basal drag is displayed in the lower layer')

  • issm/trunk-jpl/src/m/plot/plot_edges.m

    r17559 r17674  
    1717end
    1818
    19 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     19if (strcmp(meshxdim(md.mesh),'2Dhorizontal')),
    2020        %plot mesh
    2121        A=elements(:,1); B=elements(:,2); C=elements(:,3);

  • issm/trunk-jpl/src/m/plot/plot_icefront.m

    r17559 r17674  
    1919elementzeroice=sum(zeroice(md.mesh.elements),2);
    2020
    21 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     21if (strcmp(meshxdim(md.mesh),'2Dhorizontal')),
    2222        icefront=(elementice & elementnoice) & ~(elementice==2 & elementzeroice);
    2323

  • issm/trunk-jpl/src/m/plot/plot_penalties.m

    r17559 r17674  
    2121end
    2222
    23 if ~strcmp(meshtype(md.mesh),'3D'),
     23if ~strcmp(meshxdim(md.mesh),'3D'),
    2424        error('no penalties to plot for ''2d'' model');
    2525elseif isempty(md.penalties),

  • issm/trunk-jpl/src/m/plot/plot_qmu_mass_flux_segments.m

    r17559 r17674  
    1313allsegments=md.qmu.mass_flux_segments;
    1414
    15 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     15if (strcmp(meshxdim(md.mesh),'2Dhorizontal')),
    1616
    1717        %recover segments

  • issm/trunk-jpl/src/m/plot/plot_referential.m

    r17559 r17674  
    2828Yhat=cross(Zhat,Xhat);
    2929
    30 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     30if (strcmp(meshxdim(md.mesh),'2Dhorizontal')),
    3131
    3232        %plot mesh

  • issm/trunk-jpl/src/m/plot/plot_section.m

    r17559 r17674  
    203203%apply options
    204204options=addfielddefault(options,'title','Section value');
    205 if (strcmp(meshtype(md.mesh),'2Dhorizontal'))
     205if meshdim(md.mesh)==2
    206206        options=addfielddefault(options,'colorbar',0);
    207207end
    208 if ((strcmp(meshtype(md.mesh),'2Dhorizontal')) | getfieldvalue(options,'view')==2 )
     208if ((meshdim(md.mesh)==2) | getfieldvalue(options,'view')==2 )
    209209        options=addfielddefault(options,'xlabel','Curvilinear coordinate');
    210210        options=addfielddefault(options,'axis','auto');
    211211end
    212 if (strcmp(meshtype(md.mesh),'3D') & getfieldvalue(options,'view')==2 )
     212if (meshdim(md.mesh)==3 & getfieldvalue(options,'view')==2 )
    213213        options=addfielddefault(options,'ylabel','z');
    214214end

  • issm/trunk-jpl/src/m/plot/plot_segments.m

    r17559 r17674  
    1414segments=md.mesh.segments;
    1515
    16 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     16if (strcmp(meshxdim(md.mesh),'2Dhorizontal')),
    1717        %plot mesh
    1818        A=elements(:,1); B=elements(:,2); C=elements(:,3);

  • issm/trunk-jpl/src/m/plot/plot_tensor_components.m

    r17559 r17674  
    1010upperplots=fix((i-1)/width);
    1111if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end
    12 if (strcmp(meshtype(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes
     12if (strcmp(meshxdim(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes
    1313        index1=4*width*upperplots+2*leftplots+1;
    1414        index2=index1+1;
    1515        index3=index1+width*2;
    16 elseif strcmp(meshtype(md.mesh),'3D')%6 components -> 6 indexes
     16elseif meshdim(md.mesh)==3%6 components -> 6 indexes
    1717        index1=3*3*width*upperplots+3*leftplots+1;
    1818        index2=index1+1;
    … …  
    2828[tensor.yy datatype]=processdata(md,tensor.yy,options);
    2929[tensor.xy datatype]=processdata(md,tensor.xy,options);
    30 if  strcmp(meshtype(md.mesh),'3D')
     30if  meshdim(md.mesh)==3
    3131        [tensor.xz datatype]=processdata(md,tensor.xz,options);
    3232        [tensor.yz datatype]=processdata(md,tensor.yz,options);
    … …  
    3434end
    3535
    36 if ((strcmp(meshtype(md.mesh),'2Dhorizontal'))),
     36if ((strcmp(meshxdim(md.mesh),'2Dhorizontal'))),
    3737        subplot(2*width,2*width,index1),
    3838        plot_unit(x,y,z,elements,tensor.xx,is2d,isplanet,datatype,options)

  • issm/trunk-jpl/src/m/plot/plot_tensor_principal.m

    r17559 r17674  
    1010upperplots=fix((i-1)/width);
    1111if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end
    12 if (strcmp(meshtype(md.mesh),'2Dhorizontal'))%3 components -> 3 indexes
     12if (meshdim(md.mesh)==2)%3 components -> 3 indexes
    1313        index1=4*width*upperplots+2*leftplots+1;
    1414        index2=index1+1;
    … …  
    1616        index4=index3+1;
    1717        newwidth=2*width;
    18 elseif strcmp(meshtype(md.mesh),'3D')%6 components -> 6 indexes
     18elseif meshdim(md.mesh)==3%6 components -> 6 indexes
    1919        index1=3*3*width*upperplots+3*leftplots+1;
    2020        index2=index1+1;
    … …  
    3131type2=[type 'axis2'];
    3232plot_tensor_principalaxis(md,options,newwidth,index2,tensor,type2,plot_options);
    33 if  strcmp(meshtype(md.mesh),'3D')
     33if  meshdim(md.mesh)==3
    3434        type3=[type 'axis3'];
    3535        plot_tensor_principalaxis(md,options,newwidth,index3,tensor,type3,plot_options);
    … …  
    4040[tensor.principalvalue1 datatype]=processdata(md,tensor.principalvalue1,options);
    4141[tensor.principalvalue2 datatype]=processdata(md,tensor.principalvalue2,options);
    42 if  strcmp(meshtype(md.mesh),'3D')
     42if  meshdim(md.mesh)==3
    4343        [tensor.principalvalue3 datatype]=processdata(md,tensor.principalvalue3,options);
    4444end
    4545
    46 if ((strcmp(meshtype(md.mesh),'2Dhorizontal'))),
     46if meshdim(md.mesh)==2,
    4747        subplot(2*width,2*width,index3)
    4848        plot_unit(x,y,z,elements,tensor.principalvalue1,is2d,isplanet,datatype,options)

  • issm/trunk-jpl/src/m/plot/plot_tensor_principalaxis.m

    r17559 r17674  
    1313[x y z elements is2d isplanet]=processmesh(md,[],options);
    1414
    15 if ((strcmp(meshtype(md.mesh),'2Dhorizontal'))),
     15if meshdim(md.mesh)==2,
    1616        eval(['Vx=tensor.principalaxis' type(end) '(:,1); Vy=tensor.principalaxis' type(end) '(:,2);'])
    1717        eval(['value=tensor.principalvalue' type(end) ';']);
    … …  
    3333
    3434%plot quivers
    35 if (strcmp(meshtype(md.mesh),'2Dhorizontal')),
     35if meshdim(md.mesh)==2,
    3636
    3737        %density

  • issm/trunk-jpl/src/m/plot/plot_transient_results.m

    r17559 r17674  
    4141clear string;
    4242
    43 if strcmp(meshtype(md.mesh),'3D'),
     43if strcmp(meshxdim(md.mesh),'3D'),
    4444        string='plotmodel(md';
    4545        for i=1:length(md.results.transient),
    … …  
    6767clear string;
    6868
    69 if strcmp(meshtype(md.mesh),'3D'),
     69if strcmp(meshxdim(md.mesh),'3D'),
    7070        string='plotmodel(md';
    7171        for i=2:length(md.results.transient),

  • issm/trunk-jpl/src/m/plot/processdata.m

    r17597 r17674  
    2323
    2424%special case for mesh 2dvertical
    25 if strcmp(meshtype(md.mesh),'2Dvertical'),
     25if strcmp(meshxdim(md.mesh),'2Dvertical'),
    2626        [data datatype] = processdata(md.mesh,md,data,options);
    2727        return;
    … …  
    5656
    5757%check length
    58 if datasize(1)~=md.mesh.numberofvertices & datasize(1)~=md.mesh.numberofelements & datasize(1)~=md.mesh.numberofvertices*6 & (strcmp(md.mesh.meshtype(),'3D') & ~(datasize(1)==numberofelements2d | datasize(1)==numberofvertices2d))
     58if 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))
    5959        error('plotmodel error message: data not supported yet');
    6060end
    … …  
    6565
    6666        %check number of columns, add zeros if necessary,
    67         if (strcmp(md.mesh.meshtype(),'3D'))
     67        if (strcmp(md.mesh.meshxdim(),'3D'))
    6868                if datasize(2)==2,
    6969                        data=[data, zeros(datasize(1),1)];
    … …  
    8585
    8686%treat the case datasize(1)=nodes2d
    87 if (strcmp(md.mesh.meshtype(),'3D') & datasize(1)==numberofvertices2d),
     87if (strcmp(md.mesh.meshxdim(),'3D') & datasize(1)==numberofvertices2d),
    8888        data=project3d(md,'vector',data,'type','node');
    8989        datasize(1)=md.mesh.numberofvertices;
    … …  
    9292
    9393%treat the case datasize(1)=nodes2d
    94 if (strcmp(md.mesh.meshtype(),'3D') & datasize(1)==numberofelements2d),
     94if (strcmp(md.mesh.meshxdim(),'3D') & datasize(1)==numberofelements2d),
    9595        data=project3d(md,'vector',data,'type','element');
    9696        datasize(1)=md.mesh.numberofelements;

  • issm/trunk-jpl/src/m/plot/processmesh.m

    r17578 r17674  
    1616
    1717%special case for mesg 2dvertical
    18 if strcmp(meshtype(md.mesh),'2Dvertical'),
     18if strcmp(meshxdim(md.mesh),'2Dvertical'),
    1919        [x y z elements is2d isplanet] = processmesh(md.mesh,options);
    2020        return;
    … …  
    4646
    4747%is it a 2d plot?
    48 if ~strcmp(md.mesh.meshtype(),'3D');
     48if md.mesh.meshdim()==2,
    4949        is2d=1;
    5050else

  • issm/trunk-jpl/src/m/plot/processmesh.py

    r17597 r17674  
    4242
    4343                #is it a 2D plot?
    44                 if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     44                if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'):
    4545                        is2d=1
    46                 elif m.strcmp(md.mesh.meshtype(),'3D'):
     46                elif m.strcmp(md.mesh.meshxdim(),'3D'):
    4747                        if options.getfieldvalue('layer',0)>=1:
    4848                                is2d=1
    … …  
    6464        else:
    6565                #Process mesh for plotting
    66                 if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
     66                if m.strcmp(md.mesh.meshxdim(),'2Dhorizontal'):
    6767                        is2d=1
    6868                else:

  • issm/trunk-jpl/src/wrappers/MeshPartition/MeshPartition.cpp

    r16329 r17674  
    1919
    2020        /* required input: */
    21         int  meshtype;
     21        int  meshxdim;
    2222        int  numberofelements;
    2323        int  numberofvertices;
    … …  
    5050
    5151        if(strcmp(mxGetClassName(MESH),"mesh3d")==0){
    52                 meshtype = Mesh3DEnum;
     52                meshxdim = Mesh3DEnum;
    5353                FetchData(&numberofelements2d,mxGetAssignedField(MESH,0,"numberofelements2d"));
    5454                FetchData(&numberofvertices2d,mxGetAssignedField(MESH,0,"numberofvertices2d"));
    … …  
    5757        }
    5858        else if(strcmp(mxGetClassName(MESH),"mesh2dhorizontal")==0){
    59                 meshtype = Mesh2DhorizontalEnum;
     59                meshxdim = Mesh2DhorizontalEnum;
    6060                numberoflayers=1;
    6161        }
    6262        else if(strcmp(mxGetClassName(MESH),"mesh2dvertical")==0){
    63                 meshtype = Mesh2DverticalEnum;
     63                meshxdim = Mesh2DverticalEnum;
    6464                numberoflayers=1;
    6565        }
    … …  
    7171        /*Run partitioning algorithm based on a "clever" use of the Metis partitioner: */
    7272        MeshPartitionx(&int_element_partitioning,&int_node_partitioning,numberofelements,numberofvertices,elements,
    73                 numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,meshtype,numareas);
     73                numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,meshxdim,numareas);
    7474
    7575        /*Post process node_partitioning and element_partitioning to be in double format. Metis needed them in int* format: */
Note: See TracChangeset for help on using the changeset viewer.