source: issm/oecreview/Archive/16554-17801/ISSM-17584-17585.diff@ 17802

Last change on this file since 17802 was 17802, checked in by Mathieu Morlighem, 11 years ago

Added archives
File size: 50.6 KB

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

     
    125125}/*}}}*/
    126126ElementMatrix* BalancethicknessAnalysis::CreateKMatrix(Element* element){/*{{{*/
    127127
    128         if(!element->IsOnBed()) return NULL;
     128        if(!element->IsOnBase()) return NULL;
    129129        Element* basalelement = element->SpawnBasalElement();
    130130
    131131        ElementMatrix* Ke = NULL;
    … …  
    317317}/*}}}*/
    318318ElementVector* BalancethicknessAnalysis::CreatePVector(Element* element){/*{{{*/
    319319
    320         if(!element->IsOnBed()) return NULL;
     320        if(!element->IsOnBase()) return NULL;
    321321        Element* basalelement = element->SpawnBasalElement();
    322322
    323323        ElementVector* pe = NULL;

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

     
    120120                        basalelement = element;
    121121                        break;
    122122                case Mesh3DEnum:
    123                         if(!element->IsOnBed()) return NULL;
     123                        if(!element->IsOnBase()) return NULL;
    124124                        basalelement = element->SpawnBasalElement();
    125125                        break;
    126126                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    224224                        basalelement = element;
    225225                        break;
    226226                case Mesh3DEnum:
    227                         if(!element->IsOnBed()) return NULL;
     227                        if(!element->IsOnBase()) return NULL;
    228228                        basalelement = element->SpawnBasalElement();
    229229                        break;
    230230                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    322322        element->FindParam(&meshtype,MeshTypeEnum);
    323323
    324324        if(meshtype!=Mesh2DhorizontalEnum){
    325                 if(!element->IsOnBed()) return;
     325                if(!element->IsOnBase()) return;
    326326                basalelement=element->SpawnBasalElement();
    327327        }
    328328        else{
    … …  
    493493               
    494494                switch(meshtype){
    495495                case Mesh2DhorizontalEnum:
    496                         if(!element->IsOnBed()) return;                 
     496                        if(!element->IsOnBase()) return;                       
    497497                        B = element->GetMaterialParameter(MaterialsRheologyBbarEnum);
    498498                        break;
    499499                case Mesh3DEnum:
    … …  
    613613                        basalelement = element;
    614614                        break;
    615615                case Mesh3DEnum:
    616                         if(!element->IsOnBed()) return;
     616                        if(!element->IsOnBase()) return;
    617617                        basalelement = element->SpawnBasalElement();
    618618                        break;
    619619                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    693693                        basalelement = element;
    694694                        break;
    695695                case Mesh3DEnum:
    696                         if(!element->IsOnBed()) return;
     696                        if(!element->IsOnBase()) return;
    697697                        basalelement = element->SpawnBasalElement();
    698698                        break;
    699699                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    6464                        basalelement = element;
    6565                        break;
    6666                case Mesh3DEnum:
    67                         if(!element->IsOnBed()) return NULL;
     67                        if(!element->IsOnBase()) return NULL;
    6868                        basalelement = element->SpawnBasalElement();
    6969                        break;
    7070                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    693693                        basalelement = element;
    694694                        break;
    695695                case Mesh3DEnum:
    696                         if(!element->IsOnBed()) return NULL;
     696                        if(!element->IsOnBase()) return NULL;
    697697                        basalelement = element->SpawnBasalElement();
    698698                        break;
    699699                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    8383}/*}}}*/
    8484ElementMatrix* LevelsetAnalysis::CreateKMatrix(Element* element){/*{{{*/
    8585
    86         if(!element->IsOnBed()) return NULL;
     86        if(!element->IsOnBase()) return NULL;
    8787        Element* basalelement = element->SpawnBasalElement();
    8888
    8989        /*Intermediaries */
    … …  
    252252}/*}}}*/
    253253ElementVector* LevelsetAnalysis::CreatePVector(Element* element){/*{{{*/
    254254       
    255         if(!element->IsOnBed()) return NULL;
     255        if(!element->IsOnBase()) return NULL;
    256256        Element* basalelement = element->SpawnBasalElement();
    257257
    258258        /*Intermediaries */

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

     
    277277        IssmDouble  Jdet,slope[3];
    278278        IssmDouble  vx,vy,vz=0.,dbdx,dbdy,basalmeltingvalue;
    279279
    280         if(!element->IsOnBed()) return NULL;
     280        if(!element->IsOnBase()) return NULL;
    281281
    282282        /*Fetch number of nodes for this finite element*/
    283283        int numnodes = element->GetNumberOfNodes();

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

     
    8484ElementMatrix* MeltingAnalysis::CreateKMatrix(Element* element){/*{{{*/
    8585
    8686        /*Get basal element*/
    87         if(!element->IsOnBed()) return NULL;
     87        if(!element->IsOnBase()) return NULL;
    8888        Element* basalelement = element->SpawnBasalElement();
    8989
    9090        /*Intermediaries */

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

     
    162162/*}}}*/
    163163ElementMatrix* ExtrudeFromBaseAnalysis::CreateKMatrixBed(Element* element){/*{{{*/
    164164
    165         if(!element->IsOnBed()) return NULL;
     165        if(!element->IsOnBase()) return NULL;
    166166
    167167        /*Intermediaries */
    168168        IssmDouble  Jdet,D,normal[3];

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

     
    5858                        basalelement = element;
    5959                        break;
    6060                case Mesh3DEnum:
    61                         if(!element->IsOnBed()) return NULL;
     61                        if(!element->IsOnBase()) return NULL;
    6262                        basalelement = element->SpawnBasalElement();
    6363                        break;
    6464                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    9393                        basalelement = element;
    9494                        break;
    9595                case Mesh2DverticalEnum:
    96                         if(!element->IsOnBed()) return NULL;
     96                        if(!element->IsOnBase()) return NULL;
    9797                        basalelement = element->SpawnBasalElement();
    9898                        break;
    9999                case Mesh3DEnum:
    100                         if(!element->IsOnBed()) return NULL;
     100                        if(!element->IsOnBase()) return NULL;
    101101                        basalelement = element->SpawnBasalElement();
    102102                        break;
    103103                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    165165                        basalelement = element;
    166166                        break;
    167167                case Mesh3DEnum:
    168                         if(!element->IsOnBed()) return NULL;
     168                        if(!element->IsOnBase()) return NULL;
    169169                        basalelement = element->SpawnBasalElement();
    170170                        break;
    171171                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    243243        /* Check if ice in element */
    244244        if(!element->IsIceInElement()) return NULL;
    245245
    246         if(!element->IsOnBed()) return NULL;
     246        if(!element->IsOnBase()) return NULL;
    247247        Element* basalelement = element->SpawnBasalElement();
    248248
    249249        ElementMatrix* Ke = NULL;
    … …  
    489489        /* Check if ice in element */
    490490        if(!element->IsIceInElement()) return NULL;
    491491
    492         if(!element->IsOnBed()) return NULL;
     492        if(!element->IsOnBase()) return NULL;
    493493        Element* basalelement = element->SpawnBasalElement();
    494494
    495495        ElementVector* pe = NULL;
    … …  
    676676
    677677        element->FindParam(&meshtype,MeshTypeEnum);
    678678        if(meshtype!=Mesh2DhorizontalEnum){
    679                 if(!element->IsOnBed()) return;
     679                if(!element->IsOnBase()) return;
    680680                basalelement=element->SpawnBasalElement();
    681681        }
    682682        else{

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

     
    114114                        basalelement = element;
    115115                        break;
    116116                case Mesh3DEnum:
    117                         if(!element->IsOnBed()) return NULL;
     117                        if(!element->IsOnBase()) return NULL;
    118118                        basalelement = element->SpawnBasalElement();
    119119                        break;
    120120                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    114114                        basalelement = element;
    115115                        break;
    116116                case Mesh3DEnum:
    117                         if(!element->IsOnBed()) return NULL;
     117                        if(!element->IsOnBase()) return NULL;
    118118                        basalelement = element->SpawnBasalElement();
    119119                        break;
    120120                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    162162/*}}}*/
    163163ElementMatrix* ExtrudeFromTopAnalysis::CreateKMatrixBed(Element* element){/*{{{*/
    164164
    165         if(!element->IsOnBed()) return NULL;
     165        if(!element->IsOnBase()) return NULL;
    166166
    167167        /*Intermediaries */
    168168        IssmDouble  Jdet,D,normal[3];

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

     
    157157                        basalelement = element;
    158158                        break;
    159159                case Mesh3DEnum:
    160                         if(!element->IsOnBed()) return NULL;
     160                        if(!element->IsOnBase()) return NULL;
    161161                        basalelement = element->SpawnBasalElement();
    162162                        break;
    163163                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    7777                        basalelement = element;
    7878                        break;
    7979                case Mesh2DverticalEnum:
    80                         if(!element->IsOnBed()) return NULL;
     80                        if(!element->IsOnBase()) return NULL;
    8181                        basalelement = element->SpawnBasalElement();
    8282                        break;
    8383                case Mesh3DEnum:
    84                         if(!element->IsOnBed()) return NULL;
     84                        if(!element->IsOnBase()) return NULL;
    8585                        basalelement = element->SpawnBasalElement();
    8686                        break;
    8787                case Mesh3DtetrasEnum:
    88                         if(!element->IsOnBed()) return NULL;
     88                        if(!element->IsOnBase()) return NULL;
    8989                        basalelement = element->SpawnBasalElement();
    9090                        break;
    9191                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    140140                        basalelement = element;
    141141                        break;
    142142                case Mesh2DverticalEnum:
    143                         if(!element->IsOnBed()) return NULL;
     143                        if(!element->IsOnBase()) return NULL;
    144144                        basalelement = element->SpawnBasalElement();
    145145                        break;
    146146                case Mesh3DEnum:
    147                         if(!element->IsOnBed()) return NULL;
     147                        if(!element->IsOnBase()) return NULL;
    148148                        basalelement = element->SpawnBasalElement();
    149149                        break;
    150150                case Mesh3DtetrasEnum:
    151                         if(!element->IsOnBed()) return NULL;
     151                        if(!element->IsOnBase()) return NULL;
    152152                        basalelement = element->SpawnBasalElement();
    153153                        break;
    154154                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");

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

     
    226226                j0=2*nodeup;    j1=2*nodeup+1;
    227227
    228228                /*Create matrix for these two nodes*/
    229                 if(element->IsOnBed() && element->IsOnSurface()){
     229                if(element->IsOnBase() && element->IsOnSurface()){
    230230                        Ke->values[i0*numdof+i0] = +one0;
    231231                        Ke->values[i1*numdof+i1] = +one0;
    232232                        Ke->values[j0*numdof+i0] = -one1;
    … …  
    234234                        Ke->values[j1*numdof+i1] = -one1;
    235235                        Ke->values[j1*numdof+j1] = +one1;
    236236                }
    237                 else if(element->IsOnBed()){
     237                else if(element->IsOnBase()){
    238238                        Ke->values[i0*numdof+i0] = one0;
    239239                        Ke->values[i1*numdof+i1] = one0;
    240240                        Ke->values[j0*numdof+i0] = -2.*one1;
    … …  
    418418                }
    419419
    420420                /*Deal with basal velocities*/
    421                 if(element->IsOnBed()){
     421                if(element->IsOnBase()){
    422422                        drag_input->GetInputValue(&drag,gauss);
    423423
    424424                        switch(frictionlaw){

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

     
    10841084                        basalelement = element;
    10851085                        break;
    10861086                case Mesh3DEnum:
    1087                         if(!element->IsOnBed()) return NULL;
     1087                        if(!element->IsOnBase()) return NULL;
    10881088                        basalelement = element->SpawnBasalElement();
    10891089                        break;
    10901090                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    11701170                        basalelement = element;
    11711171                        break;
    11721172                case Mesh3DEnum: case Mesh2DverticalEnum:
    1173                         if(!element->IsOnBed()) return NULL;
     1173                        if(!element->IsOnBase()) return NULL;
    11741174                        basalelement = element->SpawnBasalElement();
    11751175                        break;
    11761176                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    13731373                        basalelement = element;
    13741374                        break;
    13751375                case Mesh3DEnum: case Mesh2DverticalEnum:
    1376                         if(!element->IsOnBed()) return NULL;
     1376                        if(!element->IsOnBase()) return NULL;
    13771377                        basalelement = element->SpawnBasalElement();
    13781378                        break;
    13791379                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    16911691                        basalelement = element;
    16921692                        break;
    16931693                case Mesh3DEnum: case Mesh2DverticalEnum:
    1694                         if(!element->IsOnBed()){xDelete<IssmDouble>(xyz_list); return;}
     1694                        if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
    16951695                        basalelement=element->SpawnBasalElement();
    16961696                        break;
    16971697                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    17721772}/*}}}*/
    17731773ElementMatrix* StressbalanceAnalysis::CreateKMatrixL1L2Friction(Element* element){/*{{{*/
    17741774
    1775         if(!element->IsOnBed() || element->IsFloating()) return NULL;
     1775        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    17761776        Element* basalelement = element->SpawnBasalElement();
    17771777        ElementMatrix* Ke = CreateKMatrixSSAFriction(basalelement);
    17781778
    … …  
    18531853                        basalelement = element;
    18541854                        break;
    18551855                case Mesh3DEnum:
    1856                         if(!element->IsOnBed()) return NULL;
     1856                        if(!element->IsOnBase()) return NULL;
    18571857                        basalelement = element->SpawnBasalElement();
    18581858                        break;
    18591859                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    20172017                        basalelement = element;
    20182018                        break;
    20192019                case Mesh3DEnum:
    2020                         if(!element->IsOnBed()){xDelete<IssmDouble>(xyz_list); return;}
     2020                        if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
    20212021                        basalelement=element->SpawnBasalElement();
    20222022                        break;
    20232023                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    22352235        /* Check if ice in element */
    22362236        if(!element->IsIceInElement()) return NULL;
    22372237
    2238         if(element->IsFloating() || !element->IsOnBed()) return NULL;
     2238        if(element->IsFloating() || !element->IsOnBase()) return NULL;
    22392239
    22402240        /*Intermediaries*/
    22412241        int         dim,meshtype;
    … …  
    30403040}/*}}}*/
    30413041ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSFriction(Element* element){/*{{{*/
    30423042
    3043         if(element->IsFloating() || !element->IsOnBed()) return NULL;
     3043        if(element->IsFloating() || !element->IsOnBase()) return NULL;
    30443044
    30453045        /*If on water or not FS, skip stiffness: */
    30463046        int approximation;
    … …  
    31333133}/*}}}*/
    31343134ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSShelf(Element* element){/*{{{*/
    31353135
    3136         if(!element->IsFloating() || !element->IsOnBed()) return NULL;
     3136        if(!element->IsFloating() || !element->IsOnBase()) return NULL;
    31373137
    31383138        /*If on not water or not FS, skip stiffness: */
    31393139        int approximation,shelf_dampening;
    … …  
    35643564        IssmDouble *xyz_list_base = NULL;
    35653565
    35663566        /*Get basal element*/
    3567         if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     3567        if(!element->IsOnBase() || !element->IsFloating()) return NULL;
    35683568
    35693569        /*Get problem dimension*/
    35703570        element->FindParam(&meshtype,MeshTypeEnum);
    … …  
    45084508ElementMatrix* StressbalanceAnalysis::CreateKMatrixSSA3dFriction(Element* element){/*{{{*/
    45094509
    45104510        /*Initialize Element matrix and return if necessary*/
    4511         if(element->IsFloating() || !element->IsOnBed()) return NULL;
     4511        if(element->IsFloating() || !element->IsOnBase()) return NULL;
    45124512
    45134513        /*Build a tria element using the 3 nodes of the base of the penta. Then use
    45144514         * the tria functionality to build a friction stiffness matrix on these 3
    … …  
    47324732}/*}}}*/
    47334733ElementMatrix* StressbalanceAnalysis::CreateKMatrixCouplingSSAHOFriction(Element* element){/*{{{*/
    47344734
    4735         if(element->IsFloating() || !element->IsOnBed()) return NULL;
     4735        if(element->IsFloating() || !element->IsOnBase()) return NULL;
    47364736
    47374737        /*Constants*/
    47384738        int numnodes    = element->GetNumberOfNodes();
    … …  
    49384938
    49394939        /*If on water or not FS, skip stiffness: */
    49404940        element->GetInputValue(&approximation,ApproximationEnum);
    4941         if(element->IsFloating() || !element->IsOnBed()) return NULL;
     4941        if(element->IsFloating() || !element->IsOnBase()) return NULL;
    49424942
    49434943        int vnumnodes = element->NumberofNodesVelocity();
    49444944        int pnumnodes = element->NumberofNodesPressure();
    … …  
    52235223        IssmDouble  basis[6]; //for the six nodes of the penta
    52245224
    52255225        /*Initialize Element vector and return if necessary*/
    5226         if(!element->IsOnBed() || element->IsFloating()) return NULL;
     5226        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    52275227        element->GetInputValue(&approximation,ApproximationEnum);
    52285228        if(approximation!=HOFSApproximationEnum) return NULL;
    52295229
    … …  
    53875387        IssmDouble  *xyz_list      = NULL;
    53885388
    53895389        /*Initialize Element vector and return if necessary*/
    5390         if(!element->IsOnBed() || element->IsFloating()) return NULL;
     5390        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    53915391        element->GetInputValue(&approximation,ApproximationEnum);
    53925392        if(approximation!=SSAFSApproximationEnum) return NULL;
    53935393        int vnumnodes = element->NumberofNodesVelocity();

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

     
    164164                        basalelement = element;
    165165                        break;
    166166                case Mesh3DEnum:
    167                         if(!element->IsOnBed()) return NULL;
     167                        if(!element->IsOnBase()) return NULL;
    168168                        basalelement = element->SpawnBasalElement();
    169169                        break;
    170170                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    269269                        basalelement = element;
    270270                        break;
    271271                case Mesh3DEnum:
    272                         if(!element->IsOnBed()) return NULL;
     272                        if(!element->IsOnBase()) return NULL;
    273273                        basalelement = element->SpawnBasalElement();
    274274                        break;
    275275                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    398398
    399399        element->FindParam(&meshtype,MeshTypeEnum);
    400400        if(meshtype!=Mesh2DhorizontalEnum){
    401                 if(!element->IsOnBed()) return;
     401                if(!element->IsOnBase()) return;
    402402                basalelement=element->SpawnBasalElement();
    403403        }
    404404        else{

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

     
    280280        if(!element->IsIceInElement()) return NULL;
    281281
    282282        /*Initialize Element matrix and return if necessary*/
    283         if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     283        if(!element->IsOnBase() || !element->IsFloating()) return NULL;
    284284
    285285        IssmDouble  dt,Jdet,D;
    286286        IssmDouble *xyz_list_base = NULL;
    287287
    288288        /*Get basal element*/
    289         if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     289        if(!element->IsOnBase() || !element->IsFloating()) return NULL;
    290290
    291291        /*Fetch number of nodes for this finite element*/
    292292        int numnodes = element->GetNumberOfNodes();
    … …  
    433433        if(!element->IsIceInElement()) return NULL;
    434434
    435435        /* Geothermal flux on ice sheet base and basal friction */
    436         if(!element->IsOnBed() || element->IsFloating()) return NULL;
     436        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    437437
    438438        IssmDouble  dt,Jdet,geothermalflux,vx,vy,vz;
    439439        IssmDouble  alpha2,scalar,basalfriction,heatflux;
    … …  
    498498        IssmDouble *xyz_list_base = NULL;
    499499
    500500        /*Get basal element*/
    501         if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     501        if(!element->IsOnBase() || !element->IsFloating()) return NULL;
    502502
    503503        /*Fetch number of nodes for this finite element*/
    504504        int numnodes = element->GetNumberOfNodes();

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

     
    122122                        dim = 2;
    123123                        break;
    124124                case Mesh3DEnum:
    125                         if(!element->IsOnBed()) return NULL;
     125                        if(!element->IsOnBase()) return NULL;
    126126                        basalelement = element->SpawnBasalElement();
    127127                        dim = 2;
    128128                        break;
    … …  
    270270                        basalelement = element;
    271271                        break;
    272272                case Mesh3DEnum:
    273                         if(!element->IsOnBed()) return NULL;
     273                        if(!element->IsOnBase()) return NULL;
    274274                        basalelement = element->SpawnBasalElement();
    275275                        break;
    276276                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    383383
    384384        element->FindParam(&meshtype,MeshTypeEnum);
    385385        if(meshtype!=Mesh2DhorizontalEnum){
    386                 if(!element->IsOnBed()) return;
     386                if(!element->IsOnBase()) return;
    387387                basalelement=element->SpawnBasalElement();
    388388        }
    389389        else{

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

     
    353353        if(!element->IsIceInElement()) return NULL;
    354354
    355355        /*Initialize Element matrix and return if necessary*/
    356         if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     356        if(!element->IsOnBase() || !element->IsFloating()) return NULL;
    357357
    358358        /*Intermediaries*/
    359359        IssmDouble  dt,Jdet,D;
    … …  
    538538        if(!element->IsIceInElement()) return NULL;
    539539
    540540        /* implementation of the basal condition decision chart of Aschwanden 2012, Fig.5 */
    541         if(!element->IsOnBed() || element->IsFloating()) return NULL;
     541        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    542542
    543543        IssmDouble  dt,Jdet,enthalpy,pressure,watercolumn,geothermalflux,vx,vy,vz;
    544544        IssmDouble  enthalpyup,pressureup,alpha2,scalar,basalfriction,heatflux;
    … …  
    628628        if(!element->IsIceInElement()) return NULL;
    629629
    630630        /*Get basal element*/
    631         if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     631        if(!element->IsOnBase() || !element->IsFloating()) return NULL;
    632632
    633633        IssmDouble  h_pmp,dt,Jdet,scalar_ocean,pressure;
    634634        IssmDouble *xyz_list_base = NULL;
    … …  
    901901        if(!element->IsIceInElement()) return;
    902902
    903903        /* Only compute melt rates at the base of grounded ice*/
    904         if(!element->IsOnBed() || element->IsFloating()) return;
     904        if(!element->IsOnBase() || element->IsFloating()) return;
    905905
    906906        /* Intermediaries */
    907907        const int   dim=3;
    … …  
    10471047        if(!element->IsIceInElement()) return;
    10481048
    10491049        /* Only drain waterfraction of ice column from element at base*/
    1050         if(!element->IsOnBed()) return; //FIXME: allow freeze on for floating elements
     1050        if(!element->IsOnBase()) return; //FIXME: allow freeze on for floating elements
    10511051
    10521052        /* Intermediaries*/
    10531053        int is, numvertices, numsegments;
    … …  
    11491149        if(!element->IsIceInElement()) return;
    11501150
    11511151        /* Only update Constraints at the base of grounded ice*/
    1152         if(!(element->IsOnBed()) || element->IsFloating()) return;
     1152        if(!(element->IsOnBase()) || element->IsFloating()) return;
    11531153
    11541154        /*Intermediary*/
    11551155        bool        isdynamicbasalspc,setspc;

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

     
    118118                        dim = 2;
    119119                        break;
    120120                case Mesh2DverticalEnum:
    121                         if(!element->IsOnBed()) return NULL;
     121                        if(!element->IsOnBase()) return NULL;
    122122                        basalelement = element->SpawnBasalElement();
    123123                        dim = 1;
    124124                        break;
    125125                case Mesh3DEnum:
    126                         if(!element->IsOnBed()) return NULL;
     126                        if(!element->IsOnBase()) return NULL;
    127127                        basalelement = element->SpawnBasalElement();
    128128                        dim = 2;
    129129                        break;
    … …  
    241241                        dim = 2;
    242242                        break;
    243243                case Mesh2DverticalEnum:
    244                         if(!element->IsOnBed()) return NULL;
     244                        if(!element->IsOnBase()) return NULL;
    245245                        basalelement = element->SpawnBasalElement();
    246246                        dim = 1;
    247247                        break;
    248248                case Mesh3DEnum:
    249                         if(!element->IsOnBed()) return NULL;
     249                        if(!element->IsOnBase()) return NULL;
    250250                        basalelement = element->SpawnBasalElement();
    251251                        dim = 2;
    252252                        break;
    … …  
    372372        for(int i=0;i<femmodel->elements->Size();i++){
    373373
    374374                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    375                 if(!element->IsOnBed()) continue;
     375                if(!element->IsOnBase()) continue;
    376376
    377377                int             numnodes = element->GetNumberOfNodes();
    378378                Input* groundedice_input = element->GetInput(MaskGroundediceLevelsetEnum);  _assert_(groundedice_input);

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

     
    8383}/*}}}*/
    8484ElementMatrix* ExtrapolationAnalysis::CreateKMatrix(Element* element){/*{{{*/
    8585
    86         if(!element->IsOnBed()) return NULL;
     86        if(!element->IsOnBase()) return NULL;
    8787        Element* basalelement = element->SpawnBasalElement();
    8888
    8989        /*Intermediaries */
    … …  
    218218}/*}}}*/
    219219ElementVector* ExtrapolationAnalysis::CreatePVector(Element* element){/*{{{*/
    220220
    221         if(!element->IsOnBed()) return NULL;
     221        if(!element->IsOnBase()) return NULL;
    222222        Element* basalelement = element->SpawnBasalElement();
    223223
    224224        /*Intermediaries */

  • ../trunk-jpl/src/c/classes/Loads/Pengrid.cpp

     
    613613                *punstable=unstable;
    614614                return;
    615615        }
    616         if(!element->IsOnBed()){
     616        if(!element->IsOnBase()){
    617617                unstable=0;
    618618                active=0;
    619619                *punstable=unstable;

  • ../trunk-jpl/src/c/classes/Elements/Element.h

     
    8888                void       GetVerticesCoordinates(IssmDouble** xyz_list);
    8989                void       GetVerticesSidList(int* sidlist);
    9090                void       GetVerticesConnectivityList(int* connectivitylist);
    91                 bool       HasNodeOnBed();
     91                bool       HasNodeOnBase();
    9292                bool       HasNodeOnSurface();
    9393                int        Id();
    9494                int        Sid();
    … …  
    182182                virtual int    GetNumberOfVertices(void)=0;
    183183
    184184                virtual bool   IsNodeOnShelfFromFlags(IssmDouble* flags)=0;
    185                 virtual bool   IsOnBed()=0;
     185                virtual bool   IsOnBase()=0;
    186186                virtual bool   IsOnSurface()=0;
    187187                virtual void   GetGroundedPart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlyfloating)=0;
    188188                virtual IssmDouble GetGroundedPortion(IssmDouble* xyz_list)=0;

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

     
    111111                                IssmDouble values2[NUMVERTICES]={0.};
    112112                                int        numindices;
    113113                                int       *indices = NULL;
    114                                 int        index = this->EdgeOnBedIndex();
     114                                int        index = this->EdgeOnBaseIndex();
    115115                                NodeOnEdgeIndices(&numindices,&indices,index,this->FiniteElement());
    116116                                for(int i=0;i<numindices;i++){
    117117                                        values2[indices[i]] = values[i];
    … …  
    475475        if(gl[2]==0.) gl[2]=gl[2]+epsilon;
    476476
    477477        if(meshtype==Mesh2DverticalEnum){
    478                 this->EdgeOnBedIndices(&index1,&index2);
     478                this->EdgeOnBaseIndices(&index1,&index2);
    479479                if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded
    480480                else if(gl[index1]<0 && gl[index2]<0) phi=0; // All floating
    481481                else if(gl[index1]<0 && gl[index2]>0){ //index2 grounded
    … …  
    584584
    585585        /*Allocate Output*/
    586586        IssmDouble* xyz_list_edge = xNew<IssmDouble>(2*3);
    587         this->EdgeOnBedIndices(&indices[0],&indices[1]);
     587        this->EdgeOnBaseIndices(&indices[0],&indices[1]);
    588588        for(int i=0;i<2;i++) for(int j=0;j<2;j++) xyz_list_edge[i*3+j]=xyz_list[indices[i]][j];
    589589
    590590        /*Assign output pointer*/
    … …  
    11311131
    11321132}
    11331133/*}}}*/
    1134 /*FUNCTION Tria::IsOnBed {{{*/
    1135 bool Tria::IsOnBed(){
     1134/*FUNCTION Tria::IsOnBase {{{*/
     1135bool Tria::IsOnBase(){
    11361136
    11371137        int meshtype;
    11381138        this->parameters->FindParam(&meshtype,MeshTypeEnum);
    11391139        switch(meshtype){
    11401140                case Mesh2DverticalEnum:
    1141                         return HasEdgeOnBed();
     1141                        return HasEdgeOnBase();
    11421142                case Mesh2DhorizontalEnum:
    11431143                        return true;
    11441144                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
    … …  
    11911191
    11921192}
    11931193/*}}}*/
    1194 /*FUNCTION Tria::HasEdgeOnBed {{{*/
    1195 bool Tria::HasEdgeOnBed(){
     1194/*FUNCTION Tria::HasEdgeOnBase {{{*/
     1195bool Tria::HasEdgeOnBase(){
    11961196
    11971197        IssmDouble values[NUMVERTICES];
    11981198        IssmDouble sum;
    … …  
    12351235        }
    12361236}
    12371237/*}}}*/
    1238 /*FUNCTION Tria::EdgeOnBedIndices{{{*/
    1239 void Tria::EdgeOnBedIndices(int* pindex1,int* pindex2){
     1238/*FUNCTION Tria::EdgeOnBaseIndices{{{*/
     1239void Tria::EdgeOnBaseIndices(int* pindex1,int* pindex2){
    12401240
    12411241        IssmDouble values[NUMVERTICES];
    12421242        int        indices[3][2] = {{1,2},{2,0},{0,1}};
    … …  
    12771277        _error_("Could not find 2 vertices on surface");
    12781278}
    12791279/*}}}*/
    1280 /*FUNCTION Tria::EdgeOnBedIndex{{{*/
    1281 int Tria::EdgeOnBedIndex(void){
     1280/*FUNCTION Tria::EdgeOnBaseIndex{{{*/
     1281int Tria::EdgeOnBaseIndex(void){
    12821282
    12831283        IssmDouble values[NUMVERTICES];
    12841284        int        indices[3][2] = {{1,2},{2,0},{0,1}};
    … …  
    13181318/*FUNCTION Tria::FSContactMigration{{{*/
    13191319void Tria::FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){
    13201320
    1321         if(!IsOnBed()) return;
     1321        if(!IsOnBase()) return;
    13221322
    13231323        /*Intermediaries*/
    13241324        IssmDouble* xyz_list = NULL;
    … …  
    13971397Gauss* Tria::NewGaussBase(int order){
    13981398
    13991399        int indices[2];
    1400         this->EdgeOnBedIndices(&indices[0],&indices[1]);
     1400        this->EdgeOnBaseIndices(&indices[0],&indices[1]);
    14011401        return new GaussTria(indices[0],indices[1],order);
    14021402}
    14031403/*}}}*/
    … …  
    16431643
    16441644        /*For FS only: we want the CS to be tangential to the bedrock*/
    16451645        inputs->GetInputValue(&approximation,ApproximationEnum);
    1646         if(!HasNodeOnBed() ||  approximation!=FSApproximationEnum) return;
     1646        if(!HasNodeOnBase() ||  approximation!=FSApproximationEnum) return;
    16471647
    16481648        //printf("element number %i \n",this->id);
    16491649        /*Get inputs*/
    … …  
    17731773                case Mesh2DhorizontalEnum:
    17741774                        return this;
    17751775                case Mesh2DverticalEnum:
    1776                         _assert_(HasEdgeOnBed());
    1777                         this->EdgeOnBedIndices(&index1,&index2);
     1776                        _assert_(HasEdgeOnBase());
     1777                        this->EdgeOnBaseIndices(&index1,&index2);
    17781778                        return SpawnSeg(index1,index2);
    17791779                default:
    17801780                        _error_("not implemented yet");
    … …  
    19861986/*FUNCTION Tria::UpdateConstraintsExtrudeFromBase{{{*/
    19871987void  Tria::UpdateConstraintsExtrudeFromBase(void){
    19881988
    1989         if(!HasEdgeOnBed()) return;
     1989        if(!HasEdgeOnBase()) return;
    19901990
    19911991        int        extrusioninput;
    19921992        IssmDouble value,isonbed;

  • ../trunk-jpl/src/c/classes/Elements/Tria.h

     
    6969                int         GetNodeIndex(Node* node);
    7070                int         GetNumberOfNodes(void);
    7171                int         GetNumberOfVertices(void);
    72                 bool        IsOnBed();
     72                bool        IsOnBase();
    7373                bool        IsOnSurface();
    74                 bool        HasEdgeOnBed();
     74                bool        HasEdgeOnBase();
    7575                bool        HasEdgeOnSurface();
    7676                void        EdgeOnSurfaceIndices(int* pindex1,int* pindex);
    77                 void        EdgeOnBedIndices(int* pindex1,int* pindex);
    78                 int         EdgeOnBedIndex();
     77                void        EdgeOnBaseIndices(int* pindex1,int* pindex);
     78                int         EdgeOnBaseIndex();
    7979                int         EdgeOnSurfaceIndex();
    8080                bool        IsNodeOnShelfFromFlags(IssmDouble* flags);
    8181                int         NumberofNodesVelocity(void);

  • ../trunk-jpl/src/c/classes/Elements/Penta.cpp

     
    118118void  Penta::AddBasalInput(int input_enum,IssmDouble* values, int interpolation_enum){
    119119
    120120        _assert_(this->inputs);
    121         if(!IsOnBed()) return;
     121        if(!IsOnBase()) return;
    122122        else{
    123123                if(interpolation_enum==P1Enum){
    124124                        int        i;
    … …  
    151151        GaussPenta *gauss                      = NULL;
    152152
    153153        /* Basal friction can only be found at the base of an ice sheet: */
    154         if (!IsOnBed() || IsFloating()){
     154        if (!IsOnBase() || IsFloating()){
    155155                //empty friction:
    156156                this->inputs->AddInput(new PentaInput(BasalFrictionEnum,&basalfriction[0],P1Enum));
    157157                return;
    … …  
    218218        /*retrieve some parameters: */
    219219        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    220220
    221         if(!IsOnBed()){
     221        if(!IsOnBase()){
    222222                //put zero
    223223                sigma_b->SetValue(id-1,0.0,INS_VAL);
    224224                return;
    … …  
    373373/*FUNCTION Penta::Delta18oParameterization{{{*/
    374374void  Penta::Delta18oParameterization(void){
    375375        /*Are we on the base? If not, return*/
    376         if(!IsOnBed()) return;
     376        if(!IsOnBase()) return;
    377377
    378378        int        i;
    379379        IssmDouble monthlytemperatures[NUMVERTICES][12],monthlyprec[NUMVERTICES][12];
    … …  
    543543        penta=this;
    544544        for(;;){
    545545                /*Stop if we have reached the surface, else, take lower penta*/
    546                 if (penta->IsOnBed()) break;
     546                if (penta->IsOnBase()) break;
    547547
    548548                /* get lower Penta*/
    549549                penta=penta->GetLowerPenta();
    … …  
    11241124        /*recover parameters: */
    11251125
    11261126        /*Are we on the base? If not, return*/
    1127         if(!IsOnBed()) return;
     1127        if(!IsOnBase()) return;
    11281128
    11291129        /*OK, we are on bed. Initialize global inputs as 0*/
    11301130        total_thickness_input =new PentaInput(ThicknessEnum,zeros_list,P1Enum);
    … …  
    12241224        Input **base_inputs = NULL;
    12251225
    12261226        /*Are we on the base, not on the surface?:*/
    1227         if(!IsOnBed()) return;
     1227        if(!IsOnBase()) return;
    12281228
    12291229        /*Step1: Get and Extrude original input: */
    12301230        num_inputs=1;
    … …  
    14141414        Penta  *penta   = NULL;
    14151415
    14161416        /*If not on bed, return*/
    1417         if (!IsOnBed()) return;
     1417        if (!IsOnBase()) return;
    14181418
    14191419        /*Get dof list: */
    14201420        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    … …  
    15031503        }
    15041504}
    15051505/*}}}*/
    1506 /*FUNCTION Penta::IsOnBed{{{*/
    1507 bool Penta::IsOnBed(void){
     1506/*FUNCTION Penta::IsOnBase{{{*/
     1507bool Penta::IsOnBase(void){
    15081508
    15091509        bool onbed;
    15101510        inputs->GetInputValue(&onbed,MeshElementonbedEnum);
    … …  
    19121912
    19131913        /*For FS only: we want the CS to be tangential to the bedrock*/
    19141914        inputs->GetInputValue(&approximation,ApproximationEnum);
    1915         if(!IsOnBed() || (approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum &&  approximation!=HOFSApproximationEnum)) return;
     1915        if(!IsOnBase() || (approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum &&  approximation!=HOFSApproximationEnum)) return;
    19161916
    19171917        /*Get number of nodes for velocity only and base*/
    19181918        BasalNodeIndices(&numindices,&indices,this->VelocityInterpolation());
    … …  
    20212021/*FUNCTION Penta::SpawnBasalElement{{{*/
    20222022Element*  Penta::SpawnBasalElement(void){
    20232023
    2024         _assert_(this->IsOnBed());
     2024        _assert_(this->IsOnBase());
    20252025
    20262026        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    20272027        this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum);
    … …  
    21082108        /*Bail out if this element if:
    21092109         * -> Non SSA not on the surface
    21102110         * -> SSA (2d model) and not on bed) */
    2111         if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
     2111        if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
    21122112                return 0;
    21132113        }
    21142114        else if (approximation==SSAApproximationEnum){
    … …  
    24892489/*FUNCTION Penta::UpdateConstraintsExtrudeFromBase{{{*/
    24902490void  Penta::UpdateConstraintsExtrudeFromBase(void){
    24912491
    2492         if(!IsOnBed()) return;
     2492        if(!IsOnBase()) return;
    24932493
    24942494        int        extrusioninput;
    24952495        IssmDouble value,isonbed;
    … …  
    26642664        IssmDouble base,bed,surface,bathymetry;
    26652665        IssmDouble xyz_list[NUMVERTICES][3];
    26662666
    2667         if(!IsIceInElement() || IsFloating() || !IsOnBed())return 0;
     2667        if(!IsIceInElement() || IsFloating() || !IsOnBase())return 0;
    26682668
    26692669        rho_ice=matpar->GetRhoIce();
    26702670        rho_water=matpar->GetRhoWater();
    … …  
    27322732
    27332733        IssmDouble mass_flux=0;
    27342734
    2735         if(!IsOnBed()) return mass_flux;
     2735        if(!IsOnBase()) return mass_flux;
    27362736
    27372737        /*Depth Averaging Vx and Vy*/
    27382738        this->InputDepthAverageAtBase(VxEnum,VxAverageEnum);
    … …  
    27562756
    27572757        IssmDouble mass_flux=0;
    27582758
    2759         if(!IsOnBed()) return mass_flux;
     2759        if(!IsOnBase()) return mass_flux;
    27602760
    27612761        /*Depth Averaging Vx and Vy*/
    27622762        this->InputDepthAverageAtBase(VxEnum,VxAverageEnum);
    … …  
    29222922        Input* input=NULL;
    29232923
    29242924        if(enum_type==MaterialsRheologyBbarEnum){
    2925                 if(!IsOnBed()) return;
     2925                if(!IsOnBase()) return;
    29262926                input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    29272927        }
    29282928        else if(enum_type==DamageDbarEnum){
    2929                 if(!IsOnBed()) return;
     2929                if(!IsOnBase()) return;
    29302930                input=(Input*)inputs->GetInput(DamageDEnum);
    29312931        }
    29322932        else{
    … …  
    31143114                        /*Nothing, J does not depends on the parameter being inverted for*/
    31153115                        break;
    31163116                case DragCoefficientAbsGradientEnum:
    3117                         if(IsOnBed()){
     3117                        if(IsOnBase()){
    31183118                                tria=(Tria*)SpawnTria(0,1,2);
    31193119                                tria->GradjDragGradient(gradient,control_index);
    31203120                                delete tria->material; delete tria;
    31213121                        }
    31223122                        break;
    31233123                case RheologyBbarAbsGradientEnum:
    3124                         if(IsOnBed()){
     3124                        if(IsOnBase()){
    31253125                                tria=(Tria*)SpawnTria(0,1,2);
    31263126                                tria->GradjBGradient(gradient,control_index);
    31273127                                delete tria->material; delete tria;
    … …  
    31373137void  Penta::GradjDragSSA(Vector<IssmDouble>* gradient,int control_index){
    31383138
    31393139        /*Gradient is 0 if on shelf or not on bed*/
    3140         if(IsFloating() || !IsOnBed()) return;
     3140        if(IsFloating() || !IsOnBase()) return;
    31413141
    31423142        /*Spawn tria*/
    31433143        Tria* tria=(Tria*)SpawnTria(0,1,2);
    … …  
    31633163        GaussPenta *gauss=NULL;
    31643164
    31653165        /*Gradient is 0 if on shelf or not on bed*/
    3166         if(IsFloating() || !IsOnBed()) return;
     3166        if(IsFloating() || !IsOnBase()) return;
    31673167
    31683168        /*Retrieve all inputs and parameters*/
    31693169        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    … …  
    32363236        GaussPenta* gauss=NULL;
    32373237
    32383238        /*Gradient is 0 if on shelf or not on bed*/
    3239         if(IsFloating() || !IsOnBed()) return;
     3239        if(IsFloating() || !IsOnBase()) return;
    32403240
    32413241        /*Retrieve all inputs and parameters*/
    32423242        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    … …  
    33123312void  Penta::GradjBbarSSA(Vector<IssmDouble>* gradient,int control_index){
    33133313
    33143314        /*This element should be collapsed into a tria element at its base*/
    3315         if (!IsOnBed()) return;
     3315        if (!IsOnBase()) return;
    33163316
    33173317        /*Depth Average B*/
    33183318        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    … …  
    33323332void  Penta::GradjBbarHO(Vector<IssmDouble>* gradient,int control_index){
    33333333
    33343334        /*Gradient is computed on bed only (Bbar)*/
    3335         if (!IsOnBed()) return;
     3335        if (!IsOnBase()) return;
    33363336
    33373337        /*Depth Average B and D*/
    33383338        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    … …  
    33513351void  Penta::GradjBbarFS(Vector<IssmDouble>* gradient,int control_index){
    33523352
    33533353        /*Gradient is computed on bed only (Bbar)*/
    3354         if (!IsOnBed()) return;
     3354        if (!IsOnBase()) return;
    33553355
    33563356        /*Depth Average B and D*/
    33573357        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    … …  
    33813381        for(int i=0;i<num_controls;i++){
    33823382
    33833383                if(control_type[i]==MaterialsRheologyBbarEnum){
    3384                         if (!IsOnBed()) goto cleanup_and_return;
     3384                        if (!IsOnBase()) goto cleanup_and_return;
    33853385                        input=(Input*)this->inputs->GetInput(MaterialsRheologyBEnum); _assert_(input);
    33863386                }
    33873387                else if(control_type[i]==DamageDbarEnum){
    3388                         if (!IsOnBed()) goto cleanup_and_return;
     3388                        if (!IsOnBase()) goto cleanup_and_return;
    33893389                        input=(Input*)this->inputs->GetInput(DamageDEnum); _assert_(input);
    33903390                }
    33913391                else{
    … …  
    34263426        /*Bail out if this element if:
    34273427         * -> Non SSA and not on the surface
    34283428         * -> SSA (2d model) and not on bed) */
    3429         if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
     3429        if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
    34303430                return 0;
    34313431        }
    34323432        else if (approximation==SSAApproximationEnum){
    … …  
    34633463        /*Bail out if this element if:
    34643464         * -> Non SSA and not on the surface
    34653465         * -> SSA (2d model) and not on bed) */
    3466         if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
     3466        if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
    34673467                return 0;
    34683468        }
    34693469        else if (approximation==SSAApproximationEnum){
    … …  
    35003500        /*Bail out if this element if:
    35013501         * -> Non SSA and not on the surface
    35023502         * -> SSA (2d model) and not on bed) */
    3503         if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
     3503        if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
    35043504                return 0;
    35053505        }
    35063506        else if (approximation==SSAApproximationEnum){
    … …  
    35393539        /*Bail out if this element if:
    35403540         * -> Non SSA and not on the surface
    35413541         * -> SSA (2d model) and not on bed) */
    3542         if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
     3542        if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
    35433543                return 0;
    35443544        }
    35453545        else if (approximation==SSAApproximationEnum){
    … …  
    35763576        /*Bail out if this element if:
    35773577         * -> Non SSA and not on the surface
    35783578         * -> SSA (2d model) and not on bed) */
    3579         if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
     3579        if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
    35803580                return 0;
    35813581        }
    35823582        else if (approximation==SSAApproximationEnum){
    … …  
    36303630        Tria*  tria=NULL;
    36313631
    36323632        /*If on water, on shelf or not on bed, skip: */
    3633         if(!IsIceInElement()|| IsFloating() || !IsOnBed()) return 0;
     3633        if(!IsIceInElement()|| IsFloating() || !IsOnBase()) return 0;
    36343634
    36353635        tria=(Tria*)SpawnTria(0,1,2); //lower face is 0, upper face is 1
    36363636        J=tria->DragCoefficientAbsGradient();
    … …  
    36453645        Tria*  tria=NULL;
    36463646
    36473647        /*If on water, on shelf or not on bed, skip: */
    3648         if(!IsIceInElement() || !IsOnBed()) return 0;
     3648        if(!IsIceInElement() || !IsOnBase()) return 0;
    36493649
    36503650        tria=(Tria*)SpawnTria(0,1,2);
    36513651        J=tria->RheologyBbarAbsGradient();
    … …  
    38903890        IssmDouble h[NUMVERTICES],s[NUMVERTICES],b[NUMVERTICES],r[NUMVERTICES];
    38913891        IssmDouble melting[NUMVERTICES],phi[NUMVERTICES];
    38923892
    3893         if(!IsOnBed()) return;
     3893        if(!IsOnBase()) return;
    38943894
    38953895        /*Recover info at the vertices: */
    38963896        parameters->FindParam(&migration_style,GroundinglineMigrationEnum);

  • ../trunk-jpl/src/c/classes/Elements/Penta.h

     
    186186                void           InputUpdateFromSolutionOneDof(IssmDouble* solutiong,int enum_type);
    187187                void           InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type);
    188188                bool             IsOnSurface(void);
    189                 bool             IsOnBed(void);
     189                bool             IsOnBase(void);
    190190                bool           IsNodeOnShelfFromFlags(IssmDouble* flags);
    191191                void           JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
    192192                void           JacobianDeterminantLine(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss);

  • ../trunk-jpl/src/c/classes/Elements/Tetra.cpp

     
    102102        this->inputs->Configure(parameters);
    103103}
    104104/*}}}*/
    105 /*FUNCTION Tetra::FaceOnBedIndices{{{*/
    106 void Tetra::FaceOnBedIndices(int* pindex1,int* pindex2,int* pindex3){
     105/*FUNCTION Tetra::FaceOnBaseIndices{{{*/
     106void Tetra::FaceOnBaseIndices(int* pindex1,int* pindex2,int* pindex3){
    107107
    108108        IssmDouble values[NUMVERTICES];
    109109        int        indices[4][3] = {{0,1,2},{0,1,3},{1,2,3},{2,0,3}};
    … …  
    186186
    187187        /*Allocate Output*/
    188188        IssmDouble* xyz_list_edge = xNew<IssmDouble>(3*3);
    189         this->FaceOnBedIndices(&indices[0],&indices[1],&indices[2]);
     189        this->FaceOnBaseIndices(&indices[0],&indices[1],&indices[2]);
    190190        for(int i=0;i<3;i++) for(int j=0;j<3;j++) xyz_list_edge[i*3+j]=xyz_list[indices[i]][j];
    191191
    192192        /*Assign output pointer*/
    … …  
    226226        return z;
    227227}
    228228/*}}}*/
    229 /*FUNCTION Tetra::HasFaceOnBed{{{*/
    230 bool Tetra::HasFaceOnBed(){
     229/*FUNCTION Tetra::HasFaceOnBase{{{*/
     230bool Tetra::HasFaceOnBase(){
    231231
    232232        IssmDouble values[NUMVERTICES];
    233233        IssmDouble sum;
    … …  
    397397        xDelete<int>(doflist);
    398398}
    399399/*}}}*/
    400 /*FUNCTION Tetra::IsOnBed {{{*/
    401 bool Tetra::IsOnBed(){
    402         return HasFaceOnBed();
     400/*FUNCTION Tetra::IsOnBase {{{*/
     401bool Tetra::IsOnBase(){
     402        return HasFaceOnBase();
    403403}
    404404/*}}}*/
    405405/*FUNCTION Tetra::IsOnSurface {{{*/
    … …  
    475475Gauss* Tetra::NewGaussBase(int order){
    476476
    477477        int indices[3];
    478         this->FaceOnBedIndices(&indices[0],&indices[1],&indices[2]);
     478        this->FaceOnBaseIndices(&indices[0],&indices[1],&indices[2]);
    479479        return new GaussTetra(indices[0],indices[1],indices[2],order);
    480480}
    481481/*}}}*/
    … …  
    659659
    660660        /*For FS only: we want the CS to be tangential to the bedrock*/
    661661        inputs->GetInputValue(&approximation,ApproximationEnum);
    662         if(IsFloating() || !HasNodeOnBed() ||  approximation!=FSApproximationEnum) return;
     662        if(IsFloating() || !HasNodeOnBase() ||  approximation!=FSApproximationEnum) return;
    663663
    664664        //printf("element number %i \n",this->id);
    665665        /*Get inputs*/
    … …  
    726726/*FUNCTION Tetra::SpawnBasalElement{{{*/
    727727Element*  Tetra::SpawnBasalElement(void){
    728728
    729         _assert_(HasFaceOnBed());
     729        _assert_(HasFaceOnBase());
    730730
    731731        int index1,index2,index3;
    732         this->FaceOnBedIndices(&index1,&index2,&index3);
     732        this->FaceOnBaseIndices(&index1,&index2,&index3);
    733733        return SpawnTria(index1,index2,index3);
    734734}/*}}}*/
    735735/*FUNCTION Tetra::SpawnTopElement{{{*/

  • ../trunk-jpl/src/c/classes/Elements/Seg.h

     
    7171                void        GetVerticesCoordinates(IssmDouble** pxyz_list);
    7272                void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list){_error_("not implemented yet");};
    7373                void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list){_error_("not implemented yet");};
    74                 bool        IsOnBed(){_error_("not implemented yet");};
     74                bool        IsOnBase(){_error_("not implemented yet");};
    7575                bool        IsOnSurface(){_error_("not implemented yet");};
    7676                bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
    7777                void        JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);

  • ../trunk-jpl/src/c/classes/Elements/Tetra.h

     
    6060                void        Delta18oParameterization(void){_error_("not implemented yet");};
    6161                void        ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){_error_("not implemented yet");};
    6262                void        FaceOnFrontIndices(int* pindex1,int* pindex2,int* pindex3);
    63                 void        FaceOnBedIndices(int* pindex1,int* pindex2,int* pindex3);
     63                void        FaceOnBaseIndices(int* pindex1,int* pindex2,int* pindex3);
    6464                void        FaceOnSurfaceIndices(int* pindex1,int* pindex2,int* pindex3);
    6565                void        FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){_error_("not implemented yet");};
    6666                int         FiniteElement(void);
    … …  
    7373                int         GetNumberOfVertices(void);
    7474                void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
    7575                void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
    76                 bool        HasFaceOnBed();
     76                bool        HasFaceOnBase();
    7777                bool        HasFaceOnSurface();
    78                 bool        IsOnBed();
     78                bool        IsOnBase();
    7979                bool        IsOnSurface();
    8080                bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
    8181                void        JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);

  • ../trunk-jpl/src/c/classes/Elements/Element.cpp

     
    548548        for(int i=0;i<numvertices;i++) connectivity[i]=this->vertices[i]->Connectivity();
    549549}
    550550/*}}}*/
    551 bool Element::HasNodeOnBed(){/*{{{*/
     551bool Element::HasNodeOnBase(){/*{{{*/
    552552        return (this->inputs->Max(MeshVertexonbedEnum)>0.);
    553553}/*}}}*/
    554554bool Element::HasNodeOnSurface(){/*{{{*/
Note: See TracBrowser for help on using the repository browser.