Changeset 17585


Ignore:
Timestamp:
03/27/14 18:14:43 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: renaming OnBed OnBase for consistency

Location:
issm/trunk-jpl/src/c
Files:
33 edited

Legend:

Unmodified
Added
Removed

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

    r17212 r17585  
    5959                        break;
    6060                case Mesh3DEnum:
    61                         if(!element->IsOnBed()) return NULL;
     61                        if(!element->IsOnBase()) return NULL;
    6262                        basalelement = element->SpawnBasalElement();
    6363                        break;

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

    r17516 r17585  
    6565                        break;
    6666                case Mesh3DEnum:
    67                         if(!element->IsOnBed()) return NULL;
     67                        if(!element->IsOnBase()) return NULL;
    6868                        basalelement = element->SpawnBasalElement();
    6969                        break;
    … …  
    694694                        break;
    695695                case Mesh3DEnum:
    696                         if(!element->IsOnBed()) return NULL;
     696                        if(!element->IsOnBase()) return NULL;
    697697                        basalelement = element->SpawnBasalElement();
    698698                        break;

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

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

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

    r17564 r17585  
    158158                        break;
    159159                case Mesh3DEnum:
    160                         if(!element->IsOnBed()) return NULL;
     160                        if(!element->IsOnBase()) return NULL;
    161161                        basalelement = element->SpawnBasalElement();
    162162                        break;

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

    r17516 r17585  
    123123                        break;
    124124                case Mesh3DEnum:
    125                         if(!element->IsOnBed()) return NULL;
     125                        if(!element->IsOnBase()) return NULL;
    126126                        basalelement = element->SpawnBasalElement();
    127127                        dim = 2;
    … …  
    271271                        break;
    272272                case Mesh3DEnum:
    273                         if(!element->IsOnBed()) return NULL;
     273                        if(!element->IsOnBase()) return NULL;
    274274                        basalelement = element->SpawnBasalElement();
    275275                        break;
    … …  
    384384        element->FindParam(&meshtype,MeshTypeEnum);
    385385        if(meshtype!=Mesh2DhorizontalEnum){
    386                 if(!element->IsOnBed()) return;
     386                if(!element->IsOnBase()) return;
    387387                basalelement=element->SpawnBasalElement();
    388388        }

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

    r17555 r17585  
    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*/
    … …  
    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;
    … …  
    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;
    … …  
    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 */
    … …  
    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*/
    … …  
    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*/

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

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

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

    r17212 r17585  
    163163ElementMatrix* ExtrudeFromBaseAnalysis::CreateKMatrixBed(Element* element){/*{{{*/
    164164
    165         if(!element->IsOnBed()) return NULL;
     165        if(!element->IsOnBase()) return NULL;
    166166
    167167        /*Intermediaries */

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

    r17212 r17585  
    163163ElementMatrix* ExtrudeFromTopAnalysis::CreateKMatrixBed(Element* element){/*{{{*/
    164164
    165         if(!element->IsOnBed()) return NULL;
     165        if(!element->IsOnBase()) return NULL;
    166166
    167167        /*Intermediaries */

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

    r17584 r17585  
    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;
    … …  
    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;
    … …  
    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();

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

    r17564 r17585  
    121121                        break;
    122122                case Mesh3DEnum:
    123                         if(!element->IsOnBed()) return NULL;
     123                        if(!element->IsOnBase()) return NULL;
    124124                        basalelement = element->SpawnBasalElement();
    125125                        break;
    … …  
    225225                        break;
    226226                case Mesh3DEnum:
    227                         if(!element->IsOnBed()) return NULL;
     227                        if(!element->IsOnBase()) return NULL;
    228228                        basalelement = element->SpawnBasalElement();
    229229                        break;
    … …  
    323323
    324324        if(meshtype!=Mesh2DhorizontalEnum){
    325                 if(!element->IsOnBed()) return;
     325                if(!element->IsOnBase()) return;
    326326                basalelement=element->SpawnBasalElement();
    327327        }
    … …  
    494494                switch(meshtype){
    495495                case Mesh2DhorizontalEnum:
    496                         if(!element->IsOnBed()) return;                 
     496                        if(!element->IsOnBase()) return;                       
    497497                        B = element->GetMaterialParameter(MaterialsRheologyBbarEnum);
    498498                        break;
    … …  
    614614                        break;
    615615                case Mesh3DEnum:
    616                         if(!element->IsOnBed()) return;
     616                        if(!element->IsOnBase()) return;
    617617                        basalelement = element->SpawnBasalElement();
    618618                        break;
    … …  
    694694                        break;
    695695                case Mesh3DEnum:
    696                         if(!element->IsOnBed()) return;
     696                        if(!element->IsOnBase()) return;
    697697                        basalelement = element->SpawnBasalElement();
    698698                        break;

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

    r17564 r17585  
    165165                        break;
    166166                case Mesh3DEnum:
    167                         if(!element->IsOnBed()) return NULL;
     167                        if(!element->IsOnBase()) return NULL;
    168168                        basalelement = element->SpawnBasalElement();
    169169                        break;
    … …  
    270270                        break;
    271271                case Mesh3DEnum:
    272                         if(!element->IsOnBed()) return NULL;
     272                        if(!element->IsOnBase()) return NULL;
    273273                        basalelement = element->SpawnBasalElement();
    274274                        break;
    … …  
    399399        element->FindParam(&meshtype,MeshTypeEnum);
    400400        if(meshtype!=Mesh2DhorizontalEnum){
    401                 if(!element->IsOnBed()) return;
     401                if(!element->IsOnBase()) return;
    402402                basalelement=element->SpawnBasalElement();
    403403        }

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

    r17555 r17585  
    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;
    … …  
    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;

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

    r17362 r17585  
    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;
    … …  
    166166                        break;
    167167                case Mesh3DEnum:
    168                         if(!element->IsOnBed()) return NULL;
     168                        if(!element->IsOnBase()) return NULL;
    169169                        basalelement = element->SpawnBasalElement();
    170170                        break;

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

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

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

    r17555 r17585  
    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
    … …  
    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
    … …  
    677677        element->FindParam(&meshtype,MeshTypeEnum);
    678678        if(meshtype!=Mesh2DhorizontalEnum){
    679                 if(!element->IsOnBed()) return;
     679                if(!element->IsOnBase()) return;
    680680                basalelement=element->SpawnBasalElement();
    681681        }

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

    r17555 r17585  
    8585
    8686        /*Get basal element*/
    87         if(!element->IsOnBed()) return NULL;
     87        if(!element->IsOnBase()) return NULL;
    8888        Element* basalelement = element->SpawnBasalElement();
    8989

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

    r17564 r17585  
    115115                        break;
    116116                case Mesh3DEnum:
    117                         if(!element->IsOnBed()) return NULL;
     117                        if(!element->IsOnBase()) return NULL;
    118118                        basalelement = element->SpawnBasalElement();
    119119                        break;

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

    r17564 r17585  
    115115                        break;
    116116                case Mesh3DEnum:
    117                         if(!element->IsOnBed()) return NULL;
     117                        if(!element->IsOnBase()) return NULL;
    118118                        basalelement = element->SpawnBasalElement();
    119119                        break;

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

    r17555 r17585  
    10851085                        break;
    10861086                case Mesh3DEnum:
    1087                         if(!element->IsOnBed()) return NULL;
     1087                        if(!element->IsOnBase()) return NULL;
    10881088                        basalelement = element->SpawnBasalElement();
    10891089                        break;
    … …  
    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;
    … …  
    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;
    … …  
    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;
    … …  
    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);
    … …  
    18541854                        break;
    18551855                case Mesh3DEnum:
    1856                         if(!element->IsOnBed()) return NULL;
     1856                        if(!element->IsOnBase()) return NULL;
    18571857                        basalelement = element->SpawnBasalElement();
    18581858                        break;
    … …  
    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;
    … …  
    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*/
    … …  
    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: */
    … …  
    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: */
    … …  
    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*/
    … …  
    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
    … …  
    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*/
    … …  
    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();
    … …  
    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;
    … …  
    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;

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

    r17560 r17585  
    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;
    … …  
    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;
    … …  
    419419
    420420                /*Deal with basal velocities*/
    421                 if(element->IsOnBed()){
     421                if(element->IsOnBase()){
    422422                        drag_input->GetInputValue(&drag,gauss);
    423423

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

    r17555 r17585  
    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*/

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

    r17555 r17585  
    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;
    … …  
    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*/
    … …  
    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;
    … …  
    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*/

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

    r17555 r17585  
    549549}
    550550/*}}}*/
    551 bool Element::HasNodeOnBed(){/*{{{*/
     551bool Element::HasNodeOnBase(){/*{{{*/
    552552        return (this->inputs->Max(MeshVertexonbedEnum)>0.);
    553553}/*}}}*/

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

    r17579 r17585  
    8989                void       GetVerticesSidList(int* sidlist);
    9090                void       GetVerticesConnectivityList(int* connectivitylist);
    91                 bool       HasNodeOnBed();
     91                bool       HasNodeOnBase();
    9292                bool       HasNodeOnSurface();
    9393                int        Id();
    … …  
    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;

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

    r17555 r17585  
    119119
    120120        _assert_(this->inputs);
    121         if(!IsOnBed()) return;
     121        if(!IsOnBase()) return;
    122122        else{
    123123                if(interpolation_enum==P1Enum){
    … …  
    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));
    … …  
    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);
    … …  
    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;
    … …  
    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*/
    … …  
    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*/
    … …  
    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: */
    … …  
    14151415
    14161416        /*If not on bed, return*/
    1417         if (!IsOnBed()) return;
     1417        if (!IsOnBase()) return;
    14181418
    14191419        /*Get dof list: */
    … …  
    15041504}
    15051505/*}}}*/
    1506 /*FUNCTION Penta::IsOnBed{{{*/
    1507 bool Penta::IsOnBed(void){
     1506/*FUNCTION Penta::IsOnBase{{{*/
     1507bool Penta::IsOnBase(void){
    15081508
    15091509        bool onbed;
    … …  
    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*/
    … …  
    20222022Element*  Penta::SpawnBasalElement(void){
    20232023
    2024         _assert_(this->IsOnBed());
     2024        _assert_(this->IsOnBase());
    20252025
    20262026        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    … …  
    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        }
    … …  
    24902490void  Penta::UpdateConstraintsExtrudeFromBase(void){
    24912491
    2492         if(!IsOnBed()) return;
     2492        if(!IsOnBase()) return;
    24932493
    24942494        int        extrusioninput;
    … …  
    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();
    … …  
    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*/
    … …  
    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*/
    … …  
    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        }
    … …  
    31153115                        break;
    31163116                case DragCoefficientAbsGradientEnum:
    3117                         if(IsOnBed()){
     3117                        if(IsOnBase()){
    31183118                                tria=(Tria*)SpawnTria(0,1,2);
    31193119                                tria->GradjDragGradient(gradient,control_index);
    … …  
    31223122                        break;
    31233123                case RheologyBbarAbsGradientEnum:
    3124                         if(IsOnBed()){
     3124                        if(IsOnBase()){
    31253125                                tria=(Tria*)SpawnTria(0,1,2);
    31263126                                tria->GradjBGradient(gradient,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*/
    … …  
    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*/
    … …  
    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*/
    … …  
    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*/
    … …  
    33333333
    33343334        /*Gradient is computed on bed only (Bbar)*/
    3335         if (!IsOnBed()) return;
     3335        if (!IsOnBase()) return;
    33363336
    33373337        /*Depth Average B and D*/
    … …  
    33523352
    33533353        /*Gradient is computed on bed only (Bbar)*/
    3354         if (!IsOnBed()) return;
     3354        if (!IsOnBase()) return;
    33553355
    33563356        /*Depth Average B and D*/
    … …  
    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                }
    … …  
    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        }
    … …  
    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        }
    … …  
    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        }
    … …  
    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        }
    … …  
    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        }
    … …  
    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
    … …  
    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);
    … …  
    38913891        IssmDouble melting[NUMVERTICES],phi[NUMVERTICES];
    38923892
    3893         if(!IsOnBed()) return;
     3893        if(!IsOnBase()) return;
    38943894
    38953895        /*Recover info at the vertices: */

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

    r17579 r17585  
    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);

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

    r17579 r17585  
    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");};

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

    r17536 r17585  
    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];
    … …  
    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
    … …  
    227227}
    228228/*}}}*/
    229 /*FUNCTION Tetra::HasFaceOnBed{{{*/
    230 bool Tetra::HasFaceOnBed(){
     229/*FUNCTION Tetra::HasFaceOnBase{{{*/
     230bool Tetra::HasFaceOnBase(){
    231231
    232232        IssmDouble values[NUMVERTICES];
    … …  
    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/*}}}*/
    … …  
    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}
    … …  
    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);
    … …  
    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}/*}}}*/

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

    r17579 r17585  
    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");};
    … …  
    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");};

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

    r17583 r17585  
    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++){
    … …  
    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
    … …  
    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
    … …  
    11321132}
    11331133/*}}}*/
    1134 /*FUNCTION Tria::IsOnBed {{{*/
    1135 bool Tria::IsOnBed(){
     1134/*FUNCTION Tria::IsOnBase {{{*/
     1135bool Tria::IsOnBase(){
    11361136
    11371137        int meshtype;
    … …  
    11391139        switch(meshtype){
    11401140                case Mesh2DverticalEnum:
    1141                         return HasEdgeOnBed();
     1141                        return HasEdgeOnBase();
    11421142                case Mesh2DhorizontalEnum:
    11431143                        return true;
    … …  
    11921192}
    11931193/*}}}*/
    1194 /*FUNCTION Tria::HasEdgeOnBed {{{*/
    1195 bool Tria::HasEdgeOnBed(){
     1194/*FUNCTION Tria::HasEdgeOnBase {{{*/
     1195bool Tria::HasEdgeOnBase(){
    11961196
    11971197        IssmDouble values[NUMVERTICES];
    … …  
    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];
    … …  
    12781278}
    12791279/*}}}*/
    1280 /*FUNCTION Tria::EdgeOnBedIndex{{{*/
    1281 int Tria::EdgeOnBedIndex(void){
     1280/*FUNCTION Tria::EdgeOnBaseIndex{{{*/
     1281int Tria::EdgeOnBaseIndex(void){
    12821282
    12831283        IssmDouble values[NUMVERTICES];
    … …  
    13191319void Tria::FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){
    13201320
    1321         if(!IsOnBed()) return;
     1321        if(!IsOnBase()) return;
    13221322
    13231323        /*Intermediaries*/
    … …  
    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}
    … …  
    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);
    … …  
    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:
    … …  
    19871987void  Tria::UpdateConstraintsExtrudeFromBase(void){
    19881988
    1989         if(!HasEdgeOnBed()) return;
     1989        if(!HasEdgeOnBase()) return;
    19901990
    19911991        int        extrusioninput;

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

    r17582 r17585  
    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);

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

    r17516 r17585  
    614614                return;
    615615        }
    616         if(!element->IsOnBed()){
     616        if(!element->IsOnBase()){
    617617                unstable=0;
    618618                active=0;
Note: See TracChangeset for help on using the changeset viewer.