Changeset 17700


Ignore:
Timestamp:
04/09/14 17:49:39 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: renamed Mesh3D Domain3D etc and simplified the way we get the dimension when possible

Location:
issm/trunk-jpl/src
Files:
3 added
4 deleted
54 edited

Legend:

Unmodified
Added
Removed

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

    r17686 r17700  
    5555        element->FindParam(&domaintype,DomainTypeEnum);
    5656        switch(domaintype){
    57                 case Mesh2DhorizontalEnum:
     57                case Domain2DhorizontalEnum:
    5858                        basalelement = element;
    5959                        break;
    60                 case Mesh3DEnum:
     60                case Domain3DEnum:
    6161                        if(!element->IsOnBase()) return NULL;
    6262                        basalelement = element->SpawnBasalElement();
    … …  
    143143        xDelete<IssmDouble>(basis);
    144144        xDelete<IssmDouble>(dbasis);
    145         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     145        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    146146        delete gauss;
    147147        return pe;
    … …  
    155155        element->FindParam(&domaintype,DomainTypeEnum);
    156156        switch(domaintype){
    157                 case Mesh2DhorizontalEnum:
     157                case Domain2DhorizontalEnum:
    158158                        element->InputUpdateFromSolutionOneDof(solution,AdjointEnum);
    159159                        break;
    160                 case Mesh3DEnum:
     160                case Domain3DEnum:
    161161                        element->InputUpdateFromSolutionOneDofCollapsed(solution,AdjointEnum);
    162162                        break;

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

    r17686 r17700  
    6161        element->FindParam(&domaintype,DomainTypeEnum);
    6262        switch(domaintype){
    63                 case Mesh2DhorizontalEnum:
     63                case Domain2DhorizontalEnum:
    6464                        basalelement = element;
    6565                        break;
    66                 case Mesh3DEnum:
     66                case Domain3DEnum:
    6767                        if(!element->IsOnBase()) return NULL;
    6868                        basalelement = element->SpawnBasalElement();
    … …  
    8787        delete analysis;
    8888        if(incomplete_adjoint){
    89                 if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     89                if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    9090                return Ke;
    9191        }
    … …  
    136136        xDelete<IssmDouble>(dbasis);
    137137        xDelete<IssmDouble>(xyz_list);
    138         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     138        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    139139        return Ke;
    140140}/*}}}*/
    … …  
    304304
    305305        /*Intermediaries */
    306         int        num_responses,i,domaintype,dim;
     306        int        num_responses,i,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(&domaintype,DomainTypeEnum);
    315         switch(domaintype){
    316                 case Mesh2DverticalEnum: dim = 2; break;
    317                 case Mesh3DEnum:         dim = 3; break;
    318                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    319         }
     314        element->FindParam(&dim,DomainDimensionEnum);
    320315
    321316        /*Fetch number of nodes and dof for this finite element*/
    … …  
    690685        element->FindParam(&domaintype,DomainTypeEnum);
    691686        switch(domaintype){
    692                 case Mesh2DhorizontalEnum:
     687                case Domain2DhorizontalEnum:
    693688                        basalelement = element;
    694689                        break;
    695                 case Mesh3DEnum:
     690                case Domain3DEnum:
    696691                        if(!element->IsOnBase()) return NULL;
    697692                        basalelement = element->SpawnBasalElement();
    … …  
    875870        xDelete<IssmDouble>(xyz_list);
    876871        xDelete<IssmDouble>(basis);
    877         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     872        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    878873        delete gauss;
    879874        return pe;

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

    r17686 r17700  
    4444        iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum);
    4545
    46         if(iomodel->domaintype==Mesh3DEnum){
     46        if(iomodel->domaintype==Domain3DEnum){
    4747                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4848                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    5555
    5656        /*Check in 3d*/
    57         if(stabilization==3 && iomodel->domaintype==Mesh3DEnum) _error_("DG 3d not implemented yet");
     57        if(stabilization==3 && iomodel->domaintype==Domain3DEnum) _error_("DG 3d not implemented yet");
    5858
    5959        /*First fetch data: */
    60         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     60        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6161        if(stabilization!=3){
    6262                ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);
    … …  
    143143        int domaintype;
    144144        element->FindParam(&domaintype,DomainTypeEnum);
    145         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     145        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    146146        return Ke;
    147147}/*}}}*/
    … …  
    171171        Input* vxaverage_input=NULL;
    172172        Input* vyaverage_input=NULL;
    173         if(domaintype==Mesh2DhorizontalEnum){
     173        if(domaintype==Domain2DhorizontalEnum){
    174174                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    175175                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    272272        Input* vxaverage_input=NULL;
    273273        Input* vyaverage_input=NULL;
    274         if(domaintype==Mesh2DhorizontalEnum){
     274        if(domaintype==Domain2DhorizontalEnum){
    275275                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    276276                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    335335        int domaintype;
    336336        element->FindParam(&domaintype,DomainTypeEnum);
    337         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     337        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    338338        return pe;
    339339}/*}}}*/
    … …  
    483483        element->FindParam(&domaintype,DomainTypeEnum);
    484484        switch(domaintype){
    485                 case Mesh2DhorizontalEnum:
     485                case Domain2DhorizontalEnum:
    486486                        element->InputUpdateFromSolutionOneDof(solution,ThicknessEnum);
    487487                        break;
    488                 case Mesh3DEnum:
     488                case Domain3DEnum:
    489489                        element->InputUpdateFromSolutionOneDofCollapsed(solution,ThicknessEnum);
    490490                        break;

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

    r17686 r17700  
    3333        iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum);
    3434
    35         if(iomodel->domaintype==Mesh3DEnum){
     35        if(iomodel->domaintype==Domain3DEnum){
    3636                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3737                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    4141
    4242        /*Check in 3d*/
    43         if(iomodel->domaintype==Mesh3DEnum) _error_("DG 3d not implemented yet");
     43        if(iomodel->domaintype==Domain3DEnum) _error_("DG 3d not implemented yet");
    4444
    4545        /*First fetch data: */
    … …  
    154154        element->FindParam(&domaintype,DomainTypeEnum);
    155155        switch(domaintype){
    156                 case Mesh2DhorizontalEnum:
     156                case Domain2DhorizontalEnum:
    157157                        basalelement = element;
    158158                        break;
    159                 case Mesh3DEnum:
     159                case Domain3DEnum:
    160160                        if(!element->IsOnBase()) return NULL;
    161161                        basalelement = element->SpawnBasalElement();
    … …  
    235235        xDelete<IssmDouble>(Ny);
    236236        delete gauss;
    237         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     237        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    238238        return pe;
    239239}/*}}}*/
    … …  
    246246        element->FindParam(&domaintype,DomainTypeEnum);
    247247        switch(domaintype){
    248                 case Mesh2DhorizontalEnum:
     248                case Domain2DhorizontalEnum:
    249249                        element->InputUpdateFromSolutionOneDof(solution,VelEnum);
    250250                        break;
    251                 case Mesh3DEnum:
     251                case Domain3DEnum:
    252252                        element->InputUpdateFromSolutionOneDofCollapsed(solution,VelEnum);
    253253                        break;

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

    r17686 r17700  
    6060        iomodel->FetchDataToInput(elements,VxEnum);
    6161        iomodel->FetchDataToInput(elements,VyEnum);
    62         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchDataToInput(elements,VzEnum);
     62        if(iomodel->domaintype==Domain3DEnum) 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->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     75        if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    7676        ::CreateNodes(nodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum);
    7777        iomodel->DeleteData(1,MeshVertexonbaseEnum);
    … …  
    118118        element->FindParam(&domaintype,DomainTypeEnum);
    119119        switch(domaintype){
    120                 case Mesh2DhorizontalEnum:
     120                case Domain2DhorizontalEnum:
    121121                        basalelement = element;
    122122                        dim = 2;
    123123                        break;
    124                 case Mesh3DEnum:
     124                case Domain3DEnum:
    125125                        if(!element->IsOnBase()) return NULL;
    126126                        basalelement = element->SpawnBasalElement();
    … …  
    146146        Input* vxaverage_input=NULL;
    147147        Input* vyaverage_input=NULL;
    148         if(domaintype==Mesh2DhorizontalEnum){
     148        if(domaintype==Domain2DhorizontalEnum){
    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(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     251        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    252252        return Ke;
    253253}/*}}}*/
    … …  
    267267        element->FindParam(&domaintype,DomainTypeEnum);
    268268        switch(domaintype){
    269                 case Mesh2DhorizontalEnum:
     269                case Domain2DhorizontalEnum:
    270270                        basalelement = element;
    271271                        break;
    272                 case Mesh3DEnum:
     272                case Domain3DEnum:
    273273                        if(!element->IsOnBase()) return NULL;
    274274                        basalelement = element->SpawnBasalElement();
    … …  
    311311        xDelete<IssmDouble>(xyz_list);
    312312        xDelete<IssmDouble>(basis);
    313         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     313        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    314314        delete gauss;
    315315        return pe;
    … …  
    383383
    384384        element->FindParam(&domaintype,DomainTypeEnum);
    385         if(domaintype!=Mesh2DhorizontalEnum){
     385        if(domaintype!=Domain2DhorizontalEnum){
    386386                if(!element->IsOnBase()) return;
    387387                basalelement=element->SpawnBasalElement();
    … …  
    416416        xDelete<IssmDouble>(newdamage);
    417417        xDelete<int>(doflist);
    418         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     418        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    419419}/*}}}*/
    420420void DamageEvolutionAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/

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

    r17692 r17700  
    2222        }
    2323
    24         if(iomodel->domaintype==Mesh2DverticalEnum){
     24        if(iomodel->domaintype==Domain2DverticalEnum){
    2525                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    … …  
    5050
    5151        /*Intermediaries */
     52        int         dim;
    5253        IssmDouble  Jdet,D,dt=1.e+9;
    5354        IssmDouble *xyz_list = NULL;
    5455
    5556        /*Get dimension*/
    56         int dim,domaintype;
    57         element->FindParam(&domaintype,DomainTypeEnum);
    58         switch(domaintype){
    59                 case Mesh2DverticalEnum: dim = 2; break;
    60                 case Mesh3DEnum:         dim = 3; break;
    61                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    62         }
     57        element->FindParam(&dim,DomainDimensionEnum);
    6358
    6459        /*Fetch number of nodes and dof for this finite element*/

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

    r17686 r17700  
    2929
    3030        /*Now, is the model 3d? otherwise, do nothing: */
    31         if(iomodel->domaintype==Mesh2DhorizontalEnum)return;
     31        if(iomodel->domaintype==Domain2DhorizontalEnum)return;
    3232
    3333        /*Is enthalpy requested?*/
    … …  
    9494void EnthalpyAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    9595
    96         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     96        if(iomodel->domaintype==Domain3DEnum) 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->domaintype==Mesh2DhorizontalEnum) return;
     119        if(iomodel->domaintype==Domain2DhorizontalEnum) return;
    120120
    121121        /*Fetch data: */

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

    r17686 r17700  
    3030                }
    3131        }
    32         if(iomodel->domaintype==Mesh3DEnum){
     32        if(iomodel->domaintype==Domain3DEnum){
    3333                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3434                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    3838void ExtrapolationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3939        int finiteelement=P1Enum;
    40         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     40        if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4141        ::CreateNodes(nodes,iomodel,ExtrapolationAnalysisEnum,finiteelement);
    4242        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    9999        basalelement->FindParam(&domaintype,DomainTypeEnum);
    100100        switch(domaintype){
    101                 case Mesh2DverticalEnum:   dim = 1; break;
    102                 case Mesh2DhorizontalEnum: dim = 2; break;
    103                 case Mesh3DEnum:           dim = 2; break;
     101                case Domain2DverticalEnum:   dim = 1; break;
     102                case Domain2DhorizontalEnum: dim = 2; break;
     103                case Domain3DEnum:           dim = 2; break;
    104104                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    105105        }
    … …  
    213213        xDelete<IssmDouble>(normal);
    214214        delete gauss;
    215         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     215        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    216216        return Ke;
    217217
    … …  
    234234
    235235        basalelement->FindParam(&domaintype,DomainTypeEnum);
    236         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     236        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    237237        return pe;
    238238}/*}}}*/
    … …  
    246246        element->FindParam(&extrapolationvariable, ExtrapolationVariableEnum);
    247247        switch(domaintype){
    248                 case Mesh2DhorizontalEnum:
     248                case Domain2DhorizontalEnum:
    249249                        element->InputUpdateFromSolutionOneDof(solution,extrapolationvariable);
    250250                        break;
    251                 case Mesh3DEnum:
     251                case Domain3DEnum:
    252252                        element->InputUpdateFromSolutionOneDofCollapsed(solution,extrapolationvariable);
    253253                        break;

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

    r17686 r17700  
    2222        }
    2323
    24         if(iomodel->domaintype==Mesh2DverticalEnum){
     24        if(iomodel->domaintype==Domain2DverticalEnum){
    2525                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    … …  
    6868
    6969        /*Get dimension*/
    70         int dim,domaintype;
    71         element->FindParam(&domaintype,DomainTypeEnum);
    72         switch(domaintype){
    73                 case Mesh2DverticalEnum: dim = 2; break;
    74                 case Mesh3DEnum:         dim = 3; break;
    75                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    76         }
     70        int dim;
     71        element->FindParam(&dim,DomainDimensionEnum);
    7772
    7873        /*Fetch number of nodes and dof for this finite element*/
    … …  
    116111
    117112        /*Intermediaries */
     113        int         dim;
    118114        IssmDouble  Jdet,D,normal[3];
    119115        IssmDouble *xyz_list_top = NULL;
    120116
    121117        /*Get dimension*/
    122         int dim,domaintype;
    123         element->FindParam(&domaintype,DomainTypeEnum);
    124         switch(domaintype){
    125                 case Mesh2DverticalEnum: dim = 2; break;
    126                 case Mesh3DEnum:         dim = 3; break;
    127                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    128         }
     118        element->FindParam(&dim,DomainDimensionEnum);
    129119
    130120        /*Fetch number of nodes and dof for this finite element*/
    … …  
    166156
    167157        /*Intermediaries */
     158        int         dim;
    168159        IssmDouble  Jdet,D,normal[3];
    169160        IssmDouble *xyz_list_base = NULL;
    170161
    171162        /*Get dimension*/
    172         int dim,domaintype;
    173         element->FindParam(&domaintype,DomainTypeEnum);
    174         switch(domaintype){
    175                 case Mesh2DverticalEnum: dim = 2; break;
    176                 case Mesh3DEnum:         dim = 3; break;
    177                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    178         }
     163        element->FindParam(&dim,DomainDimensionEnum);
    179164
    180165        /*Fetch number of nodes and dof for this finite element*/

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

    r17686 r17700  
    2222        }
    2323
    24         if(iomodel->domaintype==Mesh2DverticalEnum){
     24        if(iomodel->domaintype==Domain2DverticalEnum){
    2525                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    … …  
    6464
    6565        /*Intermediaries */
    66         int         domaintype,dim;
     66        int         dim;
    6767        IssmDouble  Jdet,D;
    6868        IssmDouble *xyz_list = NULL;
    6969
    7070        /*Get dimension*/
    71         element->FindParam(&domaintype,DomainTypeEnum);
    72         switch(domaintype){
    73                 case Mesh2DverticalEnum: dim = 2; break;
    74                 case Mesh3DEnum:         dim = 3; break;
    75                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    76         }
     71        element->FindParam(&dim,DomainDimensionEnum);
    7772
    7873        /*Fetch number of nodes and dof for this finite element*/
    … …  
    116111
    117112        /*Intermediaries */
     113        int         dim;
    118114        IssmDouble  Jdet,D,normal[2];
    119115        IssmDouble *xyz_list_top = NULL;
    120116
    121117        /*Get dimension*/
    122         int dim,domaintype;
    123         element->FindParam(&domaintype,DomainTypeEnum);
    124         switch(domaintype){
    125                 case Mesh2DverticalEnum: dim = 2; break;
    126                 case Mesh3DEnum:         dim = 3; break;
    127                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    128         }
     118        element->FindParam(&dim,DomainDimensionEnum);
    129119
    130120        /*Fetch number of nodes and dof for this finite element*/
    … …  
    166156
    167157        /*Intermediaries */
     158        int         dim;
    168159        IssmDouble  Jdet,D,normal[3];
    169160        IssmDouble *xyz_list_base = NULL;
    170161
    171162        /*Get dimension*/
    172         int dim,domaintype;
    173         element->FindParam(&domaintype,DomainTypeEnum);
    174         switch(domaintype){
    175                 case Mesh2DverticalEnum: dim = 2; break;
    176                 case Mesh3DEnum:         dim = 3; break;
    177                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    178         }
     163        element->FindParam(&dim,DomainDimensionEnum);
    179164
    180165        /*Fetch number of nodes and dof for this finite element*/

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

    r17686 r17700  
    1414
    1515        /*Now, is the model 3d? otherwise, do nothing: */
    16         if (iomodel->domaintype==Mesh2DhorizontalEnum)return;
     16        if (iomodel->domaintype==Domain2DhorizontalEnum)return;
    1717
    1818        /*Finite element type*/
    … …  
    3535        iomodel->FetchDataToInput(elements,VxEnum);
    3636        iomodel->FetchDataToInput(elements,VyEnum);
    37         if(iomodel->domaintype==Mesh3DEnum){
     37        if(iomodel->domaintype==Domain3DEnum){
    3838                iomodel->FetchDataToInput(elements,VzEnum);
    3939                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    … …  
    4343void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4444
    45         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     45        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
     62        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype!=Mesh2DhorizontalEnum){
     71                        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    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                        }
    … …  
    114114        element->FindParam(&domaintype,DomainTypeEnum);
    115115        switch(domaintype){
    116                 case Mesh2DhorizontalEnum:
     116                case Domain2DhorizontalEnum:
    117117                        basalelement = element;
    118118                        dim = 2;
    119119                        break;
    120                 case Mesh2DverticalEnum:
     120                case Domain2DverticalEnum:
    121121                        if(!element->IsOnBase()) return NULL;
    122122                        basalelement = element->SpawnBasalElement();
    123123                        dim = 1;
    124124                        break;
    125                 case Mesh3DEnum:
     125                case Domain3DEnum:
    126126                        if(!element->IsOnBase()) return NULL;
    127127                        basalelement = element->SpawnBasalElement();
    … …  
    223223        xDelete<IssmDouble>(D);
    224224        delete gauss;
    225         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     225        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    226226        return Ke;
    227227}/*}}}*/
    … …  
    237237        element->FindParam(&domaintype,DomainTypeEnum);
    238238        switch(domaintype){
    239                 case Mesh2DhorizontalEnum:
     239                case Domain2DhorizontalEnum:
    240240                        basalelement = element;
    241241                        dim = 2;
    242242                        break;
    243                 case Mesh2DverticalEnum:
     243                case Domain2DverticalEnum:
    244244                        if(!element->IsOnBase()) return NULL;
    245245                        basalelement = element->SpawnBasalElement();
    246246                        dim = 1;
    247247                        break;
    248                 case Mesh3DEnum:
     248                case Domain3DEnum:
    249249                        if(!element->IsOnBase()) return NULL;
    250250                        basalelement = element->SpawnBasalElement();
    … …  
    298298        xDelete<IssmDouble>(basis);
    299299        delete gauss;
    300         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     300        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    301301        return pe;
    302302

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

    r17686 r17700  
    1414
    1515        /*Now, is the model 3d? otherwise, do nothing: */
    16         if (iomodel->domaintype==Mesh2DhorizontalEnum)return;
     16        if (iomodel->domaintype==Domain2DhorizontalEnum)return;
    1717
    1818        int smb_model;
    … …  
    3535        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    3636        iomodel->FetchDataToInput(elements,VxEnum);
    37         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
    38         if(iomodel->domaintype==Mesh3DEnum){
     37        if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
     38        if(iomodel->domaintype==Domain3DEnum){
    3939                iomodel->FetchDataToInput(elements,VzEnum);
    4040                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    … …  
    5252void FreeSurfaceTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    5353
    54         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     54        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonsurface,NULL,NULL,MeshVertexonsurfaceEnum);
     71        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype!=Mesh2DhorizontalEnum){
     80                        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    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                        }
    … …  
    123123        element->FindParam(&domaintype,DomainTypeEnum);
    124124        switch(domaintype){
    125                 case Mesh2DhorizontalEnum:
     125                case Domain2DhorizontalEnum:
    126126                        topelement = element;
    127127                        dim = 2;
    128128                        break;
    129                 case Mesh2DverticalEnum:
     129                case Domain2DverticalEnum:
    130130                        if(!element->IsOnSurface()) return NULL;
    131131                        topelement = element->SpawnTopElement();
    132132                        dim = 1;
    133133                        break;
    134                 case Mesh3DEnum:
     134                case Domain3DEnum:
    135135                        if(!element->IsOnSurface()) return NULL;
    136136                        topelement = element->SpawnTopElement();
    … …  
    232232        xDelete<IssmDouble>(D);
    233233        delete gauss;
    234         if(domaintype!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
     234        if(domaintype!=Domain2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
    235235        return Ke;
    236236}/*}}}*/
    … …  
    246246        element->FindParam(&domaintype,DomainTypeEnum);
    247247        switch(domaintype){
    248                 case Mesh2DhorizontalEnum:
     248                case Domain2DhorizontalEnum:
    249249                        topelement = element;
    250250                        dim = 2;
    251251                        break;
    252                 case Mesh2DverticalEnum:
     252                case Domain2DverticalEnum:
    253253                        if(!element->IsOnSurface()) return NULL;
    254254                        topelement = element->SpawnTopElement();
    255255                        dim = 1;
    256256                        break;
    257                 case Mesh3DEnum:
     257                case Domain3DEnum:
    258258                        if(!element->IsOnSurface()) return NULL;
    259259                        topelement = element->SpawnTopElement();
    … …  
    302302        xDelete<IssmDouble>(basis);
    303303        delete gauss;
    304         if(domaintype!=Mesh2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
     304        if(domaintype!=Domain2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
    305305        return pe;
    306306

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

    r17686 r17700  
    5656        iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum);
    5757        iomodel->FetchDataToInput(elements,HydrologydcEplThicknessEnum);
    58         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
     58        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    5959       
    6060        //      elements->InputDuplicate(HydrologydcEplInitialThicknessEnum,HydrologydcEplThicknessEnum);
    … …  
    7373        if(!isefficientlayer) return;
    7474
    75         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     75        if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    7676        ::CreateNodes(nodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum);
    7777        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    117117        element->FindParam(&domaintype,DomainTypeEnum);
    118118        switch(domaintype){
    119                 case Mesh2DhorizontalEnum:
     119                case Domain2DhorizontalEnum:
    120120                        basalelement = element;
    121121                        break;
    122                 case Mesh3DEnum:
     122                case Domain3DEnum:
    123123                        if(!element->IsOnBase()) return NULL;
    124124                        basalelement = element->SpawnBasalElement();
    … …  
    132132        /*Check that all nodes are active, else return empty matrix*/
    133133        if(!active_element) {
    134         if(domaintype!=Mesh2DhorizontalEnum){
     134        if(domaintype!=Domain2DhorizontalEnum){
    135135                        basalelement->DeleteMaterials();
    136136                        delete basalelement;
    … …  
    207207        xDelete<IssmDouble>(B);
    208208        delete gauss;
    209         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     209        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    210210        return Ke;
    211211
    … …  
    221221        element->FindParam(&domaintype,DomainTypeEnum);
    222222        switch(domaintype){
    223                 case Mesh2DhorizontalEnum:
     223                case Domain2DhorizontalEnum:
    224224                        basalelement = element;
    225225                        break;
    226                 case Mesh3DEnum:
     226                case Domain3DEnum:
    227227                        if(!element->IsOnBase()) return NULL;
    228228                        basalelement = element->SpawnBasalElement();
    … …  
    236236        /*Check that all nodes are active, else return empty matrix*/
    237237        if(!active_element) {
    238         if(domaintype!=Mesh2DhorizontalEnum){
     238        if(domaintype!=Domain2DhorizontalEnum){
    239239                        basalelement->DeleteMaterials();
    240240                        delete basalelement;
    … …  
    309309        xDelete<IssmDouble>(basis);
    310310        delete gauss;
    311         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     311        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    312312        return pe;
    313313}/*}}}*/
    … …  
    322322        element->FindParam(&domaintype,DomainTypeEnum);
    323323
    324         if(domaintype!=Mesh2DhorizontalEnum){
     324        if(domaintype!=Domain2DhorizontalEnum){
    325325                if(!element->IsOnBase()) return;
    326326                basalelement=element->SpawnBasalElement();
    … …  
    351351        xDelete<IssmDouble>(eplHeads);
    352352        xDelete<int>(doflist);
    353         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     353        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    354354} /*}}}*/
    355355void HydrologyDCEfficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
    … …  
    493493               
    494494                switch(domaintype){
    495                 case Mesh2DhorizontalEnum:
     495                case Domain2DhorizontalEnum:
    496496                        if(!element->IsOnBase()) return;                       
    497497                        B = element->GetMaterialParameter(MaterialsRheologyBbarEnum);
    498498                        break;
    499                 case Mesh3DEnum:
     499                case Domain3DEnum:
    500500                        B = element->GetMaterialParameter(MaterialsRheologyBEnum);
    501501                        break;
    … …  
    610610        element->FindParam(&domaintype,DomainTypeEnum);
    611611        switch(domaintype){
    612                 case Mesh2DhorizontalEnum:
     612                case Domain2DhorizontalEnum:
    613613                        basalelement = element;
    614614                        break;
    615                 case Mesh3DEnum:
     615                case Domain3DEnum:
    616616                        if(!element->IsOnBase()) return;
    617617                        basalelement = element->SpawnBasalElement();
    … …  
    673673                }
    674674        }
    675         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     675        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    676676        xDelete<IssmDouble>(epl_thickness);
    677677        xDelete<IssmDouble>(old_active);
    … …  
    690690        element->FindParam(&domaintype,DomainTypeEnum);
    691691        switch(domaintype){
    692                 case Mesh2DhorizontalEnum:
     692                case Domain2DhorizontalEnum:
    693693                        basalelement = element;
    694694                        break;
    695                 case Mesh3DEnum:
     695                case Domain3DEnum:
    696696                        if(!element->IsOnBase()) return;
    697697                        basalelement = element->SpawnBasalElement();
    … …  
    716716                /*Do not do anything: at least one node is active for this element but this element is not solved for*/
    717717        }
    718         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     718        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    719719        xDelete<IssmDouble>(active);
    720720}

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

    r17686 r17700  
    8888        iomodel->FetchDataToInput(elements,SedimentHeadEnum);
    8989        iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum);
    90         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
     90        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    9191
    9292        if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveNodeEnum);
    … …  
    101101        if(hydrology_model!=HydrologydcEnum) return;
    102102
    103         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     103        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     123        if(iomodel->domaintype==Domain3DEnum) 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->domaintype!=Mesh3DEnum){
     128                if (iomodel->domaintype!=Domain3DEnum){
    129129                        /*keep only this partition's nodes:*/
    130130                        if(iomodel->my_vertices[i]){
    … …  
    161161        element->FindParam(&domaintype,DomainTypeEnum);
    162162        switch(domaintype){
    163                 case Mesh2DhorizontalEnum:
     163                case Domain2DhorizontalEnum:
    164164                        basalelement = element;
    165165                        break;
    166                 case Mesh3DEnum:
     166                case Domain3DEnum:
    167167                        if(!element->IsOnBase()) return NULL;
    168168                        basalelement = element->SpawnBasalElement();
    … …  
    254254        xDelete<IssmDouble>(basis);
    255255        delete gauss;
    256         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     256        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    257257        return Ke;
    258258}/*}}}*/
    … …  
    266266        element->FindParam(&domaintype,DomainTypeEnum);
    267267        switch(domaintype){
    268                 case Mesh2DhorizontalEnum:
     268                case Domain2DhorizontalEnum:
    269269                        basalelement = element;
    270270                        break;
    271                 case Mesh3DEnum:
     271                case Domain3DEnum:
    272272                        if(!element->IsOnBase()) return NULL;
    273273                        basalelement = element->SpawnBasalElement();
    … …  
    357357        xDelete<IssmDouble>(basis);
    358358        delete gauss;
    359         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     359        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    360360        return pe;
    361361}/*}}}*/
    … …  
    398398
    399399        element->FindParam(&domaintype,DomainTypeEnum);
    400         if(domaintype!=Mesh2DhorizontalEnum){
     400        if(domaintype!=Domain2DhorizontalEnum){
    401401                if(!element->IsOnBase()) return;
    402402                basalelement=element->SpawnBasalElement();
    … …  
    446446        xDelete<IssmDouble>(residual);
    447447        xDelete<int>(doflist);
    448         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     448        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    449449}/*}}}*/
    450450void HydrologyDCInefficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/

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

    r17686 r17700  
    6262        if(hydrology_model!=HydrologyshreveEnum) return;
    6363
    64         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     64        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6565        ::CreateNodes(nodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
    6666        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);

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

    r17693 r17700  
    2626        iomodel->FetchDataToInput(elements,BaseEnum);
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    28         if(iomodel->domaintype==Mesh3DEnum){
     28        if(iomodel->domaintype==Domain3DEnum){
    2929                if(iomodel->meshelementtype==PentaEnum){
    3030                        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    … …  
    3333                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    35         if(iomodel->domaintype==Mesh2DverticalEnum){
     35        if(iomodel->domaintype==Domain2DverticalEnum){
    3636                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3737        }
    … …  
    3939void L2ProjectionBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4040
    41         if(iomodel->domaintype==Mesh3DEnum){
     41        if(iomodel->domaintype==Domain3DEnum){
    4242                iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4343        }
    44         else if(iomodel->domaintype==Mesh2DverticalEnum){
     44        else if(iomodel->domaintype==Domain2DverticalEnum){
    4545                iomodel->FetchData(1,MeshVertexonbaseEnum);
    4646        }
    … …  
    7777        element->FindParam(&domaintype,DomainTypeEnum);
    7878        switch(domaintype){
    79                 case Mesh2DhorizontalEnum:
     79                case Domain2DhorizontalEnum:
    8080                        basalelement = element;
    8181                        break;
    82                 case Mesh2DverticalEnum:
    83                         if(!element->IsOnBase()) return NULL;
    84                         basalelement = element->SpawnBasalElement();
    85                         break;
    86                 case Mesh3DEnum:
     82                case Domain2DverticalEnum:
     83                        if(!element->IsOnBase()) return NULL;
     84                        basalelement = element->SpawnBasalElement();
     85                        break;
     86                case Domain3DEnum:
    8787                        if(!element->IsOnBase()) return NULL;
    8888                        basalelement = element->SpawnBasalElement();
    … …  
    124124        xDelete<IssmDouble>(basis);
    125125        delete gauss;
    126         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     126        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    127127        return Ke;
    128128}/*}}}*/
    … …  
    136136        element->FindParam(&domaintype,DomainTypeEnum);
    137137        switch(domaintype){
    138                 case Mesh2DhorizontalEnum:
     138                case Domain2DhorizontalEnum:
    139139                        basalelement = element;
    140140                        break;
    141                 case Mesh2DverticalEnum:
    142                         if(!element->IsOnBase()) return NULL;
    143                         basalelement = element->SpawnBasalElement();
    144                         break;
    145                 case Mesh3DEnum:
     141                case Domain2DverticalEnum:
     142                        if(!element->IsOnBase()) return NULL;
     143                        basalelement = element->SpawnBasalElement();
     144                        break;
     145                case Domain3DEnum:
    146146                        if(!element->IsOnBase()) return NULL;
    147147                        basalelement = element->SpawnBasalElement();
    … …  
    199199        xDelete<IssmDouble>(basis);
    200200        delete gauss;
    201         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     201        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    202202        return pe;
    203203}/*}}}*/
    … …  
    213213        element->FindParam(&elementtype,MeshElementtypeEnum);
    214214        switch(domaintype){
    215                 case Mesh2DhorizontalEnum:
     215                case Domain2DhorizontalEnum:
    216216                        element->InputUpdateFromSolutionOneDof(solution,inputenum);
    217217                        break;
    218                 case Mesh2DverticalEnum:
     218                case Domain2DverticalEnum:
    219219                        element->InputUpdateFromSolutionOneDof(solution,inputenum);
    220220                        break;
    221                 case Mesh3DEnum:
     221                case Domain3DEnum:
    222222                        if(elementtype==TetraEnum)
    223223                         element->InputUpdateFromSolutionOneDof(solution,inputenum);

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

    r17686 r17700  
    3636        iomodel->FetchDataToInput(elements,EplHeadEnum);
    3737        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    38         if(iomodel->domaintype==Mesh3DEnum){
     38        if(iomodel->domaintype==Domain3DEnum){
    3939                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4040        }
    … …  
    5151        if(!isefficientlayer) return;
    5252
    53         if(iomodel->domaintype==Mesh3DEnum){
     53        if(iomodel->domaintype==Domain3DEnum){
    5454                iomodel->FetchData(1,MeshVertexonbaseEnum);
    5555        }
    56         else if(iomodel->domaintype==Mesh2DverticalEnum){
     56        else if(iomodel->domaintype==Domain2DverticalEnum){
    5757                iomodel->FetchData(1,MeshVertexonbaseEnum);
    5858        }
    … …  
    9090        element->FindParam(&domaintype,DomainTypeEnum);
    9191        switch(domaintype){
    92                 case Mesh2DhorizontalEnum:
     92                case Domain2DhorizontalEnum:
    9393                        basalelement = element;
    9494                        break;
    95                 case Mesh2DverticalEnum:
     95                case Domain2DverticalEnum:
    9696                        if(!element->IsOnBase()) return NULL;
    9797                        basalelement = element->SpawnBasalElement();
    9898                        break;
    99                 case Mesh3DEnum:
     99                case Domain3DEnum:
    100100                        if(!element->IsOnBase()) return NULL;
    101101                        basalelement = element->SpawnBasalElement();
    … …  
    109109        /* Check that all nodes are active, else return empty matrix */
    110110        if(!active_element){
    111                 if(domaintype!=Mesh2DhorizontalEnum){
     111                if(domaintype!=Domain2DhorizontalEnum){
    112112                        basalelement->DeleteMaterials();
    113113                        delete basalelement;
    … …  
    149149        xDelete<IssmDouble>(basis);
    150150        delete gauss;
    151         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     151        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    152152        return Ke;
    153153}/*}}}*/
    … …  
    162162        element->FindParam(&domaintype,DomainTypeEnum);
    163163        switch(domaintype){
    164                 case Mesh2DhorizontalEnum:
     164                case Domain2DhorizontalEnum:
    165165                        basalelement = element;
    166166                        break;
    167                 case Mesh3DEnum:
     167                case Domain3DEnum:
    168168                        if(!element->IsOnBase()) return NULL;
    169169                        basalelement = element->SpawnBasalElement();
    … …  
    177177        /*Check that all nodes are active, else return empty matrix*/
    178178        if(!active_element) {
    179                 if(domaintype!=Mesh2DhorizontalEnum){
     179                if(domaintype!=Domain2DhorizontalEnum){
    180180                        basalelement->DeleteMaterials();
    181181                        delete basalelement;
    … …  
    222222        xDelete<IssmDouble>(basis);
    223223        delete gauss;
    224         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     224        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    225225        return pe;
    226226}/*}}}*/
    … …  
    234234        element->FindParam(&domaintype,DomainTypeEnum);
    235235        switch(domaintype){
    236                 case Mesh2DhorizontalEnum:
     236                case Domain2DhorizontalEnum:
    237237                        element->InputUpdateFromSolutionOneDof(solution,inputenum);
    238238                        break;
    239                 case Mesh2DverticalEnum:
     239                case Domain2DverticalEnum:
    240240                        element->InputUpdateFromSolutionOneDof(solution,inputenum);
    241241                        break;
    242                 case Mesh3DEnum:
     242                case Domain3DEnum:
    243243                        element->InputUpdateFromSolutionOneDofCollapsed(solution,inputenum);
    244244                        break;

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

    r17686 r17700  
    4343void LevelsetAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4444        int finiteelement=P1Enum;
    45         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     45        if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4646        ::CreateNodes(nodes,iomodel,LevelsetAnalysisEnum,finiteelement);
    4747        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    105105        basalelement->FindParam(&domaintype,DomainTypeEnum);
    106106        switch(domaintype){
    107                 case Mesh2DverticalEnum:   dim = 1; break;
    108                 case Mesh2DhorizontalEnum: dim = 2; break;
    109                 case Mesh3DEnum:           dim = 2; break;
     107                case Domain2DverticalEnum:   dim = 1; break;
     108                case Domain2DhorizontalEnum: dim = 2; break;
     109                case Domain3DEnum:           dim = 2; break;
    110110                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    111111        }
    … …  
    130130        Input* vx_input=NULL;
    131131        Input* vy_input=NULL;
    132         if(domaintype==Mesh2DhorizontalEnum){
     132        if(domaintype==Domain2DhorizontalEnum){
    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(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     255        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    256256        return Ke;
    257257}/*}}}*/
    … …  
    299299                xDelete<IssmDouble>(basis);
    300300                basalelement->FindParam(&domaintype,DomainTypeEnum);
    301                 if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     301                if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    302302                delete gauss;
    303303        }
    … …  
    313313        element->FindParam(&domaintype,DomainTypeEnum);
    314314        switch(domaintype){
    315                 case Mesh2DhorizontalEnum:
     315                case Domain2DhorizontalEnum:
    316316                        element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum);
    317317                        break;
    318                 case Mesh3DEnum:
     318                case Domain3DEnum:
    319319                        element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum);
    320320                        break;

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

    r17692 r17700  
    3636void LsfReinitializationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737        int finiteelement=P1Enum;
    38         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     38        if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    3939        ::CreateNodes(nodes,iomodel,LsfReinitializationAnalysisEnum,finiteelement);
    4040        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    … …  
    252252
    253253        IssmDouble   lsf;
    254         int          domaintype,dim,dofpernode;
     254        int          dim;
    255255        int*         doflist = NULL;
    256256
    257257        /*Get some parameters*/
    258         element->FindParam(&domaintype,DomainTypeEnum);
    259         switch(domaintype){
    260                 case Mesh2DhorizontalEnum: dim = 2; dofpernode = 1; break;
    261                 case Mesh2DverticalEnum:   dim = 2; dofpernode = 1; break;
    262                 case Mesh3DEnum:           dim = 3; dofpernode = 1; break;
    263                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    264         }
     258        element->FindParam(&dim,DomainDimensionEnum);
    265259
    266260        /*Fetch number of nodes and dof for this finite element*/
    267261        int numnodes = element->GetNumberOfNodes();
    268         int numdof   = numnodes*dofpernode;
    269262
    270263        /*Fetch dof list and allocate solution vector*/
    271264        element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    272         IssmDouble* values = xNew<IssmDouble>(numdof);
     265        IssmDouble* values = xNew<IssmDouble>(numnodes);
    273266
    274267        /*Get inputs*/
    … …  
    280273
    281274                lsf_input->GetInputValue(&lsf,gauss);
    282                 values[i*dofpernode+0]=lsf;
    283         }
    284 
    285         solution->SetValues(numdof,doflist,values,INS_VAL);
     275                values[i]=lsf;
     276        }
     277
     278        solution->SetValues(numnodes,doflist,values,INS_VAL);
    286279
    287280        /*Free ressources:*/
    … …  
    296289        element->FindParam(&domaintype,DomainTypeEnum);
    297290        switch(domaintype){
    298                 case Mesh2DhorizontalEnum:
     291                case Domain2DhorizontalEnum:
    299292                        element->InputUpdateFromSolutionOneDof(solution,MaskIceLevelsetEnum);
    300293                        break;
    301                 case Mesh3DEnum:
     294                case Domain3DEnum:
    302295                        element->InputUpdateFromSolutionOneDofCollapsed(solution,MaskIceLevelsetEnum);
    303296                        break;

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

    r17686 r17700  
    8383        }
    8484
    85         if(iomodel->domaintype==Mesh3DEnum){
     85        if(iomodel->domaintype==Domain3DEnum){
    8686                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    8787                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    … …  
    9090        if(islevelset){
    9191                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    92                 if(iomodel->domaintype!=Mesh2DhorizontalEnum)
     92                if(iomodel->domaintype!=Domain2DhorizontalEnum)
    9393                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    9494        }
    … …  
    132132
    133133        /*Check in 3d*/
    134         if(stabilization==3 && iomodel->domaintype==Mesh3DEnum) _error_("DG 3d not implemented yet");
     134        if(stabilization==3 && iomodel->domaintype==Domain3DEnum) _error_("DG 3d not implemented yet");
    135135
    136136        /*Create Nodes either DG or CG depending on stabilization*/
    137         if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     137        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
     197        if(iomodel->domaintype!=Domain2DhorizontalEnum) 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->domaintype!=Mesh2DhorizontalEnum){
     207                        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    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                        }
    … …  
    261261        int domaintype;
    262262        element->FindParam(&domaintype,DomainTypeEnum);
    263         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     263        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    264264        return Ke;
    265265}/*}}}*/
    … …  
    280280        element->FindParam(&domaintype,DomainTypeEnum);
    281281        switch(domaintype){
    282                 case Mesh2DverticalEnum:   dim = 1; break;
    283                 case Mesh2DhorizontalEnum: dim = 2; break;
    284                 case Mesh3DEnum:           dim = 2; break;
     282                case Domain2DverticalEnum:   dim = 1; break;
     283                case Domain2DhorizontalEnum: dim = 2; break;
     284                case Domain3DEnum:           dim = 2; break;
    285285                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    286286        }
    … …  
    303303        Input* vxaverage_input=NULL;
    304304        Input* vyaverage_input=NULL;
    305         if(domaintype==Mesh2DhorizontalEnum){
     305        if(domaintype==Domain2DhorizontalEnum){
    306306                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    307307                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    435435        Input* vxaverage_input=NULL;
    436436        Input* vyaverage_input=NULL;
    437         if(domaintype==Mesh2DhorizontalEnum){
     437        if(domaintype==Domain2DhorizontalEnum){
    438438                vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    439439                vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    507507        int domaintype;
    508508        element->FindParam(&domaintype,DomainTypeEnum);
    509         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     509        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    510510        return pe;
    511511}/*}}}*/
    … …  
    676676
    677677        element->FindParam(&domaintype,DomainTypeEnum);
    678         if(domaintype!=Mesh2DhorizontalEnum){
     678        if(domaintype!=Domain2DhorizontalEnum){
    679679                if(!element->IsOnBase()) return;
    680680                basalelement=element->SpawnBasalElement();
    … …  
    750750        xDelete<IssmDouble>(phi);
    751751        xDelete<int>(doflist);
    752         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     752        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    753753}/*}}}*/
    754754void MasstransportAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/

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

    r17686 r17700  
    1414
    1515        /*Now, is the model 3d? otherwise, do nothing: */
    16         if(iomodel->domaintype==Mesh2DhorizontalEnum)return;
     16        if(iomodel->domaintype==Domain2DhorizontalEnum)return;
    1717
    1818        /*Update elements: */
    … …  
    4444void MeltingAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4545
    46         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     46        if(iomodel->domaintype==Domain3DEnum) 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->domaintype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
     56        if(iomodel->domaintype==Domain2DhorizontalEnum) _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/SmoothedSurfaceSlopeXAnalysis.cpp

    r17686 r17700  
    2626        iomodel->FetchDataToInput(elements,BaseEnum);
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    28         if(iomodel->domaintype==Mesh3DEnum){
     28        if(iomodel->domaintype==Domain3DEnum){
    2929                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    32         if(iomodel->domaintype==Mesh2DverticalEnum){
     32        if(iomodel->domaintype==Domain2DverticalEnum){
    3333                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    3636void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    37         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     37        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    3838        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum);
    39         if(iomodel->domaintype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
     39        if(iomodel->domaintype==Domain3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
    4040}/*}}}*/
    4141void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    111111        element->FindParam(&domaintype,DomainTypeEnum);
    112112        switch(domaintype){
    113                 case Mesh2DhorizontalEnum:
     113                case Domain2DhorizontalEnum:
    114114                        basalelement = element;
    115115                        break;
    116                 case Mesh3DEnum:
     116                case Domain3DEnum:
    117117                        if(!element->IsOnBase()) return NULL;
    118118                        basalelement = element->SpawnBasalElement();
    … …  
    169169        xDelete<IssmDouble>(basis);
    170170        delete gauss;
    171         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     171        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    172172        return pe;
    173173}/*}}}*/

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

    r17686 r17700  
    2626        iomodel->FetchDataToInput(elements,BaseEnum);
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    28         if(iomodel->domaintype==Mesh3DEnum){
     28        if(iomodel->domaintype==Domain3DEnum){
    2929                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    32         if(iomodel->domaintype==Mesh2DverticalEnum){
     32        if(iomodel->domaintype==Domain2DverticalEnum){
    3333                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    3636void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    37         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
     37        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    3838        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum);
    39         if(iomodel->domaintype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
     39        if(iomodel->domaintype==Domain3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
    4040}/*}}}*/
    4141void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    111111        element->FindParam(&domaintype,DomainTypeEnum);
    112112        switch(domaintype){
    113                 case Mesh2DhorizontalEnum:
     113                case Domain2DhorizontalEnum:
    114114                        basalelement = element;
    115115                        break;
    116                 case Mesh3DEnum:
     116                case Domain3DEnum:
    117117                        if(!element->IsOnBase()) return NULL;
    118118                        basalelement = element->SpawnBasalElement();
    … …  
    169169        xDelete<IssmDouble>(basis);
    170170        delete gauss;
    171         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     171        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    172172        return pe;
    173173}/*}}}*/

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

    r17693 r17700  
    1919                case SSAApproximationEnum:
    2020                         switch(domaintype){
    21                                  case Mesh3DEnum:           numdofs=2; break;
    22                                  case Mesh2DhorizontalEnum: numdofs=2; break;
    23                                  case Mesh2DverticalEnum:   numdofs=1; break;
     21                                 case Domain3DEnum:           numdofs=2; break;
     22                                 case Domain2DhorizontalEnum: numdofs=2; break;
     23                                 case Domain2DverticalEnum:   numdofs=1; break;
    2424                                 default: _error_("mesh type not supported yet");
    2525                         }
    … …  
    2828                case HOApproximationEnum:   
    2929                         switch(domaintype){
    30                                  case Mesh3DEnum:         numdofs=2; break;
    31                                  case Mesh2DverticalEnum: numdofs=1; break;
     30                                 case Domain3DEnum:         numdofs=2; break;
     31                                 case Domain2DverticalEnum: numdofs=1; break;
    3232                                 default: _error_("mesh type not supported yet");
    3333                         }
    … …  
    3636                case FSvelocityEnum:
    3737                         switch(domaintype){
    38                                  case Mesh3DEnum:         numdofs=3; break;
    39                                  case Mesh2DverticalEnum: numdofs=2; break;
     38                                 case Domain3DEnum:         numdofs=3; break;
     39                                 case Domain2DverticalEnum: numdofs=2; break;
    4040                                 default: _error_("mesh type not supported yet");
    4141                        }
    … …  
    4444                case NoneApproximationEnum:
    4545                         switch(domaintype){
    46                                  case Mesh3DEnum:         numdofs=4; break;
    47                                  case Mesh2DverticalEnum: numdofs=3; break;
     46                                 case Domain3DEnum:         numdofs=4; break;
     47                                 case Domain2DverticalEnum: numdofs=3; break;
    4848                                 default: _error_("mesh type not supported yet");
    4949                        }
    … …  
    214214        iomodel->FetchDataToInput(elements,DamageDEnum);
    215215
    216         if(iomodel->domaintype==Mesh3DEnum){
     216        if(iomodel->domaintype==Domain3DEnum){
    217217                if(iomodel->meshelementtype==PentaEnum){
    218218                        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    … …  
    225225                if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum);
    226226        }
    227         if(iomodel->domaintype==Mesh2DverticalEnum){
     227        if(iomodel->domaintype==Domain2DverticalEnum){
    228228                iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
    229229        }
    … …  
    235235        if(islevelset){
    236236                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    237                 if(iomodel->domaintype!=Mesh2DhorizontalEnum)
     237                if(iomodel->domaintype!=Domain2DhorizontalEnum)
    238238                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    239239        }
    … …  
    289289                }
    290290                iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    291                 if(iomodel->domaintype!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
     291                if(iomodel->domaintype!=Domain2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
    292292                ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
    293293                iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    … …  
    421421                        iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    422422                        iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    423                         if(iomodel->domaintype==Mesh3DEnum){
     423                        if(iomodel->domaintype==Domain3DEnum){
    424424                                iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    425425                        }
    426                         else if (iomodel->domaintype==Mesh2DverticalEnum){
     426                        else if (iomodel->domaintype==Domain2DverticalEnum){
    427427                                iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvyEnum);
    428428                        }
    … …  
    430430                                _error_("not supported yet");
    431431                        }
    432                         if(iomodel->domaintype==Mesh3DEnum){
     432                        if(iomodel->domaintype==Domain3DEnum){
    433433                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0);
    434434                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1);
    … …  
    436436                                iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    437437                        }
    438                         else if (iomodel->domaintype==Mesh2DverticalEnum){
     438                        else if (iomodel->domaintype==Domain2DverticalEnum){
    439439                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0);
    440440                                IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,finiteelement,1);
    … …  
    497497                else{
    498498                        IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,0);
    499                         if(iomodel->domaintype!=Mesh2DverticalEnum){
     499                        if(iomodel->domaintype!=Domain2DverticalEnum){
    500500                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,1);
    501501                        }
    … …  
    510510        iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    511511        iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum);
    512         if(iomodel->domaintype==Mesh3DEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
    513         if(iomodel->domaintype==Mesh3DEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    514         if(iomodel->domaintype==Mesh3DEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    515         if(iomodel->domaintype==Mesh3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
     512        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
     513        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
     514        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
     515        if(iomodel->domaintype==Domain3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    516516        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    517517        iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum);
    … …  
    740740        iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    741741        iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum);
    742         if(iomodel->domaintype==Mesh3DEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
    743         if(iomodel->domaintype==Mesh3DEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    744         if(iomodel->domaintype==Mesh3DEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
    745         if(iomodel->domaintype==Mesh3DEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
     742        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
     743        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
     744        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
     745        if(iomodel->domaintype==Domain3DEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
    746746        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);
    747747        iomodel->DeleteData(surface,SurfaceEnum);
    … …  
    856856                 solutionsequence_nonlinear(femmodel,conserve_loads);
    857857
    858                 if(domaintype==Mesh2DverticalEnum && isSSA){
     858                if(domaintype==Domain2DverticalEnum && isSSA){
    859859                        femmodel->parameters->SetParam(VxEnum,InputToExtrudeEnum);
    860860                        extrudefrombase_core(femmodel);
    … …  
    985985        element->FindParam(&domaintype,DomainTypeEnum);
    986986        switch(domaintype){
    987                 case Mesh2DhorizontalEnum: dim = 2; dofpernode = 2; break;
    988                 case Mesh2DverticalEnum:   dim = 2; dofpernode = 1; break;
    989                 case Mesh3DEnum:           dim = 3; dofpernode = 2; break;
     987                case Domain2DhorizontalEnum: dim = 2; dofpernode = 2; break;
     988                case Domain2DverticalEnum:   dim = 2; dofpernode = 1; break;
     989                case Domain3DEnum:           dim = 3; dofpernode = 2; break;
    990990                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    991991        }
    … …  
    10031003        Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    10041004        Input* vy_input=NULL;
    1005         if(domaintype!=Mesh2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);}
     1005        if(domaintype!=Domain2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);}
    10061006
    10071007        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    10781078        element->FindParam(&domaintype,DomainTypeEnum);
    10791079        switch(domaintype){
    1080                 case Mesh2DhorizontalEnum:
     1080                case Domain2DhorizontalEnum:
    10811081                        basalelement = element;
    10821082                        break;
    1083                 case Mesh3DEnum:
     1083                case Domain3DEnum:
    10841084                        if(!element->IsOnBase()) return NULL;
    10851085                        basalelement = element->SpawnBasalElement();
    … …  
    11481148
    11491149        /*clean-up and return*/
    1150         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1150        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    11511151        return Ke;
    11521152
    … …  
    11641164        element->FindParam(&domaintype,DomainTypeEnum);
    11651165        switch(domaintype){
    1166                 case Mesh2DhorizontalEnum:
     1166                case Domain2DhorizontalEnum:
    11671167                        basalelement = element;
    11681168                        break;
    1169                 case Mesh3DEnum: case Mesh2DverticalEnum:
     1169                case Domain3DEnum: case Domain2DverticalEnum:
    11701170                        if(!element->IsOnBase()) return NULL;
    11711171                        basalelement = element->SpawnBasalElement();
    … …  
    11801180
    11811181        /*clean-up and return*/
    1182         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1182        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    11831183        delete Ke1;
    11841184        delete Ke2;
    … …  
    12021202        element->FindParam(&domaintype,DomainTypeEnum);
    12031203        switch(domaintype){
    1204                 case Mesh2DverticalEnum:   dim = 1;break;
    1205                 case Mesh2DhorizontalEnum: dim = 2;break;
    1206                 case Mesh3DEnum:           dim = 2;break;
     1204                case Domain2DverticalEnum:   dim = 1;break;
     1205                case Domain2DhorizontalEnum: dim = 2;break;
     1206                case Domain3DEnum:           dim = 2;break;
    12071207                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    12081208        }
    … …  
    12871287        element->FindParam(&domaintype,DomainTypeEnum);
    12881288        switch(domaintype){
    1289                 case Mesh2DverticalEnum:   dim = 1; bsize = 1; break;
    1290                 case Mesh2DhorizontalEnum: dim = 2; bsize = 3; break;
    1291                 case Mesh3DEnum:           dim = 2; bsize = 3; break;
     1289                case Domain2DverticalEnum:   dim = 1; bsize = 1; break;
     1290                case Domain2DhorizontalEnum: dim = 2; bsize = 3; break;
     1291                case Domain3DEnum:           dim = 2; bsize = 3; break;
    12921292                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    12931293        }
    … …  
    13651365        element->FindParam(&domaintype,DomainTypeEnum);
    13661366        switch(domaintype){
    1367                 case Mesh2DhorizontalEnum:
     1367                case Domain2DhorizontalEnum:
    13681368                        basalelement = element;
    13691369                        break;
    1370                 case Mesh3DEnum: case Mesh2DverticalEnum:
     1370                case Domain3DEnum: case Domain2DverticalEnum:
    13711371                        if(!element->IsOnBase()) return NULL;
    13721372                        basalelement = element->SpawnBasalElement();
    … …  
    13811381
    13821382        /*clean-up and return*/
    1383         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1383        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    13841384        delete pe1;
    13851385        delete pe2;
    … …  
    13991399        element->FindParam(&domaintype,DomainTypeEnum);
    14001400        switch(domaintype){
    1401                 case Mesh2DverticalEnum:   dim = 1;break;
    1402                 case Mesh2DhorizontalEnum: dim = 2;break;
    1403                 case Mesh3DEnum:           dim = 2;break;
     1401                case Domain2DverticalEnum:   dim = 1;break;
     1402                case Domain2DhorizontalEnum: dim = 2;break;
     1403                case Domain3DEnum:           dim = 2;break;
    14041404                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    14051405        }
    … …  
    14641464        element->FindParam(&domaintype,DomainTypeEnum);
    14651465        switch(domaintype){
    1466                 case Mesh2DverticalEnum:   dim = 1;break;
    1467                 case Mesh2DhorizontalEnum: dim = 2;break;
    1468                 case Mesh3DEnum:           dim = 2;break;
     1466                case Domain2DverticalEnum:   dim = 1;break;
     1467                case Domain2DhorizontalEnum: dim = 2;break;
     1468                case Domain3DEnum:           dim = 2;break;
    14691469                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    14701470        }
    … …  
    16551655        g       =element->GetMaterialParameter(ConstantsGEnum);
    16561656        switch(domaintype){
    1657                 case Mesh2DhorizontalEnum:
     1657                case Domain2DhorizontalEnum:
    16581658                        element->GetInputListOnVertices(thickness,ThicknessEnum);
    16591659                        for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*thickness[i];
    16601660                        dim=2;
    16611661                        break;
    1662                 case Mesh3DEnum:
     1662                case Domain3DEnum:
    16631663                        element->GetVerticesCoordinates(&xyz_list);
    16641664                        element->GetInputListOnVertices(surface,SurfaceEnum);
    … …  
    16661666                        dim=2;
    16671667                        break;
    1668                 case Mesh2DverticalEnum:
     1668                case Domain2DverticalEnum:
    16691669                        element->GetVerticesCoordinates(&xyz_list);
    16701670                        element->GetInputListOnVertices(surface,SurfaceEnum);
    … …  
    16811681        /*Get basal element*/
    16821682        switch(domaintype){
    1683                 case Mesh2DhorizontalEnum:
     1683                case Domain2DhorizontalEnum:
    16841684                        basalelement = element;
    16851685                        break;
    1686                 case Mesh3DEnum: case Mesh2DverticalEnum:
     1686                case Domain3DEnum: case Domain2DverticalEnum:
    16871687                        if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
    16881688                        basalelement=element->SpawnBasalElement();
    … …  
    17481748        xDelete<IssmDouble>(xyz_list);
    17491749        xDelete<int>(doflist);
    1750         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1750        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    17511751}/*}}}*/
    17521752
    … …  
    18431843        element->FindParam(&domaintype,DomainTypeEnum);
    18441844        switch(domaintype){
    1845                 case Mesh2DhorizontalEnum:
     1845                case Domain2DhorizontalEnum:
    18461846                        basalelement = element;
    18471847                        break;
    1848                 case Mesh3DEnum:
     1848                case Domain3DEnum: case Domain2DverticalEnum:
    18491849                        if(!element->IsOnBase()) return NULL;
    18501850                        basalelement = element->SpawnBasalElement();
    … …  
    18591859
    18601860        /*clean-up and return*/
    1861         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     1861        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    18621862        delete pe1;
    18631863        delete pe2;
    … …  
    19731973void StressbalanceAnalysis::InputUpdateFromSolutionL1L2(IssmDouble* solution,Element* element){/*{{{*/
    19741974
    1975         int         i,domaintype;
     1975        int         i,dim,domaintype;
    19761976        IssmDouble  rho_ice,g;
    19771977        int*        doflist=NULL;
    … …  
    19851985        IssmDouble* surface   = xNew<IssmDouble>(numvertices);
    19861986
     1987        element->FindParam(&dim,DomainDimensionEnum);
    19871988        element->FindParam(&domaintype,DomainTypeEnum);
    19881989        rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    19891990        g       =element->GetMaterialParameter(ConstantsGEnum);
    1990         switch(domaintype){
    1991                 case Mesh2DhorizontalEnum:
    1992                         element->GetInputListOnVertices(thickness,ThicknessEnum);
    1993                         for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*thickness[i];
    1994                         break;
    1995                 case Mesh3DEnum:
    1996                         element->GetVerticesCoordinates(&xyz_list);
    1997                         element->GetInputListOnVertices(surface,SurfaceEnum);
    1998                         for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
    1999                         break;
    2000                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
     1991        if(dim==2){
     1992                element->GetInputListOnVertices(thickness,ThicknessEnum);
     1993                for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*thickness[i];
     1994        }
     1995        else{
     1996                element->GetVerticesCoordinates(&xyz_list);
     1997                element->GetInputListOnVertices(surface,SurfaceEnum);
     1998                for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
    20011999        }
    20022000        element->AddInput(PressureEnum,pressure,P1Enum);
    … …  
    20072005        /*Get basal element*/
    20082006        switch(domaintype){
    2009                 case Mesh2DhorizontalEnum:
     2007                case Domain2DhorizontalEnum:
    20102008                        basalelement = element;
    20112009                        break;
    2012                 case Mesh3DEnum:
     2010                case Domain3DEnum:
    20132011                        if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
    20142012                        basalelement=element->SpawnBasalElement();
    … …  
    20682066        xDelete<IssmDouble>(xyz_list);
    20692067        xDelete<int>(doflist);
    2070         if(domaintype!=Mesh2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
     2068        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    20712069}/*}}}*/
    20722070
    … …  
    21542152
    21552153        /*Intermediaries*/
    2156         int         dim,domaintype,bsize;
     2154        int         dim,bsize;
    21572155        IssmDouble  viscosity,newviscosity,oldviscosity;
    21582156        IssmDouble  viscosity_overshoot,thickness,Jdet;
    … …  
    21612159
    21622160        /*Get problem dimension*/
    2163         element->FindParam(&domaintype,DomainTypeEnum);
    2164         switch(domaintype){
    2165                 case Mesh2DverticalEnum: dim = 2; bsize = 2; break;
    2166                 case Mesh3DEnum:         dim = 3; bsize = 5; break;
    2167                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2168         }
     2161        element->FindParam(&dim,DomainDimensionEnum);
     2162        if(dim==2) bsize = 2;
     2163        else       bsize = 5;
    21692164
    21702165        /*Fetch number of nodes and dof for this finite element*/
    … …  
    22312226
    22322227        /*Intermediaries*/
    2233         int         dim,domaintype;
     2228        int         dim;
    22342229        bool        mainlyfloating;
    22352230        int         migration_style,point1;
    … …  
    22402235
    22412236        /*Get problem dimension*/
    2242         element->FindParam(&domaintype,DomainTypeEnum);
    2243         switch(domaintype){
    2244                 case Mesh2DverticalEnum: dim = 2; break;
    2245                 case Mesh3DEnum:         dim = 3; break;
    2246                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2247         }
     2237        element->FindParam(&dim,DomainDimensionEnum);
    22482238
    22492239        /*Fetch number of nodes and dof for this finite element*/
    … …  
    23192309
    23202310        /*Intermediaries */
    2321         int         dim,domaintype;
     2311        int         dim;
    23222312        IssmDouble  x_coord,y_coord,z_coord;
    23232313        IssmDouble  Jdet,forcex,forcey,forcez;
    … …  
    23252315
    23262316        /*Get problem dimension*/
    2327         element->FindParam(&domaintype,DomainTypeEnum);
    2328         switch(domaintype){
    2329                 case Mesh2DverticalEnum: dim = 2; break;
    2330                 case Mesh3DEnum:         dim = 3; break;
    2331                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2332         }
     2317        element->FindParam(&dim,DomainDimensionEnum);
    23332318
    23342319        /*Fetch number of nodes and dof for this finite element*/
    … …  
    23962381
    23972382        /*Intermediaries */
    2398         int         dim,domaintype;
     2383        int         dim;
    23992384        IssmDouble  Jdet,slope[3];
    24002385        IssmDouble* xyz_list = NULL;
    24012386
    24022387        /*Get problem dimension*/
    2403         element->FindParam(&domaintype,DomainTypeEnum);
    2404         switch(domaintype){
    2405                 case Mesh2DverticalEnum: dim = 2; break;
    2406                 case Mesh3DEnum:         dim = 3; break;
    2407                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2408         }
     2388        element->FindParam(&dim,DomainDimensionEnum);
    24092389
    24102390        /*Fetch number of nodes and dof for this finite element*/
    … …  
    24532433
    24542434        /*Intermediaries*/
    2455         int         dim,domaintype;
     2435        int         dim;
    24562436        IssmDouble  Jdet,surface,z,water_pressure,ice_pressure;
    24572437        IssmDouble  surface_under_water,base_under_water,pressure;
    … …  
    24622442
    24632443        /*Get problem dimension*/
    2464         element->FindParam(&domaintype,DomainTypeEnum);
    2465         switch(domaintype){
    2466                 case Mesh2DverticalEnum: dim = 2; break;
    2467                 case Mesh3DEnum:         dim = 3; break;
    2468                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2469         }
     2444        element->FindParam(&dim,DomainDimensionEnum);
    24702445
    24712446        /*Fetch number of nodes and dof for this finite element*/
    … …  
    26552630void StressbalanceAnalysis::InputUpdateFromSolutionHO(IssmDouble* solution,Element* element){/*{{{*/
    26562631
    2657         int         i,dim,domaintype;
     2632        int         i,dim;
    26582633        int*        doflist=NULL;
    26592634        IssmDouble* xyz_list=NULL;
    26602635
    26612636        /*Get mesh dimension*/
    2662         element->FindParam(&domaintype,DomainTypeEnum);
    2663         switch(domaintype){
    2664                 case Mesh2DverticalEnum: dim = 2; break;
    2665                 case Mesh3DEnum:         dim = 3; break;
    2666                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2667         }
     2637        element->FindParam(&dim,DomainDimensionEnum);
    26682638
    26692639        /*Deal with pressure first*/
    … …  
    27442714ElementVector* StressbalanceAnalysis::CreateDVectorFS(Element* element){/*{{{*/
    27452715
    2746         int         domaintype,dim;
     2716        int dim;
    27472717
    27482718        /*Get problem dimension*/
    2749         element->FindParam(&domaintype,DomainTypeEnum);
    2750         switch(domaintype){
    2751                 case Mesh2DverticalEnum: dim = 2; break;
    2752                 case Mesh3DEnum:         dim = 3; break;
    2753                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2754         }
     2719        element->FindParam(&dim,DomainDimensionEnum);
    27552720
    27562721        /*Fetch number of nodes and dof for this finite element*/
    … …  
    28822847
    28832848        /*Intermediaries*/
    2884         int         i,domaintype,dim,epssize;
     2849        int         i,dim,epssize;
    28852850        IssmDouble  r,FSreconditioning,Jdet;
    28862851        IssmDouble *xyz_list = NULL;
    28872852
    28882853        /*Get problem dimension*/
    2889         element->FindParam(&domaintype,DomainTypeEnum);
     2854        element->FindParam(&dim,DomainDimensionEnum);
    28902855        element->FindParam(&r,AugmentedLagrangianREnum);
    2891         switch(domaintype){
    2892                 case Mesh2DverticalEnum: dim = 2; epssize = 3; break;
    2893                 case Mesh3DEnum:         dim = 3; epssize = 6; break;
    2894                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2895         }
     2856        if(dim==2) epssize = 3;
     2857        else       epssize = 6;
    28962858
    28972859        /*Fetch number of nodes and dof for this finite element*/
    … …  
    29542916
    29552917        /*Intermediaries*/
    2956         int         i,domaintype,dim,epssize;
     2918        int         i,dim,epssize;
    29572919        IssmDouble  viscosity,FSreconditioning,Jdet;
    29582920        IssmDouble *xyz_list = NULL;
    29592921
    29602922        /*Get problem dimension*/
    2961         element->FindParam(&domaintype,DomainTypeEnum);
    2962         switch(domaintype){
    2963                 case Mesh2DverticalEnum: dim = 2; epssize = 3; break;
    2964                 case Mesh3DEnum:         dim = 3; epssize = 6; break;
    2965                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    2966         }
     2923        element->FindParam(&dim,DomainDimensionEnum);
     2924        if(dim==2) epssize = 3;
     2925        else       epssize = 6;
    29672926
    29682927        /*Fetch number of nodes and dof for this finite element*/
    … …  
    30362995        /*Intermediaries*/
    30372996        bool        mainlyfloating;
    3038         int         j,i,domaintype,dim;
     2997        int         j,i,dim;
    30392998        IssmDouble  Jdet,slope2,scalar,dt;
    30402999        IssmDouble  slope[3];
    … …  
    30443003
    30453004        /*Get problem dimension*/
    3046         element->FindParam(&domaintype,DomainTypeEnum);
    3047         switch(domaintype){
    3048                 case Mesh2DverticalEnum: dim = 2;break;
    3049                 case Mesh3DEnum:         dim = 3;break;
    3050                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3051         }
     3005        element->FindParam(&dim,DomainDimensionEnum);
    30523006
    30533007        /*Fetch number of nodes and dof for this finite element*/
    … …  
    31073061
    31083062        /*Intermediaries*/
    3109         int         i,domaintype,dim;
     3063        int         i,dim;
    31103064        IssmDouble  alpha2,Jdet;
    31113065        IssmDouble  x_coord,y_coord,z_coord;
    … …  
    31143068
    31153069        /*Get problem dimension*/
    3116         element->FindParam(&domaintype,DomainTypeEnum);
    3117         switch(domaintype){
    3118                 case Mesh2DverticalEnum: dim = 2;break;
    3119                 case Mesh3DEnum:         dim = 3;break;
    3120                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3121         }
     3070        element->FindParam(&dim,DomainDimensionEnum);
    31223071
    31233072        /*Fetch number of nodes and dof for this finite element*/
    … …  
    31713120ElementVector* StressbalanceAnalysis::CreatePVectorFS(Element* element){/*{{{*/
    31723121
    3173         int         i,domaintype,dim,fe_FS;
     3122        int         i,dim,fe_FS;
    31743123        IssmDouble  x_coord,y_coord,z_coord;
    31753124        IssmDouble  Jdet,forcex,forcey,forcez;
    … …  
    31773126
    31783127        element->FindParam(&fe_FS,FlowequationFeFSEnum);
    3179         element->FindParam(&domaintype,DomainTypeEnum);
    3180         switch(domaintype){
    3181                 case Mesh2DverticalEnum: dim = 2; break;
    3182                 case Mesh3DEnum:         dim = 3; break;
    3183                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3184         }
     3128        element->FindParam(&dim,DomainDimensionEnum);
    31853129
    31863130        /*Fetch number of nodes and dof for this finite element*/
    … …  
    32543198        /*Intermediaries*/
    32553199        bool        mainlyfloating;
    3256         int         i,domaintype,dim,epssize;
     3200        int         i,dim,domaintype,epssize;
    32573201        int         migration_style,point1;
    32583202        IssmDouble  alpha2,Jdet,fraction1,fraction2;
    … …  
    32623206
    32633207        /*Get problem dimension*/
     3208        element->FindParam(&dim,DomainDimensionEnum);
    32643209        element->FindParam(&domaintype,DomainTypeEnum);
    3265         switch(domaintype){
    3266                 case Mesh2DverticalEnum: dim = 2;break;
    3267                 case Mesh3DEnum:         dim = 3;break;
    3268                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3269         }
    32703210
    32713211        /*Fetch number of nodes and dof for this finite element*/
    … …  
    32943234        if(migration_style==SubelementMigrationEnum) phi=element->GetGroundedPortion(xyz_list_base);
    32953235        if(migration_style==SubelementMigration2Enum){
    3296                 if(domaintype==Mesh2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline");
     3236                if(domaintype==Domain2DverticalEnum) _error_("Subelement Migration 2 not implemented yet for Flowline");
    32973237                gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    32983238                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    … …  
    33713311ElementVector* StressbalanceAnalysis::CreatePVectorFSViscous(Element* element){/*{{{*/
    33723312
    3373         int         i,domaintype,dim;
     3313        int         i,dim;
    33743314        IssmDouble  Jdet,forcex,forcey,forcez;
    33753315        IssmDouble *xyz_list = NULL;
    33763316
    33773317        /*Get problem dimension*/
    3378         element->FindParam(&domaintype,DomainTypeEnum);
    3379         switch(domaintype){
    3380                 case Mesh2DverticalEnum: dim = 2; break;
    3381                 case Mesh3DEnum:         dim = 3; break;
    3382                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3383         }
     3318        element->FindParam(&dim,DomainDimensionEnum);
    33843319
    33853320        /*Fetch number of nodes and dof for this finite element*/
    … …  
    34453380ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousXTH(Element* element){/*{{{*/
    34463381
    3447         int         i,tausize,domaintype,dim;
     3382        int         i,tausize,dim;
    34483383        IssmDouble  Jdet,r;
    34493384        IssmDouble  epsxx,epsyy,epszz,epsxy,epsxz,epsyz;
    … …  
    34533388
    34543389        /*Get problem dimension*/
    3455         element->FindParam(&domaintype,DomainTypeEnum);
    3456         switch(domaintype){
    3457                 case Mesh2DverticalEnum: dim = 2; tausize = 3; break;
    3458                 case Mesh3DEnum:         dim = 3; tausize = 6; break;
    3459                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3460         }
     3390        element->FindParam(&dim,DomainDimensionEnum);
     3391        if(dim==2) tausize = 3;
     3392        else       tausize = 6;
    34613393
    34623394        /*Fetch number of nodes and dof for this finite element*/
    … …  
    36203552ElementVector* StressbalanceAnalysis::CreatePVectorFSShelf(Element* element){/*{{{*/
    36213553
    3622         int         i,domaintype,dim;
     3554        int         i,dim;
    36233555        IssmDouble  Jdet,water_pressure,bed;
    36243556        IssmDouble      normal[3];
    … …  
    36293561
    36303562        /*Get problem dimension*/
    3631         element->FindParam(&domaintype,DomainTypeEnum);
    3632         switch(domaintype){
    3633                 case Mesh2DverticalEnum: dim = 2; break;
    3634                 case Mesh3DEnum:         dim = 3; break;
    3635                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3636         }
     3563        element->FindParam(&dim,DomainDimensionEnum);
    36373564
    36383565        /*Fetch number of nodes and dof for this finite element*/
    … …  
    36943621
    36953622        /*Intermediaries*/
    3696         int         i,domaintype,dim;
     3623        int         i,dim;
    36973624        IssmDouble  Jdet,pressure,surface,z;
    36983625        IssmDouble      normal[3];
    … …  
    37053632
    37063633        /*Get problem dimension*/
    3707         element->FindParam(&domaintype,DomainTypeEnum);
    3708         switch(domaintype){
    3709                 case Mesh2DverticalEnum: dim = 2; break;
    3710                 case Mesh3DEnum:         dim = 3; break;
    3711                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3712         }
     3634        element->FindParam(&dim,DomainDimensionEnum);
    37133635
    37143636        /*Fetch number of nodes and dof for this finite element*/
    … …  
    40513973        int*         pdoflist=NULL;
    40523974        Input*       vz_input=NULL;
    4053         int          domaintype,dim;
     3975        int          dim;
    40543976        IssmDouble   vx,vy,vz,p;
    40553977        IssmDouble   FSreconditioning;
    40563978
    40573979        /*Get some parameters*/
    4058         element->FindParam(&domaintype,DomainTypeEnum);
     3980        element->FindParam(&dim,DomainDimensionEnum);
    40593981        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    4060         switch(domaintype){
    4061                 case Mesh2DverticalEnum: dim = 2; break;
    4062                 case Mesh3DEnum:         dim = 3; break;
    4063                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    4064         }
    40653982
    40663983        /*Fetch number of nodes and dof for this finite element*/
    … …  
    41174034
    41184035        /*Intermediaries*/
    4119         int        domaintype,dim;
     4036        int        dim;
    41204037        IssmDouble dvx[3],dvy[3],dvz[3];
    41214038        IssmDouble viscosity;
    … …  
    41234040
    41244041        /*Get problem dimension*/
    4125         parameters->FindParam(&domaintype,DomainTypeEnum);
    4126         switch(domaintype){
    4127                 case Mesh2DverticalEnum: dim = 2; break;
    4128                 case Mesh3DEnum:         dim = 3; break;
    4129                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    4130         }
     4042        parameters->FindParam(&dim,DomainDimensionEnum);
    41314043
    41324044        for(int i=0;i<elements->Size();i++){
    … …  
    42014113
    42024114        bool         results_on_nodes;
    4203         int          i,dim,domaintype;
     4115        int          i,dim;
    42044116        int*         vdoflist=NULL;
    42054117        int*         pdoflist=NULL;
    42064118        IssmDouble   FSreconditioning;
    42074119
    4208         element->FindParam(&domaintype,DomainTypeEnum);
     4120        element->FindParam(&dim,DomainDimensionEnum);
    42094121        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    42104122        element->FindParam(&results_on_nodes,SettingsResultsOnNodesEnum);
    4211         switch(domaintype){
    4212                 case Mesh2DverticalEnum: dim = 2; break;
    4213                 case Mesh3DEnum:         dim = 3; break;
    4214                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    4215         }
    42164123
    42174124        /*Fetch number of nodes and dof for this finite element*/
    … …  
    42964203
    42974204        /*Intermediaries*/
    4298         int         dim,tausize,domaintype;
     4205        int         dim,tausize;
    42994206        IssmDouble  epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar;
    43004207        IssmDouble  epsxx_old,epsyy_old,epszz_old,epsxy_old,epsxz_old,epsyz_old;
    … …  
    43054212
    43064213        parameters->FindParam(&r,AugmentedLagrangianREnum);
    4307         parameters->FindParam(&domaintype,DomainTypeEnum);
    4308         switch(domaintype){
    4309                 case Mesh2DverticalEnum: dim = 2; tausize = 3; break;
    4310                 case Mesh3DEnum:         dim = 3; tausize = 6; break;
    4311                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    4312         }
     4214        parameters->FindParam(&dim,DomainDimensionEnum);
     4215        if(dim==2) tausize = 3;
     4216        else       tausize = 6;
    43134217
    43144218        for(int i=0;i<elements->Size();i++){
    … …  
    45094413
    45104414        /*Intermediaries*/
    4511         int         dim,tausize,domaintype;
     4415        int         dim,tausize;
    45124416        IssmDouble  epsxx,epsyy,epszz,epsxy,epsxz,epsyz,D_scalar;
    45134417        IssmDouble  d_xx,d_yy,d_zz,d_xy,d_xz,d_yz;
    … …  
    45184422
    45194423        parameters->FindParam(&r,AugmentedLagrangianREnum);
    4520         parameters->FindParam(&domaintype,DomainTypeEnum);
    4521         switch(domaintype){
    4522                 case Mesh2DverticalEnum: dim = 2; tausize = 3; break;
    4523                 case Mesh3DEnum:         dim = 3; tausize = 6; break;
    4524                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    4525         }
     4424        parameters->FindParam(&dim,DomainDimensionEnum);
     4425        if(dim==2) tausize = 3;
     4426        else       tausize = 6;
    45264427
    45274428        for(int i=0;i<elements->Size();i++){

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

    r17686 r17700  
    4242        if(islevelset){
    4343                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    44                 if(iomodel->domaintype!=Mesh2DhorizontalEnum)
     44                if(iomodel->domaintype!=Domain2DhorizontalEnum)
    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->domaintype!=Mesh2DhorizontalEnum){
     66        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    6767                iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6868        }
    … …  
    166166        element->FindParam(&domaintype,DomainTypeEnum);
    167167        switch(domaintype){
    168                 case Mesh2DhorizontalEnum:
     168                case Domain2DhorizontalEnum:
    169169                        return CreateKMatrix2D(element);
    170                 case Mesh3DEnum:
     170                case Domain3DEnum:
    171171                        return CreateKMatrix3D(element);
    172172                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    … …  
    269269        element->FindParam(&domaintype,DomainTypeEnum);
    270270        switch(domaintype){
    271                 case Mesh2DhorizontalEnum:
     271                case Domain2DhorizontalEnum:
    272272                        return CreatePVector2D(element);
    273                 case Mesh3DEnum:
     273                case Domain3DEnum:
    274274                        return CreatePVector3D(element);
    275275                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    … …  
    541541        element->FindParam(&domaintype,DomainTypeEnum);
    542542        switch(domaintype){
    543                 case Mesh2DhorizontalEnum:
     543                case Domain2DhorizontalEnum:
    544544                        element->GetInputListOnNodes(&thickness[0],ThicknessEnum);
    545545                        for(i=0;i<numnodes;i++) pressure[i]=rho_ice*g*thickness[i];
    546546                        break;
    547                 case Mesh3DEnum:   
     547                case Domain3DEnum:   
    548548                        element->GetVerticesCoordinates(&xyz_list);
    549549                        element->GetInputListOnNodes(&surface[0],SurfaceEnum);

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

    r17694 r17700  
    1818
    1919        /*return if not 3d mesh*/
    20         if(iomodel->domaintype!=Mesh3DEnum) return;
     20        if(iomodel->domaintype!=Domain3DEnum) return;
    2121
    2222        /*Update elements: */
    … …  
    4646
    4747        /*return if not 3d mesh*/
    48         if(iomodel->domaintype!=Mesh3DEnum) return;
     48        if(iomodel->domaintype!=Domain3DEnum) return;
    4949
    5050        iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    … …  
    6262
    6363        /*return if not 3d mesh*/
    64         if(iomodel->domaintype!=Mesh3DEnum) return;
     64        if(iomodel->domaintype!=Domain3DEnum) return;
    6565
    6666        /*Fetch data: */

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

    r17686 r17700  
    3131
    3232        /*Now, is the model 3d? otherwise, do nothing: */
    33         if(iomodel->domaintype==Mesh2DhorizontalEnum)return;
     33        if(iomodel->domaintype==Domain2DhorizontalEnum)return;
    3434
    3535        /*Update elements: */
    … …  
    8383void ThermalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    8484
    85         if(iomodel->domaintype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
     85        if(iomodel->domaintype==Domain3DEnum) 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->domaintype==Mesh3DEnum){
     92        if(iomodel->domaintype==Domain3DEnum){
    9393                IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P1Enum);
    9494        }
    … …  
    9797void ThermalAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    9898
    99         if(iomodel->domaintype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
     99        if(iomodel->domaintype==Domain2DhorizontalEnum) _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/classes/Elements/Tria.cpp

    r17686 r17700  
    104104        parameters->FindParam(&domaintype,DomainTypeEnum);
    105105        switch(domaintype){
    106                 case Mesh2DhorizontalEnum:
     106                case Domain2DhorizontalEnum:
    107107                        this->inputs->AddInput(new TriaInput(input_enum,values,interpolation_enum));
    108108                        break;
    109                 case Mesh2DverticalEnum:{
     109                case Domain2DverticalEnum:{
    110110                        if(interpolation_enum==P1Enum){
    111111                                IssmDouble values2[NUMVERTICES]={0.};
    … …  
    172172        /*Retrieve all inputs we will be needing: */
    173173        this->FindParam(&domaintype,DomainTypeEnum);
    174         if(domaintype==Mesh2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <<EnumToStringx(domaintype)<<", extrude mesh or call ComputeDeviatoricStressTensor");
     174        if(domaintype==Domain2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <<EnumToStringx(domaintype)<<", extrude mesh or call ComputeDeviatoricStressTensor");
    175175        Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
    176176        Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    … …  
    225225        /*Retrieve all inputs we will be needing: */
    226226        this->FindParam(&domaintype,DomainTypeEnum);
    227         if(domaintype!=Mesh2DhorizontalEnum) _error_("deviatoric stress tensor calculation not implemented for mesh of type " <<EnumToStringx(domaintype));
     227        if(domaintype!=Domain2DhorizontalEnum) _error_("deviatoric stress tensor calculation not implemented for mesh of type " <<EnumToStringx(domaintype));
    228228        Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    229229        Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
    … …  
    529529        if(gl[2]==0.) gl[2]=gl[2]+epsilon;
    530530
    531         if(domaintype==Mesh2DverticalEnum){
     531        if(domaintype==Domain2DverticalEnum){
    532532                this->EdgeOnBaseIndices(&index1,&index2);
    533533                if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded
    … …  
    541541
    542542        }
    543         else if(domaintype==Mesh2DhorizontalEnum || domaintype==Mesh3DEnum){
     543        else if(domaintype==Domain2DhorizontalEnum || domaintype==Domain3DEnum){
    544544                /*Check that not all nodes are grounded or floating*/
    545545                if(gl[0]>0 && gl[1]>0 && gl[2]>0){ // All grounded
    … …  
    11661166        this->parameters->FindParam(&domaintype,DomainTypeEnum);
    11671167        switch(domaintype){
    1168                 case Mesh2DverticalEnum:
     1168                case Domain2DverticalEnum:
    11691169                        return HasEdgeOnBase();
    1170                 case Mesh2DhorizontalEnum:
     1170                case Domain2DhorizontalEnum:
    11711171                        return true;
    11721172                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    … …  
    11801180        this->parameters->FindParam(&domaintype,DomainTypeEnum);
    11811181        switch(domaintype){
    1182                 case Mesh2DverticalEnum:
     1182                case Domain2DverticalEnum:
    11831183                        return HasEdgeOnSurface();
    1184                 case Mesh2DhorizontalEnum:
     1184                case Domain2DhorizontalEnum:
    11851185                        return true;
    11861186                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    … …  
    18451845        this->parameters->FindParam(&domaintype,DomainTypeEnum);
    18461846        switch(domaintype){
    1847                 case Mesh2DhorizontalEnum:
     1847                case Domain2DhorizontalEnum:
    18481848                        return this;
    1849                 case Mesh2DverticalEnum:
     1849                case Domain2DverticalEnum:
    18501850                        _assert_(HasEdgeOnBase());
    18511851                        this->EdgeOnBaseIndices(&index1,&index2);
    … …  
    18641864        this->parameters->FindParam(&domaintype,DomainTypeEnum);
    18651865        switch(domaintype){
    1866                 case Mesh2DhorizontalEnum:
     1866                case Domain2DhorizontalEnum:
    18671867                        return this;
    1868                 case Mesh2DverticalEnum:
     1868                case Domain2DverticalEnum:
    18691869                        _assert_(HasEdgeOnSurface());
    18701870                        this->EdgeOnSurfaceIndices(&index1,&index2);
    … …  
    22212221        int domaintype;
    22222222        parameters->FindParam(&domaintype,DomainTypeEnum);
    2223         if(domaintype==Mesh2DverticalEnum){
     2223        if(domaintype==Domain2DverticalEnum){
    22242224          return base;
    22252225        }
    … …  
    22972297        Input* vx_input=NULL;
    22982298        Input* vy_input=NULL;
    2299         if(domaintype==Mesh2DhorizontalEnum){
     2299        if(domaintype==Domain2DhorizontalEnum){
    23002300                vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    23012301                vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    23642364        Input* vx_input=NULL;
    23652365        Input* vy_input=NULL;
    2366         if(domaintype==Mesh2DhorizontalEnum){
     2366        if(domaintype==Domain2DhorizontalEnum){
    23672367                vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    23682368                vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);

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

    r17686 r17700  
    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->domaintype!=Mesh2DhorizontalEnum){
     63                if(iomodel->domaintype!=Domain2DhorizontalEnum){
    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->domaintype!=Mesh2DhorizontalEnum){
     103                if(iomodel->domaintype!=Domain2DhorizontalEnum){
    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->domaintype!=Mesh2DhorizontalEnum){
     114                if(iomodel->domaintype!=Domain2DhorizontalEnum){
    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

    r17686 r17700  
    3636        _assert_(iomodel->Data(BaseEnum) && iomodel->Data(ThicknessEnum) && iomodel->numbernodetoelementconnectivity);
    3737        switch(iomodel->domaintype){
    38                 case Mesh3DEnum:
    39                 case Mesh2DhorizontalEnum:
     38                case Domain3DEnum:
     39                case Domain2DhorizontalEnum:
    4040                        this->sigma = (iomodel->Data(MeshZEnum)[i]-iomodel->Data(BaseEnum)[i])/(iomodel->Data(ThicknessEnum)[i]);
    4141                        break;
    42                 case Mesh2DverticalEnum:
     42                case Domain2DverticalEnum:
    4343                        this->sigma = (iomodel->Data(MeshYEnum)[i]-iomodel->Data(BaseEnum)[i])/(iomodel->Data(ThicknessEnum)[i]);
    4444                        break;
    … …  
    133133        /*sigma remains constant. z=bed+sigma*thickness*/
    134134        switch(this->domaintype){
    135                 case Mesh2DhorizontalEnum:
     135                case Domain2DhorizontalEnum:
    136136                        /*Nothing*/
    137137                        return;
    138                 case Mesh2DverticalEnum:
     138                case Domain2DverticalEnum:
    139139                        oldy = this->y;
    140140                        newy = bed[this->pid]+sigma*(surface[this->pid] - bed[this->pid]);
    … …  
    143143                        vy->SetValue(this->pid,vely,INS_VAL);
    144144                        return;
    145                 case Mesh3DEnum:
     145                case Domain3DEnum:
    146146                        oldz = this->z;
    147147                        newz = bed[this->pid]+sigma*(surface[this->pid] - bed[this->pid]);

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

    r17686 r17700  
    2828        solutionsequence_linear(femmodel);
    2929
    30         if(domaintype!=Mesh2DverticalEnum){
     30        if(domaintype!=Domain2DverticalEnum){
    3131                femmodel->parameters->SetParam(BedSlopeYEnum,InputToL2ProjectEnum);
    3232                solutionsequence_linear(femmodel);
    … …  
    3535        if(save_results){
    3636                if(VerboseSolution()) _printf0_("   saving results\n");
    37                 if(domaintype!=Mesh2DverticalEnum){
     37                if(domaintype!=Domain2DverticalEnum){
    3838                        int outputs[2] = {BedSlopeXEnum,BedSlopeYEnum};
    3939                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2);

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

    r17686 r17700  
    2828        solutionsequence_linear(femmodel);
    2929
    30         if(domaintype!=Mesh2DverticalEnum){
     30        if(domaintype!=Domain2DverticalEnum){
    3131                femmodel->parameters->SetParam(LevelsetfunctionSlopeYEnum,InputToL2ProjectEnum);
    3232                solutionsequence_linear(femmodel);
    3333        }
    34         if(domaintype==Mesh2DverticalEnum){
     34        if(domaintype==Domain2DverticalEnum){
    3535              femmodel->parameters->SetParam(LevelsetfunctionSlopeXEnum,InputToExtrudeEnum);
    3636                extrudefrombase_core(femmodel);
    … …  
    3939        if(save_results){
    4040                if(VerboseSolution()) _printf0_("saving results:\n");
    41                 if(domaintype!=Mesh2DverticalEnum){
     41                if(domaintype!=Domain2DverticalEnum){
    4242                        int outputs[2] = {LevelsetfunctionSlopeXEnum,LevelsetfunctionSlopeYEnum};
    4343                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2);

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

    r17686 r17700  
    4848                femmodel->SetCurrentConfiguration(FreeSurfaceBaseAnalysisEnum);
    4949                solutionsequence_linear(femmodel);
    50                 if(domaintype!=Mesh2DhorizontalEnum){
     50                if(domaintype!=Domain2DhorizontalEnum){
    5151                        femmodel->parameters->SetParam(BaseEnum,InputToExtrudeEnum);
    5252                        extrudefrombase_core(femmodel);
    … …  
    5454                femmodel->SetCurrentConfiguration(FreeSurfaceTopAnalysisEnum);
    5555                solutionsequence_linear(femmodel);
    56                 if(domaintype!=Mesh2DhorizontalEnum){
     56                if(domaintype!=Domain2DhorizontalEnum){
    5757                        femmodel->parameters->SetParam(SurfaceEnum,InputToExtrudeEnum);
    5858                        extrudefromtop_core(femmodel);
    … …  
    6262                if(VerboseSolution()) _printf0_("   call computational core\n");
    6363                solutionsequence_linear(femmodel);
    64                 if(domaintype==Mesh2DverticalEnum){
     64                if(domaintype==Domain2DverticalEnum){
    6565                        femmodel->parameters->SetParam(ThicknessEnum,InputToExtrudeEnum);
    6666                        extrudefrombase_core(femmodel);

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

    r17686 r17700  
    4040                InputDuplicatex(femmodel,QmuVxEnum,VxEnum);
    4141                InputDuplicatex(femmodel,QmuVyEnum,VyEnum);
    42                 if(domaintype==Mesh3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
     42                if(domaintype==Domain3DEnum) InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
    4343                if(isFS) InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum);
    4444        }
    4545
    4646        /*Compute slopes if necessary */
    47         if(isSIA || (isFS && domaintype==Mesh2DverticalEnum)) surfaceslope_core(femmodel);
     47        if(isSIA || (isFS && domaintype==Domain2DverticalEnum)) surfaceslope_core(femmodel);
    4848        if(isFS){
    4949                bedslope_core(femmodel);
    … …  
    7474
    7575        /*Compute vertical velocities*/
    76         if (domaintype==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){
     76        if (domaintype==Domain3DEnum && (isSIA || isSSA || isL1L2 || isHO)){
    7777                analysis = new StressbalanceVerticalAnalysis();
    7878                analysis->Core(femmodel);

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

    r17686 r17700  
    2828        solutionsequence_linear(femmodel);
    2929
    30         if(domaintype!=Mesh2DverticalEnum){
     30        if(domaintype!=Domain2DverticalEnum){
    3131                femmodel->parameters->SetParam(SurfaceSlopeYEnum,InputToL2ProjectEnum);
    3232                solutionsequence_linear(femmodel);
    3333        }
    34         if(domaintype==Mesh2DverticalEnum){
     34        if(domaintype==Domain2DverticalEnum){
    3535                femmodel->parameters->SetParam(SurfaceSlopeXEnum,InputToExtrudeEnum);
    3636                extrudefrombase_core(femmodel);
    … …  
    3939        if(save_results){
    4040                if(VerboseSolution()) _printf0_("saving results:\n");
    41                 if(domaintype!=Mesh2DverticalEnum){
     41                if(domaintype!=Domain2DverticalEnum){
    4242                        int outputs[2] = {SurfaceSlopeXEnum,SurfaceSlopeYEnum};
    4343                        femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],2);

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

    r17686 r17700  
    6666                        InputDuplicatex(femmodel,QmuVxEnum,VxEnum);
    6767                        InputDuplicatex(femmodel,QmuVyEnum,VyEnum);
    68                         if(domaintype==Mesh3DEnum){
     68                        if(domaintype==Domain3DEnum){
    6969                                InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
    7070                                if(isFS)InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum);
    … …  
    7878                }
    7979                if(isgroundingline) InputDuplicatex(femmodel,QmuMaskGroundediceLevelsetEnum,MaskGroundediceLevelsetEnum);
    80                 if(isthermal && domaintype==Mesh3DEnum){
     80                if(isthermal && domaintype==Domain3DEnum){
    8181                        //Update Vertex Position after updating Thickness and Bed
    8282                        femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum);
    … …  
    114114                femmodel->parameters->SetParam(save_results,SaveResultsEnum);
    115115
    116                 if(isthermal && domaintype==Mesh3DEnum){
     116                if(isthermal && domaintype==Domain3DEnum){
    117117                        if(VerboseSolution()) _printf0_("   computing thermal regime\n");
    118118                        thermal_core(femmodel);

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

    r17692 r17700  
    1717
    1818        /*Check Iomodel properties*/
    19         if(iomodel->domaintype==Mesh2DhorizontalEnum || iomodel->domaintype==Mesh2DverticalEnum){
     19        if(iomodel->domaintype==Domain2DhorizontalEnum || iomodel->domaintype==Domain2DverticalEnum){
    2020                /*Keep going*/
    2121        }
    22         else if(iomodel->domaintype==Mesh3DEnum){
     22        else if(iomodel->domaintype==Domain3DEnum){
    2323                CreateFaces3d(iomodel);
    2424                return;
    … …  
    243243
    244244        int numbervertices;
    245         if(iomodel->domaintype==Mesh3DEnum){
     245        if(iomodel->domaintype==Domain3DEnum){
    246246                if((iomodel->faces[6*facenumber+5])==1){
    247247                        numbervertices=3;

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

    r17692 r17700  
    8686        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceReltolEnum));
    8787        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceAbstolEnum));
    88         if(iomodel->domaintype==Mesh3DEnum)
     88        if(iomodel->domaintype==Domain3DEnum)
    8989         parameters->AddObject(iomodel->CopyConstantObject(MeshNumberoflayersEnum));
    9090

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

    r17686 r17700  
    3131        /*Get element width (3 or 6)*/
    3232        switch(iomodel->domaintype){
    33                 case Mesh2DhorizontalEnum: elementswidth=3; break;
    34                 case Mesh2DverticalEnum  : elementswidth=3; break;
    35                 case Mesh3DEnum          : elementswidth=6; break;
     33                case Domain2DhorizontalEnum: elementswidth=3; break;
     34                case Domain2DverticalEnum  : elementswidth=3; break;
     35                case Domain3DEnum          : elementswidth=6; break;
    3636                default:  _error_("mesh type "<<EnumToStringx(iomodel->domaintype)<<" not supported yet");
    3737        }

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

    r17686 r17700  
    1818
    1919        /*Mesh dependent variables*/
    20         if(iomodel->domaintype==Mesh2DhorizontalEnum){
     20        if(iomodel->domaintype==Domain2DhorizontalEnum){
    2121                elementnbf = 3;
    2222        }
    23         else if(iomodel->domaintype==Mesh2DverticalEnum){
     23        else if(iomodel->domaintype==Domain2DverticalEnum){
    2424                elementnbf = 3;
    2525        }
    26         else if(iomodel->domaintype==Mesh3DEnum){
     26        else if(iomodel->domaintype==Domain3DEnum){
    2727                elementnbf = 5;
    2828        }

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

    r17686 r17700  
    5959
    6060                /*Hack for trasient runs (FIXME: to be improved)*/
    61                 if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum  && iomodel->domaintype==Mesh2DhorizontalEnum) continue;
    62                 if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum  && iomodel->domaintype==Mesh2DhorizontalEnum) continue;
    63                 if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->domaintype==Mesh2DhorizontalEnum) continue;
     61                if(solution_enum==TransientSolutionEnum && analysis_enum==ThermalAnalysisEnum  && iomodel->domaintype==Domain2DhorizontalEnum) continue;
     62                if(solution_enum==TransientSolutionEnum && analysis_enum==MeltingAnalysisEnum  && iomodel->domaintype==Domain2DhorizontalEnum) continue;
     63                if(solution_enum==TransientSolutionEnum && analysis_enum==EnthalpyAnalysisEnum && iomodel->domaintype==Domain2DhorizontalEnum) 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

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

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

    r17686 r17700  
    5050
    5151                /* if solving 2d problem on vertically extende mesh, solve on basal layer only*/
    52                 if(domaintype!=Mesh2DhorizontalEnum){
     52                if(domaintype!=Domain2DhorizontalEnum){
    5353                        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    5454                        if(

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

    r17686 r17700  
    211211        MeshYEnum,
    212212        MeshZEnum,
     213        MeshElementtypeEnum,
    213214        DomainTypeEnum,
    214215        DomainDimensionEnum,
    215         MeshElementtypeEnum,
    216         Mesh2DhorizontalEnum,
    217         Mesh2DverticalEnum,
    218         Mesh3DEnum,
    219         Mesh3DtetrasEnum,
     216        Domain2DhorizontalEnum,
     217        Domain2DverticalEnum,
     218        Domain3DEnum,
    220219        MiscellaneousNameEnum, //FIXME: only used by qmu, should not be marshalled (already in queueing script)
    221220        MasstransportHydrostaticAdjustmentEnum,

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

    r17686 r17700  
    219219                case MeshYEnum : return "MeshY";
    220220                case MeshZEnum : return "MeshZ";
     221                case MeshElementtypeEnum : return "MeshElementtype";
    221222                case DomainTypeEnum : return "DomainType";
    222223                case DomainDimensionEnum : return "DomainDimension";
    223                 case MeshElementtypeEnum : return "MeshElementtype";
    224                 case Mesh2DhorizontalEnum : return "Mesh2Dhorizontal";
    225                 case Mesh2DverticalEnum : return "Mesh2Dvertical";
    226                 case Mesh3DEnum : return "Mesh3D";
    227                 case Mesh3DtetrasEnum : return "Mesh3Dtetras";
     224                case Domain2DhorizontalEnum : return "Domain2Dhorizontal";
     225                case Domain2DverticalEnum : return "Domain2Dvertical";
     226                case Domain3DEnum : return "Domain3D";
    228227                case MiscellaneousNameEnum : return "MiscellaneousName";
    229228                case MasstransportHydrostaticAdjustmentEnum : return "MasstransportHydrostaticAdjustment";

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

    r17686 r17700  
    222222              else if (strcmp(name,"MeshY")==0) return MeshYEnum;
    223223              else if (strcmp(name,"MeshZ")==0) return MeshZEnum;
     224              else if (strcmp(name,"MeshElementtype")==0) return MeshElementtypeEnum;
    224225              else if (strcmp(name,"DomainType")==0) return DomainTypeEnum;
    225226              else if (strcmp(name,"DomainDimension")==0) return DomainDimensionEnum;
    226               else if (strcmp(name,"MeshElementtype")==0) return MeshElementtypeEnum;
    227               else if (strcmp(name,"Mesh2Dhorizontal")==0) return Mesh2DhorizontalEnum;
    228               else if (strcmp(name,"Mesh2Dvertical")==0) return Mesh2DverticalEnum;
    229               else if (strcmp(name,"Mesh3D")==0) return Mesh3DEnum;
    230               else if (strcmp(name,"Mesh3Dtetras")==0) return Mesh3DtetrasEnum;
     227              else if (strcmp(name,"Domain2Dhorizontal")==0) return Domain2DhorizontalEnum;
     228              else if (strcmp(name,"Domain2Dvertical")==0) return Domain2DverticalEnum;
     229              else if (strcmp(name,"Domain3D")==0) return Domain3DEnum;
    231230              else if (strcmp(name,"MiscellaneousName")==0) return MiscellaneousNameEnum;
    232231              else if (strcmp(name,"MasstransportHydrostaticAdjustment")==0) return MasstransportHydrostaticAdjustmentEnum;
    … …  
    260259              else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum;
    261260              else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum;
     261              else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;
    262262         else stage=3;
    263263   }
    264264   if(stage==3){
    265               if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;
    266               else if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum;
     265              if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum;
    267266              else if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum;
    268267              else if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum;
    … …  
    383382              else if (strcmp(name,"FSpressure")==0) return FSpressureEnum;
    384383              else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
     384              else if (strcmp(name,"Loads")==0) return LoadsEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"Loads")==0) return LoadsEnum;
    389               else if (strcmp(name,"Materials")==0) return MaterialsEnum;
     388              if (strcmp(name,"Materials")==0) return MaterialsEnum;
    390389              else if (strcmp(name,"Nodes")==0) return NodesEnum;
    391390              else if (strcmp(name,"Contours")==0) return ContoursEnum;
    … …  
    506505              else if (strcmp(name,"VxPicard")==0) return VxPicardEnum;
    507506              else if (strcmp(name,"VyAverage")==0) return VyAverageEnum;
     507              else if (strcmp(name,"Vy")==0) return VyEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"Vy")==0) return VyEnum;
    512               else if (strcmp(name,"VyPicard")==0) return VyPicardEnum;
     511              if (strcmp(name,"VyPicard")==0) return VyPicardEnum;
    513512              else if (strcmp(name,"Vz")==0) return VzEnum;
    514513              else if (strcmp(name,"VzSSA")==0) return VzSSAEnum;
    … …  
    629628              else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum;
    630629              else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum;
     630              else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;
    631631         else stage=6;
    632632   }
    633633   if(stage==6){
    634               if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;
    635               else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;
     634              if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;
    636635              else if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
    637636              else if (strcmp(name,"Adjoint")==0) return AdjointEnum;

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

    r17688 r17700  
    108108        #}}}
    109109        def marshall(self,md,fid):    # {{{
    110                 WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum("Mesh"+self.domaintype())[0],'format','Integer');
     110                WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum("Domain"+self.domaintype())[0],'format','Integer');
    111111                WriteData(fid,'enum',DomainDimensionEnum(),'data',self.dimension(),'format','Integer');
    112112                WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(self.elementtype())[0],'format','Integer');

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

    r17688 r17700  
    104104                end % }}}
    105105                function marshall(obj,md,fid) % {{{
    106                         WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Mesh' domaintype(obj)]),'format','Integer');
     106                        WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
    107107                        WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
    108108                        WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');

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

    r17688 r17700  
    135135                end % }}}
    136136                function marshall(obj,md,fid) % {{{
    137                         WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Mesh' domaintype(obj)]),'format','Integer');
     137                        WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
    138138                        WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
    139139                        WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');

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

    r17688 r17700  
    139139        #}}}
    140140        def marshall(self,md,fid):    # {{{
    141                 WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum("Mesh"+self.domaintype())[0],'format','Integer');
     141                WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum("Domain"+self.domaintype())[0],'format','Integer');
    142142                WriteData(fid,'enum',DomainDimensionEnum(),'data',self.dimension(),'format','Integer');
    143143                WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(self.elementtype())[0],'format','Integer');

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

    r17699 r17700  
    129129                end % }}}
    130130                function marshall(obj,md,fid) % {{{
    131                         WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Mesh' domaintype(obj)]),'format','Integer');
     131                        WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
    132132                        WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
    133133                        WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');

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

    r17686 r17700  
    211211def MeshYEnum(): return StringToEnum("MeshY")[0]
    212212def MeshZEnum(): return StringToEnum("MeshZ")[0]
     213def MeshElementtypeEnum(): return StringToEnum("MeshElementtype")[0]
    213214def DomainTypeEnum(): return StringToEnum("DomainType")[0]
    214215def DomainDimensionEnum(): return StringToEnum("DomainDimension")[0]
    215 def MeshElementtypeEnum(): return StringToEnum("MeshElementtype")[0]
    216 def Mesh2DhorizontalEnum(): return StringToEnum("Mesh2Dhorizontal")[0]
    217 def Mesh2DverticalEnum(): return StringToEnum("Mesh2Dvertical")[0]
    218 def Mesh3DEnum(): return StringToEnum("Mesh3D")[0]
    219 def Mesh3DtetrasEnum(): return StringToEnum("Mesh3Dtetras")[0]
     216def Domain2DhorizontalEnum(): return StringToEnum("Domain2Dhorizontal")[0]
     217def Domain2DverticalEnum(): return StringToEnum("Domain2Dvertical")[0]
     218def Domain3DEnum(): return StringToEnum("Domain3D")[0]
    220219def MiscellaneousNameEnum(): return StringToEnum("MiscellaneousName")[0]
    221220def MasstransportHydrostaticAdjustmentEnum(): return StringToEnum("MasstransportHydrostaticAdjustment")[0]

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

    r17686 r17700  
    1 function rot = vorticity(vx,vy)
     1function rot = vorticity(md,vx,vy)
    22%VORTICITY - calculates 2d vorticity
    33%
    … …  
    2929rot=dvxdy - dvydx;
    3030
    31 if md.mesh.dimension==3,
     31if strcmpi(meshtype(md.mesh),'3D'),
    3232        rot=project3d(md,'vector',rot,'type','element');
    3333end

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

    r17686 r17700  
    1919
    2020        /* required input: */
    21         int  domaintype;
     21        int  meshelementtype;
    2222        int  numberofelements;
    2323        int  numberofvertices;
    … …  
    4949        FetchData(&elements,NULL,&elements_width,mxGetAssignedField(MESH,0,"elements"));
    5050
    51         if(strcmp(mxGetClassName(MESH),"mesh3d")==0){
    52                 domaintype = Mesh3DEnum;
     51        if(strcmp(mxGetClassName(MESH),"mesh3dprisms")==0){
     52                meshelementtype = PentaEnum;
    5353                FetchData(&numberofelements2d,mxGetAssignedField(MESH,0,"numberofelements2d"));
    5454                FetchData(&numberofvertices2d,mxGetAssignedField(MESH,0,"numberofvertices2d"));
    … …  
    5757        }
    5858        else if(strcmp(mxGetClassName(MESH),"mesh2dhorizontal")==0){
    59                 domaintype = Mesh2DhorizontalEnum;
     59                meshelementtype = TriaEnum;
    6060                numberoflayers=1;
    6161        }
    6262        else if(strcmp(mxGetClassName(MESH),"mesh2dvertical")==0){
    63                 domaintype = Mesh2DverticalEnum;
     63                meshelementtype = TriaEnum;
    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,domaintype,numareas);
     73                numberofelements2d,numberofvertices2d,elements2d,numberoflayers,elements_width,meshelementtype,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.