Changeset 17610


Ignore:
Timestamp:
03/31/14 16:43:09 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: renamed onbed -> onbase

Location:
issm/trunk-jpl
Files:
2 added
2 deleted
78 edited

Legend:

Unmodified
Added
Removed

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

    r17585 r17610  
    4545
    4646        if(iomodel->meshtype==Mesh3DEnum){
    47                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     47                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4848                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4949        }
    … …  
    5858
    5959        /*First fetch data: */
    60         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     60        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6161        if(stabilization!=3){
    6262                ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);
    … …  
    6565                ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1DGEnum);
    6666        }
    67         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     67        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6868}/*}}}*/
    6969void BalancethicknessAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    3434
    3535        if(iomodel->meshtype==Mesh3DEnum){
    36                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     36                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3737                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3838        }

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

    r17585 r17610  
    7373void DamageEvolutionAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    7474
    75         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbedEnum);
     75        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    7676        ::CreateNodes(nodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum);
    77         iomodel->DeleteData(1,MeshVertexonbedEnum);
     77        iomodel->DeleteData(1,MeshVertexonbaseEnum);
    7878}/*}}}*/
    7979void DamageEvolutionAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17511 r17610  
    2323
    2424        if(iomodel->meshtype==Mesh2DverticalEnum){
    25                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     25                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    2727}/*}}}*/

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

    r17609 r17610  
    5959        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    6060        iomodel->FetchDataToInput(elements,MaskGroundediceLevelsetEnum);
    61         iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     61        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    6262        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    6363        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);
    … …  
    8686        if(islevelset){
    8787                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    88                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum); // required for updating active nodes
     88                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    8989        }
    9090
    … …  
    9494void EnthalpyAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    9595
    96         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     96        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    9797        ::CreateNodes(nodes,iomodel,EnthalpyAnalysisEnum,P1Enum);
    98         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     98        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    9999}/*}}}*/
    100100void EnthalpyAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17600 r17610  
    3131        }
    3232        if(iomodel->meshtype==Mesh3DEnum){
    33                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     33                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3434                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3535        }
    … …  
    3838void ExtrapolationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3939        int finiteelement=P1Enum;
    40         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     40        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4141        ::CreateNodes(nodes,iomodel,ExtrapolationAnalysisEnum,finiteelement);
    42         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     42        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4343}
    4444/*}}}*/

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

    r17585 r17610  
    2323
    2424        if(iomodel->meshtype==Mesh2DverticalEnum){
    25                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     25                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    2727}/*}}}*/

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

    r17585 r17610  
    2323
    2424        if(iomodel->meshtype==Mesh2DverticalEnum){
    25                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     25                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    2626        }
    2727}/*}}}*/

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

    r17600 r17610  
    3737        if(iomodel->meshtype==Mesh3DEnum){
    3838                iomodel->FetchDataToInput(elements,VzEnum);
    39                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     39                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4040                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4141        }
    … …  
    4343void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4444
    45         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     45        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4646        ::CreateNodes(nodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum);
    47         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     47        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4848}/*}}}*/
    4949void FreeSurfaceBaseAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    5858        /*Create Penpair for vertex_pairing: */
    5959        IssmDouble *vertex_pairing=NULL;
    60         IssmDouble *nodeonbed=NULL;
     60        IssmDouble *nodeonbase=NULL;
    6161        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    62         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
     62        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    6363        for(int i=0;i<numvertex_pairing;i++){
    6464
    … …  
    7070                        /*Skip if one of the two is not on the bed*/
    7171                        if(iomodel->meshtype!=Mesh2DhorizontalEnum){
    72                                 if(!(reCast<bool>(nodeonbed[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbed[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
     72                                if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
    7373                        }
    7474
    … …  
    8888        /*free ressources: */
    8989        iomodel->DeleteData(vertex_pairing,MasstransportVertexPairingEnum);
    90         iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
     90        iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
    9191}/*}}}*/
    9292
    … …  
    368368
    369369        /*Intermediary*/
    370         IssmDouble phi,isonbed,base;
     370        IssmDouble phi,isonbase,base;
    371371
    372372        for(int i=0;i<femmodel->elements->Size();i++){
    … …  
    377377                int             numnodes = element->GetNumberOfNodes();
    378378                Input* groundedice_input = element->GetInput(MaskGroundediceLevelsetEnum);  _assert_(groundedice_input);
    379                 Input* onbed_input       = element->GetInput(MeshVertexonbedEnum);          _assert_(onbed_input);
     379                Input* onbase_input       = element->GetInput(MeshVertexonbaseEnum);          _assert_(onbase_input);
    380380                Input* base_input        = element->GetInput(BaseEnum);                     _assert_(base_input);
    381381
    … …  
    383383                for(int iv=0;iv<numnodes;iv++){
    384384                        gauss->GaussNode(element->GetElementType(),iv);
    385                         onbed_input->GetInputValue(&isonbed,gauss);
    386                         if(isonbed==1.){
     385                        onbase_input->GetInputValue(&isonbase,gauss);
     386                        if(isonbase==1.){
    387387                                groundedice_input->GetInputValue(&phi,gauss);
    388388                                if(phi>=0.){

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

    r17518 r17610  
    3838        if(iomodel->meshtype==Mesh3DEnum){
    3939                iomodel->FetchDataToInput(elements,VzEnum);
    40                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     40                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4141                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4242        }
    … …  
    5252void FreeSurfaceTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    5353
    54         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     54        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    5555        ::CreateNodes(nodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum);
    56         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     56        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    5757}/*}}}*/
    5858void FreeSurfaceTopAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17609 r17610  
    5656        iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum);
    5757        iomodel->FetchDataToInput(elements,HydrologydcEplThicknessEnum);
    58         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     58        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    5959       
    6060        //      elements->InputDuplicate(HydrologydcEplInitialThicknessEnum,HydrologydcEplThicknessEnum);
    … …  
    7373        if(!isefficientlayer) return;
    7474
    75         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     75        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    7676        ::CreateNodes(nodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum);
    77         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     77        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    7878}/*}}}*/
    7979void HydrologyDCEfficientAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    8888        iomodel->FetchDataToInput(elements,SedimentHeadEnum);
    8989        iomodel->FetchDataToInput(elements,HydrologydcSedimentTransmitivityEnum);
    90         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     90        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    9191
    9292        if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveNodeEnum);
    … …  
    101101        if(hydrology_model!=HydrologydcEnum) return;
    102102
    103         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     103        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    104104        ::CreateNodes(nodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum);
    105         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     105        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    106106}/*}}}*/
    107107void HydrologyDCInefficientAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    121121        if(hydrology_model!=HydrologydcEnum) return;
    122122
    123         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbedEnum);
     123        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    124124
    125125        //create penalties for nodes: no node can have water above the max
    … …  
    132132                        }
    133133                }
    134                 else if(reCast<int>(iomodel->Data(MeshVertexonbedEnum)[i])){
     134                else if(reCast<int>(iomodel->Data(MeshVertexonbaseEnum)[i])){
    135135                        if(iomodel->my_vertices[i]){
    136136                                loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,HydrologyDCInefficientAnalysisEnum));
    … …  
    138138                }
    139139        }
    140         iomodel->DeleteData(1,MeshVertexonbedEnum);
     140        iomodel->DeleteData(1,MeshVertexonbaseEnum);
    141141}/*}}}*/
    142142

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

    r17609 r17610  
    4444        iomodel->FetchDataToInput(elements,SurfaceEnum);
    4545        iomodel->FetchDataToInput(elements,BaseEnum);
    46         iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     46        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4747        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4848        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    … …  
    6262        if(hydrology_model!=HydrologyshreveEnum) return;
    6363
    64         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     64        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6565        ::CreateNodes(nodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
    66         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     66        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6767}/*}}}*/
    6868void HydrologyShreveAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    2828        if(iomodel->meshtype==Mesh3DEnum){
    29                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     29                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    3232        if(iomodel->meshtype==Mesh2DverticalEnum){
    33                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     33                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    … …  
    3737
    3838        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
    39                 iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     39                iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4040        }
    4141        else if(iomodel->meshtype==Mesh2DverticalEnum){
    42                 iomodel->FetchData(1,MeshVertexonbedEnum);
     42                iomodel->FetchData(1,MeshVertexonbaseEnum);
    4343        }
    4444        ::CreateNodes(nodes,iomodel,L2ProjectionBaseAnalysisEnum,P1Enum);
    45         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     45        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4646}/*}}}*/
    4747void L2ProjectionBaseAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    3737        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    3838        if(iomodel->meshtype==Mesh3DEnum){
    39                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     39                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    4040        }
    4141}/*}}}*/
    … …  
    5252
    5353        if(iomodel->meshtype==Mesh3DEnum){
    54                 iomodel->FetchData(1,MeshVertexonbedEnum);
     54                iomodel->FetchData(1,MeshVertexonbaseEnum);
    5555        }
    5656        else if(iomodel->meshtype==Mesh2DverticalEnum){
    57                 iomodel->FetchData(1,MeshVertexonbedEnum);
     57                iomodel->FetchData(1,MeshVertexonbaseEnum);
    5858        }
    5959        ::CreateNodes(nodes,iomodel,L2ProjectionEPLAnalysisEnum,P1Enum);
    60         iomodel->DeleteData(1,MeshVertexonbedEnum);
     60        iomodel->DeleteData(1,MeshVertexonbaseEnum);
    6161}/*}}}*/
    6262void L2ProjectionEPLAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    3838void LevelsetAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3939        int finiteelement=P1Enum;
    40         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     40        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4141        ::CreateNodes(nodes,iomodel,LevelsetAnalysisEnum,finiteelement);
    42         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     42        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4343}
    4444/*}}}*/

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

    r17600 r17610  
    3636void LsfReinitializationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737        int finiteelement=P1Enum;
    38         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     38        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    3939        ::CreateNodes(nodes,iomodel,LsfReinitializationAnalysisEnum,finiteelement);
    40         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     40        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4141}/*}}}*/
    4242void LsfReinitializationAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    8484
    8585        if(iomodel->meshtype==Mesh3DEnum){
    86                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     86                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    8787                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    8888        }
    … …  
    9191                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    9292                if(iomodel->meshtype!=Mesh2DhorizontalEnum)
    93                         iomodel->FetchDataToInput(elements,MeshVertexonbedEnum); // required for updating active nodes
     93                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    9494        }
    9595
    … …  
    135135
    136136        /*Create Nodes either DG or CG depending on stabilization*/
    137         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     137        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    138138        if(stabilization!=3){
    139139                ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1Enum);
    … …  
    142142                ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1DGEnum);
    143143        }
    144         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     144        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    145145}/*}}}*/
    146146void MasstransportAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    193193        /*Create Penpair for vertex_pairing: */
    194194        IssmDouble *vertex_pairing=NULL;
    195         IssmDouble *nodeonbed=NULL;
     195        IssmDouble *nodeonbase=NULL;
    196196        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum);
    197         if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
     197        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    198198
    199199        for(int i=0;i<numvertex_pairing;i++){
    … …  
    206206                        /*Skip if one of the two is not on the bed*/
    207207                        if(iomodel->meshtype!=Mesh2DhorizontalEnum){
    208                                 if(!(reCast<bool>(nodeonbed[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbed[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
     208                                if(!(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+0])-1])) || !(reCast<bool>(nodeonbase[reCast<int>(vertex_pairing[2*i+1])-1]))) continue;
    209209                        }
    210210
    … …  
    224224        /*free ressources: */
    225225        iomodel->DeleteData(vertex_pairing,MasstransportVertexPairingEnum);
    226         iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
     226        iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
    227227
    228228}/*}}}*/

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

    r17585 r17610  
    3434        iomodel->FetchDataToInput(elements,FrictionQEnum);
    3535        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    36         iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     36        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3737        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3838        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);
    … …  
    4444void MeltingAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4545
    46         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     46        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4747        ::CreateNodes(nodes,iomodel,MeltingAnalysisEnum,P1Enum);
    48         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     48        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    4949}/*}}}*/
    5050void MeltingAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    … …  
    5757
    5858        //create penalties for nodes: no node can have a temperature over the melting point
    59         iomodel->FetchData(1,MeshVertexonbedEnum);
     59        iomodel->FetchData(1,MeshVertexonbaseEnum);
    6060        CreateSingleNodeToElementConnectivity(iomodel);
    6161
    6262        for(int i=0;i<iomodel->numberofvertices;i++){
    6363                if(iomodel->my_vertices[i]){
    64                         if (reCast<int>(iomodel->Data(MeshVertexonbedEnum)[i])){
     64                        if (reCast<int>(iomodel->Data(MeshVertexonbaseEnum)[i])){
    6565                                loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,MeltingAnalysisEnum));
    6666                        }
    6767                }
    6868        }
    69         iomodel->DeleteData(1,MeshVertexonbedEnum);
     69        iomodel->DeleteData(1,MeshVertexonbaseEnum);
    7070
    7171}/*}}}*/

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

    r17585 r17610  
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    2828        if(iomodel->meshtype==Mesh3DEnum){
    29                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     29                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    3232        if(iomodel->meshtype==Mesh2DverticalEnum){
    33                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     33                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    3636void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    37         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbedEnum);
     37        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    3838        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum);
    39         if(iomodel->meshtype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbedEnum);
     39        if(iomodel->meshtype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
    4040}/*}}}*/
    4141void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    2727        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    2828        if(iomodel->meshtype==Mesh3DEnum){
    29                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     29                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3030                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3131        }
    3232        if(iomodel->meshtype==Mesh2DverticalEnum){
    33                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     33                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    3434        }
    3535}/*}}}*/
    3636void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    37         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbedEnum);
     37        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(1,MeshVertexonbaseEnum);
    3838        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum);
    39         if(iomodel->meshtype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbedEnum);
     39        if(iomodel->meshtype==Mesh3DEnum) iomodel->DeleteData(1,MeshVertexonbaseEnum);
    4040}/*}}}*/
    4141void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17609 r17610  
    211211
    212212        if(iomodel->meshtype==Mesh3DEnum){
    213                 iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     213                iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    214214                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    215215                iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    … …  
    220220        }
    221221        if(iomodel->meshtype==Mesh3DtetrasEnum){
    222                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     222                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    223223                iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum);
    224224                iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    … …  
    231231        }
    232232        if(isFS){
    233                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum);
     233                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum);
    234234                iomodel->FetchDataToInput(elements,PressureEnum,0.);
    235235                if(dakota_analysis)elements->InputDuplicate(PressureEnum,QmuPressureEnum);
    … …  
    238238                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    239239                if(iomodel->meshtype!=Mesh2DhorizontalEnum)
    240                         iomodel->FetchDataToInput(elements,MeshVertexonbedEnum); // required for updating active nodes
     240                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    241241        }
    242242
    … …  
    291291                }
    292292                iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    293                 if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
     293                if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
    294294                ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
    295                 iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     295                iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    296296                                        FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    297297        }
    … …  
    303303                if(!nodes) nodes = new Nodes();
    304304
    305                 iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     305                iomodel->FetchData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    306306                                        FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    307307                if(isFS){
    … …  
    340340                        }
    341341                }
    342                 iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     342                iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    343343                                        FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    344344        }
    … …  
    363363        IssmDouble *nodeonHO   = NULL;
    364364        IssmDouble *nodeonFS   = NULL;
    365         IssmDouble *nodeonbed      = NULL;
     365        IssmDouble *nodeonbase      = NULL;
    366366        IssmDouble *groundedice_ls = NULL;
    367367        IssmDouble *vertices_type  = NULL;
    … …  
    421421                        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    422422                        iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    423                         iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
     423                        iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    424424                        iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    425425                        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
    … …  
    448448                        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);
    449449                        iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    450                         iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
     450                        iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
    451451                        iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
    452452
    … …  
    514514        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
    515515        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    516         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
     516        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbase,NULL,NULL,MeshVertexonbaseEnum);
    517517        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    518518        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    … …  
    744744        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
    745745        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    746         if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
     746        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbase,MeshVertexonbaseEnum);
    747747        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
    748748        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);

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

    r17600 r17610  
    4343                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    4444                if(iomodel->meshtype!=Mesh2DhorizontalEnum)
    45                         iomodel->FetchDataToInput(elements,MeshVertexonbedEnum); // required for updating active nodes
     45                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    4646        }
    4747
    … …  
    6565        iomodel->FetchData(4,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    6666        if(iomodel->meshtype!=Mesh2DhorizontalEnum){
    67                 iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     67                iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    6868        }
    6969
    … …  
    8484        }
    8585
    86         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     86        iomodel->DeleteData(6,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    8787                                FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    8888

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

    r17609 r17610  
    3434        iomodel->FetchDataToInput(elements,BaseEnum);
    3535        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    36         iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     36        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    3737        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3838        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    … …  
    4545        if(iomodel->meshtype!=Mesh3DEnum) return;
    4646
    47         iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
     47        iomodel->FetchData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    4848        ::CreateNodes(nodes,iomodel,StressbalanceVerticalAnalysisEnum,P1Enum);
    49         iomodel->DeleteData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
     49        iomodel->DeleteData(3,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    5050}/*}}}*/
    5151void StressbalanceVerticalAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17609 r17610  
    5555        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    5656        iomodel->FetchDataToInput(elements,MaskGroundediceLevelsetEnum);
    57         iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     57        iomodel->FetchDataToInput(elements,MeshElementonbaseEnum);
    5858        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    5959        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);
    … …  
    7878        if(islevelset){
    7979                iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    80                 iomodel->FetchDataToInput(elements,MeshVertexonbedEnum); // required for updating active nodes
     80                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    8181        }
    8282}/*}}}*/
    8383void ThermalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    8484
    85         if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     85        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    8686        ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P1Enum);
    87         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     87        iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum);
    8888}/*}}}*/
    8989void ThermalAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/

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

    r17585 r17610  
    550550/*}}}*/
    551551bool Element::HasNodeOnBase(){/*{{{*/
    552         return (this->inputs->Max(MeshVertexonbedEnum)>0.);
     552        return (this->inputs->Max(MeshVertexonbaseEnum)>0.);
    553553}/*}}}*/
    554554bool Element::HasNodeOnSurface(){/*{{{*/
    … …  
    750750                                name==HydrologydcEplThicknessEnum ||
    751751                                name==HydrologydcMaskEplactiveNodeEnum ||
    752                                 name==MeshVertexonbedEnum
     752                                name==MeshVertexonbaseEnum
    753753
    754754                                ) {

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

    r17600 r17610  
    15071507bool Penta::IsOnBase(void){
    15081508
    1509         bool onbed;
    1510         inputs->GetInputValue(&onbed,MeshElementonbedEnum);
    1511         return onbed;
     1509        bool onbase;
     1510        inputs->GetInputValue(&onbase,MeshElementonbaseEnum);
     1511        return onbase;
    15121512}
    15131513/*}}}*/
    … …  
    24932493
    24942494        int        extrusioninput;
    2495         IssmDouble value,isonbed;
     2495        IssmDouble value,isonbase;
    24962496
    24972497        this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
    24982498        Input* input = inputs->GetInput(extrusioninput);      _assert_(extrusioninput);
    2499         Input* onbed = inputs->GetInput(MeshVertexonbedEnum); _assert_(onbed);
     2499        Input* onbase = inputs->GetInput(MeshVertexonbaseEnum); _assert_(onbase);
    25002500
    25012501        GaussPenta* gauss=new GaussPenta();
    25022502        for(int iv=0;iv<this->NumberofNodes();iv++){
    25032503                gauss->GaussNode(this->element_type,iv);
    2504                 onbed->GetInputValue(&isonbed,gauss);
    2505                 if(isonbed==1.){
     2504                onbase->GetInputValue(&isonbase,gauss);
     2505                if(isonbase==1.){
    25062506                        input->GetInputValue(&value,gauss);
    25072507                        this->nodes[iv]->ApplyConstraint(0,value);

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

    r17585 r17610  
    110110
    111111        /*Retrieve all inputs and parameters*/
    112         GetInputListOnVertices(&values[0],MeshVertexonbedEnum);
     112        GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    113113
    114114        for(int i=0;i<4;i++){
    … …  
    234234
    235235        /*Retrieve all inputs and parameters*/
    236         GetInputListOnVertices(&values[0],MeshVertexonbedEnum);
     236        GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    237237        sum = values[0]+values[1]+values[2]+values[3];
    238238
    … …  
    654654
    655655        int          approximation;
    656         IssmDouble*  vertexonbed= NULL;
     656        IssmDouble*  vertexonbase= NULL;
    657657        IssmDouble   slopex,slopey,groundedice;
    658658        IssmDouble   xz_plane[6];
    … …  
    667667        Input* slopey_input=inputs->GetInput(BedSlopeYEnum); _assert_(slopey_input);
    668668        Input* groundedicelevelset_input=inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
    669         vertexonbed = xNew<IssmDouble>(numnodes);
    670         this->GetInputListOnNodesVelocity(&vertexonbed[0],MeshVertexonbedEnum);
     669        vertexonbase = xNew<IssmDouble>(numnodes);
     670        this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
    671671
    672672        /*Loop over basal nodes and update their CS*/
    … …  
    674674        for(int i=0;i<this->NumberofNodesVelocity();i++){
    675675
    676                 if(vertexonbed[i]==1){
     676                if(vertexonbase[i]==1){
    677677                        gauss->GaussNode(this->VelocityInterpolation(),i);
    678678
    … …  
    704704
    705705        /*cleanup*/
    706         xDelete<IssmDouble>(vertexonbed);
     706        xDelete<IssmDouble>(vertexonbase);
    707707        delete gauss;
    708708}

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

    r17600 r17610  
    11991199
    12001200        /*Retrieve all inputs and parameters*/
    1201         GetInputListOnVertices(&values[0],MeshVertexonbedEnum);
     1201        GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    12021202        sum = values[0]+values[1]+values[2];
    12031203
    … …  
    12431243
    12441244        /*Retrieve all inputs and parameters*/
    1245         GetInputListOnVertices(&values[0],MeshVertexonbedEnum);
     1245        GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    12461246
    12471247        for(int i=0;i<3;i++){
    … …  
    12851285
    12861286        /*Retrieve all inputs and parameters*/
    1287         GetInputListOnVertices(&values[0],MeshVertexonbedEnum);
     1287        GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    12881288
    12891289        for(int i=0;i<3;i++){
    … …  
    16381638
    16391639        int          approximation;
    1640         IssmDouble*  vertexonbed= NULL;
     1640        IssmDouble*  vertexonbase= NULL;
    16411641        IssmDouble   slope,groundedice;
    16421642        IssmDouble   xz_plane[6];
    … …  
    16501650        Input* slope_input=inputs->GetInput(BedSlopeXEnum);                             _assert_(slope_input);
    16511651        Input* groundedicelevelset_input=inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
    1652         vertexonbed = xNew<IssmDouble>(numnodes);
    1653         this->GetInputListOnNodesVelocity(&vertexonbed[0],MeshVertexonbedEnum);
     1652        vertexonbase = xNew<IssmDouble>(numnodes);
     1653        this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
    16541654
    16551655        /*Loop over basal nodes and update their CS*/
    … …  
    16571657        for(int i=0;i<this->NumberofNodesVelocity();i++){
    16581658
    1659                 if(vertexonbed[i]==1){
     1659                if(vertexonbase[i]==1){
    16601660                        gauss->GaussNode(this->VelocityInterpolation(),i);
    16611661                        slope_input->GetInputValue(&slope,gauss);
    … …  
    16791679
    16801680        /*cleanup*/
    1681         xDelete<IssmDouble>(vertexonbed);
     1681        xDelete<IssmDouble>(vertexonbase);
    16821682        delete gauss;
    16831683}
    … …  
    19901990
    19911991        int        extrusioninput;
    1992         IssmDouble value,isonbed;
     1992        IssmDouble value,isonbase;
    19931993
    19941994        this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
    19951995        Input* input = inputs->GetInput(extrusioninput);      _assert_(input);
    1996         Input* onbed = inputs->GetInput(MeshVertexonbedEnum); _assert_(onbed);
     1996        Input* onbase = inputs->GetInput(MeshVertexonbaseEnum); _assert_(onbase);
    19971997
    19981998        GaussTria* gauss=new GaussTria();
    19991999        for(int iv=0;iv<this->NumberofNodes();iv++){
    20002000                gauss->GaussNode(this->element_type,iv);
    2001                 onbed->GetInputValue(&isonbed,gauss);
    2002                 if(isonbed==1.){
     2001                onbase->GetInputValue(&isonbase,gauss);
     2002                if(isonbase==1.){
    20032003                        input->GetInputValue(&value,gauss);
    20042004                        this->nodes[iv]->ApplyConstraint(0,value);

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

    r17600 r17610  
    6363                if(iomodel->meshtype!=Mesh2DhorizontalEnum){
    6464                        /*We have a  3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    65                         _assert_(iomodel->Data(MeshVertexonbedEnum));
     65                        _assert_(iomodel->Data(MeshVertexonbaseEnum));
    6666                        _assert_(iomodel->Data(FlowequationVertexEquationEnum));
    67                         if(in_approximation==SSAApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
     67                        if(in_approximation==SSAApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbaseEnum)[io_index])){
    6868                                this->Deactivate();
    6969                        }
    70                         if(in_approximation==L1L2ApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
     70                        if(in_approximation==L1L2ApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbaseEnum)[io_index])){
    7171                                this->Deactivate();
    7272                        }
    7373                        if(in_approximation==SSAHOApproximationEnum && reCast<int>(iomodel->Data(FlowequationBorderSSAEnum)[io_index])){
    74                                 if(!reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
     74                                if(!reCast<int>(iomodel->Data(MeshVertexonbaseEnum)[io_index])){
    7575                                        this->Deactivate();
    7676                                }
    7777                        }
    7878                        if(in_approximation==SSAFSApproximationEnum && reCast<int>(iomodel->Data(FlowequationBorderSSAEnum)[io_index])){
    79                                 if(!reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
     79                                if(!reCast<int>(iomodel->Data(MeshVertexonbaseEnum)[io_index])){
    8080                                        for(k=0;k<=1;k++) this->FreezeDof(k);
    8181                                }
    … …  
    103103                if(iomodel->meshtype!=Mesh2DhorizontalEnum){
    104104                        /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    105                         _assert_(iomodel->Data(MeshVertexonbedEnum));
    106                         if(!(reCast<bool>(iomodel->Data(MeshVertexonbedEnum)[io_index]))){
     105                        _assert_(iomodel->Data(MeshVertexonbaseEnum));
     106                        if(!(reCast<bool>(iomodel->Data(MeshVertexonbaseEnum)[io_index]))){
    107107                                this->Deactivate();
    108108                        }

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

    r17463 r17610  
    7474
    7575                        if(solvein2d){
    76                                 IssmDouble *mask_isonbed = xNew<IssmDouble>(numnodes);
    77                                 element->GetInputListOnNodes(&mask_isonbed[0],MeshVertexonbedEnum);
    78                                 for(in=0;in<numnodes;in++)       mask[in]*=mask_isonbed[in];
    79                                 xDelete<IssmDouble>(mask_isonbed);
     76                                IssmDouble *mask_isonbase = xNew<IssmDouble>(numnodes);
     77                                element->GetInputListOnNodes(&mask_isonbase[0],MeshVertexonbaseEnum);
     78                                for(in=0;in<numnodes;in++)       mask[in]*=mask_isonbase[in];
     79                                xDelete<IssmDouble>(mask_isonbase);
    8080                        }
    8181                }

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

    r17572 r17610  
    195195        MaterialsMantleDensityEnum,
    196196        MeshAverageVertexConnectivityEnum,
    197         MeshElementonbedEnum,
     197        MeshElementonbaseEnum,
    198198        MeshElementonsurfaceEnum,
    199199        MeshElements2dEnum,
    … …  
    206206        MeshNumberofverticesEnum,
    207207        MeshUpperelementsEnum,
    208         MeshVertexonbedEnum,
     208        MeshVertexonbaseEnum,
    209209        MeshVertexonsurfaceEnum,
    210210        MeshXEnum,

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

    r17572 r17610  
    203203                case MaterialsMantleDensityEnum : return "MaterialsMantleDensity";
    204204                case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity";
    205                 case MeshElementonbedEnum : return "MeshElementonbed";
     205                case MeshElementonbaseEnum : return "MeshElementonbase";
    206206                case MeshElementonsurfaceEnum : return "MeshElementonsurface";
    207207                case MeshElements2dEnum : return "MeshElements2d";
    … …  
    214214                case MeshNumberofverticesEnum : return "MeshNumberofvertices";
    215215                case MeshUpperelementsEnum : return "MeshUpperelements";
    216                 case MeshVertexonbedEnum : return "MeshVertexonbed";
     216                case MeshVertexonbaseEnum : return "MeshVertexonbase";
    217217                case MeshVertexonsurfaceEnum : return "MeshVertexonsurface";
    218218                case MeshXEnum : return "MeshX";

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

    r17572 r17610  
    206206              else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum;
    207207              else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum;
    208               else if (strcmp(name,"MeshElementonbed")==0) return MeshElementonbedEnum;
     208              else if (strcmp(name,"MeshElementonbase")==0) return MeshElementonbaseEnum;
    209209              else if (strcmp(name,"MeshElementonsurface")==0) return MeshElementonsurfaceEnum;
    210210              else if (strcmp(name,"MeshElements2d")==0) return MeshElements2dEnum;
    … …  
    217217              else if (strcmp(name,"MeshNumberofvertices")==0) return MeshNumberofverticesEnum;
    218218              else if (strcmp(name,"MeshUpperelements")==0) return MeshUpperelementsEnum;
    219               else if (strcmp(name,"MeshVertexonbed")==0) return MeshVertexonbedEnum;
     219              else if (strcmp(name,"MeshVertexonbase")==0) return MeshVertexonbaseEnum;
    220220              else if (strcmp(name,"MeshVertexonsurface")==0) return MeshVertexonsurfaceEnum;
    221221              else if (strcmp(name,"MeshX")==0) return MeshXEnum;

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

    r17562 r17610  
    1818
    1919                vertexonboundary            = NaN
    20                 vertexonbed                 = NaN
     20                vertexonbase                 = NaN
    2121                vertexonsurface             = NaN
    2222
    … …  
    6767                        md = checkfield(md,'fieldname','mesh.numberofelements','>',0);
    6868                        md = checkfield(md,'fieldname','mesh.numberofvertices','>',0);
    69                         md = checkfield(md,'fieldname','mesh.vertexonbed','size',[md.mesh.numberofvertices 1],'values',[0 1]);
     69                        md = checkfield(md,'fieldname','mesh.vertexonbase','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    7070                        md = checkfield(md,'fieldname','mesh.vertexonsurface','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    7171                        md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message','''mesh.average_vertex_connectivity'' should be at least 9 in 2d');
    … …  
    9090                        disp(sprintf('\n      Properties:'));
    9191                        fielddisplay(obj,'vertexonboundary','vertices on the boundary of the domain flag list');
    92                         fielddisplay(obj,'vertexonbed','vertices on the bed of the domain flag list');
     92                        fielddisplay(obj,'vertexonbase','vertices on the bed of the domain flag list');
    9393                        fielddisplay(obj,'vertexonsurface','vertices on the surface of the domain flag list');
    9494                        fielddisplay(obj,'segments','edges on domain boundary (vertex1 vertex2 element)');
    … …  
    111111                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
    112112                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
    113                         WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbed','format','BooleanMat','mattype',1);
     113                        WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
    114114                        WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
    115115                        WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');

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

    r17590 r17610  
    1818                hemisphere                  = NaN
    1919
    20                 elementonbed                = NaN
     20                elementonbase                = NaN
    2121                elementonsurface            = NaN
    22                 vertexonbed                 = NaN
     22                vertexonbase                 = NaN
    2323                vertexonsurface             = NaN
    2424                lowerelements               = NaN
    … …  
    8383                        md = checkfield(md,'fieldname','mesh.numberofvertices','>',0);
    8484                        %no checks for numberofedges lat long and hemisphere
    85                         md = checkfield(md,'fieldname','mesh.elementonbed','size',[md.mesh.numberofelements 1],'values',[0 1]);
     85                        md = checkfield(md,'fieldname','mesh.elementonbase','size',[md.mesh.numberofelements 1],'values',[0 1]);
    8686                        md = checkfield(md,'fieldname','mesh.elementonsurface','size',[md.mesh.numberofelements 1],'values',[0 1]);
    87                         md = checkfield(md,'fieldname','mesh.vertexonbed','size',[md.mesh.numberofvertices 1],'values',[0 1]);
     87                        md = checkfield(md,'fieldname','mesh.vertexonbase','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    8888                        md = checkfield(md,'fieldname','mesh.vertexonsurface','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    8989                        md = checkfield(md,'fieldname','mesh.z','>=',md.geometry.base-10^-10,'message','''mesh.z'' lower than bedrock');
    … …  
    111111                        disp(sprintf('\n      Properties:'));
    112112                        fielddisplay(obj,'numberoflayers','number of extrusion layers');
    113                         fielddisplay(obj,'vertexonbed','lower vertices flags list');
    114                         fielddisplay(obj,'elementonbed','lower elements flags list');
     113                        fielddisplay(obj,'vertexonbase','lower vertices flags list');
     114                        fielddisplay(obj,'elementonbase','lower elements flags list');
    115115                        fielddisplay(obj,'vertexonsurface','upper vertices flags list');
    116116                        fielddisplay(obj,'elementonsurface','upper elements flags list');
    … …  
    143143                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
    144144                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
    145                         WriteData(fid,'object',obj,'class','mesh','fieldname','elementonbed','format','BooleanMat','mattype',2);
     145                        WriteData(fid,'object',obj,'class','mesh','fieldname','elementonbase','format','BooleanMat','mattype',2);
    146146                        WriteData(fid,'object',obj,'class','mesh','fieldname','elementonsurface','format','BooleanMat','mattype',2);
    147                         WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbed','format','BooleanMat','mattype',1);
     147                        WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
    148148                        WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
    149149                        WriteData(fid,'object',obj,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2);

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

    r17562 r17610  
    2828                self.hemisphere                  = float('NaN');
    2929
    30                 self.elementonbed                = float('NaN');
     30                self.elementonbase                = float('NaN');
    3131                self.elementonsurface            = float('NaN');
    32                 self.vertexonbed                 = float('NaN');
     32                self.vertexonbase                 = float('NaN');
    3333                self.vertexonsurface             = float('NaN');
    3434                self.lowerelements               = float('NaN');
    … …  
    7575                string="%s%s"%(string,"\n\n      Properties:")
    7676                string="%s\n%s"%(string,fielddisplay(self,"numberoflayers","number of extrusion layers"))
    77                 string="%s\n%s"%(string,fielddisplay(self,"vertexonbed","lower vertices flags list"))
    78                 string="%s\n%s"%(string,fielddisplay(self,"elementonbed","lower elements flags list"))
     77                string="%s\n%s"%(string,fielddisplay(self,"vertexonbase","lower vertices flags list"))
     78                string="%s\n%s"%(string,fielddisplay(self,"elementonbase","lower elements flags list"))
    7979                string="%s\n%s"%(string,fielddisplay(self,"vertexonsurface","upper vertices flags list"))
    8080                string="%s\n%s"%(string,fielddisplay(self,"elementonsurface","upper elements flags list"))
    … …  
    122122                md = checkfield(md,'fieldname','mesh.numberofvertices','>',0)
    123123                #no checks for numberofedges lat long and hemisphere
    124                 md = checkfield(md,'fieldname','mesh.elementonbed','size',[md.mesh.numberofelements],'values',[0,1])
     124                md = checkfield(md,'fieldname','mesh.elementonbase','size',[md.mesh.numberofelements],'values',[0,1])
    125125                md = checkfield(md,'fieldname','mesh.elementonsurface','size',[md.mesh.numberofelements],'values',[0,1])
    126                 md = checkfield(md,'fieldname','mesh.vertexonbed','size',[md.mesh.numberofvertices],'values',[0,1])
     126                md = checkfield(md,'fieldname','mesh.vertexonbase','size',[md.mesh.numberofvertices],'values',[0,1])
    127127                md = checkfield(md,'fieldname','mesh.vertexonsurface','size',[md.mesh.numberofvertices],'values',[0,1])
    128128                md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',24,'message',"'mesh.average_vertex_connectivity' should be at least 24 in 3d")
    … …  
    142142                WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements','format','Integer')
    143143                WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices','format','Integer')
    144                 WriteData(fid,'object',self,'class','mesh','fieldname','elementonbed','format','BooleanMat','mattype',2)
     144                WriteData(fid,'object',self,'class','mesh','fieldname','elementonbase','format','BooleanMat','mattype',2)
    145145                WriteData(fid,'object',self,'class','mesh','fieldname','elementonsurface','format','BooleanMat','mattype',2)
    146                 WriteData(fid,'object',self,'class','mesh','fieldname','vertexonbed','format','BooleanMat','mattype',1)
     146                WriteData(fid,'object',self,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1)
    147147                WriteData(fid,'object',self,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1)
    148148                WriteData(fid,'object',self,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2)

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

    r17590 r17610  
    1818                hemisphere                  = NaN
    1919
    20                 vertexonbed                 = NaN
     20                vertexonbase                 = NaN
    2121                vertexonsurface             = NaN
    2222                lowerelements               = NaN
    … …  
    8181                        md = checkfield(md,'fieldname','mesh.numberofvertices','>',0);
    8282                        %no checks for numberofedges lat long and hemisphere
    83                         md = checkfield(md,'fieldname','mesh.vertexonbed','size',[md.mesh.numberofvertices 1],'values',[0 1]);
     83                        md = checkfield(md,'fieldname','mesh.vertexonbase','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    8484                        md = checkfield(md,'fieldname','mesh.vertexonsurface','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    8585                        md = checkfield(md,'fieldname','mesh.z','>=',md.geometry.base-10^-10,'message','''mesh.z'' lower than bedrock');
    … …  
    107107                        disp(sprintf('\n      Properties:'));
    108108                        fielddisplay(obj,'numberoflayers','number of extrusion layers');
    109                         fielddisplay(obj,'vertexonbed','lower vertices flags list');
     109                        fielddisplay(obj,'vertexonbase','lower vertices flags list');
    110110                        fielddisplay(obj,'vertexonsurface','upper vertices flags list');
    111111                        fielddisplay(obj,'uppervertex','upper vertex list (NaN for vertex on the upper surface)');
    … …  
    137137                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
    138138                        WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
    139                         WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbed','format','BooleanMat','mattype',1);
     139                        WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
    140140                        WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
    141141                        WriteData(fid,'object',obj,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2);

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

    r17590 r17610  
    721721
    722722                        %bedinfo and surface info
    723                         md.mesh.elementonbed=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',1);
     723                        md.mesh.elementonbase=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',1);
    724724                        md.mesh.elementonsurface=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',md.mesh.numberoflayers-1);
    725                         md.mesh.vertexonbed=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',1);
     725                        md.mesh.vertexonbase=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',1);
    726726                        md.mesh.vertexonsurface=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',md.mesh.numberoflayers);
    727727
    … …  
    841841                        if isfield(structmd,'uppergrids'), md.mesh.uppervertex=structmd.uppergrids; end
    842842                        if isfield(structmd,'lowergrids'), md.mesh.lowervertex=structmd.lowergrids; end
    843                         if isfield(structmd,'gridonbed'), md.mesh.vertexonbed=structmd.gridonbed; end
     843                        if isfield(structmd,'gridonbase'), md.mesh.vertexonbase=structmd.gridonbase; end
    844844                        if isfield(structmd,'gridonsurface'), md.mesh.vertexonsurface=structmd.gridonsurface; end
    845845                        if isfield(structmd,'extractedgrids'), md.mesh.extractedvertices=structmd.extractedgrids; end
    … …  
    951951                        if isfield(structmd,'upperelements'), md.mesh.upperelements=structmd.upperelements; end
    952952                        if isfield(structmd,'lowerelements'), md.mesh.lowerelements=structmd.lowerelements; end
    953                         if isfield(structmd,'elementonbed'), md.mesh.elementonbed=structmd.elementonbed; end
     953                        if isfield(structmd,'elementonbase'), md.mesh.elementonbase=structmd.elementonbase; end
    954954                        if isfield(structmd,'elementonsurface'), md.mesh.elementonsurface=structmd.elementonsurface; end
    955955                        if isfield(structmd,'nodeonsurface'), md.mesh.vertexonsurface=structmd.nodeonsurface; end
    956                         if isfield(structmd,'nodeonbed'), md.mesh.vertexonbed=structmd.nodeonbed; end
     956                        if isfield(structmd,'nodeonbase'), md.mesh.vertexonbase=structmd.nodeonbase; end
    957957                        if isfield(structmd,'elements2d'), md.mesh.elements2d=structmd.elements2d; end
    958958                        if isfield(structmd,'y2d'), md.mesh.y2d=structmd.y2d; end

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

    r17590 r17610  
    615615
    616616                #bedinfo and surface info
    617                 md.mesh.elementonbed=project3d(md,'vector',numpy.ones(md.mesh.numberofelements2d,bool),'type','element','layer',1)
     617                md.mesh.elementonbase=project3d(md,'vector',numpy.ones(md.mesh.numberofelements2d,bool),'type','element','layer',1)
    618618                md.mesh.elementonsurface=project3d(md,'vector',numpy.ones(md.mesh.numberofelements2d,bool),'type','element','layer',md.mesh.numberoflayers-1)
    619                 md.mesh.vertexonbed=project3d(md,'vector',numpy.ones(md.mesh.numberofvertices2d,bool),'type','node','layer',1)
     619                md.mesh.vertexonbase=project3d(md,'vector',numpy.ones(md.mesh.numberofvertices2d,bool),'type','node','layer',1)
    620620                md.mesh.vertexonsurface=project3d(md,'vector',numpy.ones(md.mesh.numberofvertices2d,bool),'type','node','layer',md.mesh.numberoflayers)
    621621

  • issm/trunk-jpl/src/m/classes/oldclasses/mesh.m

    r17558 r17610  
    1515                hemisphere                  = NaN
    1616
    17                 elementonbed                = NaN
     17                elementonbase                = NaN
    1818                elementonsurface            = NaN
    19                 vertexonbed                 = NaN
     19                vertexonbase                 = NaN
    2020                vertexonsurface             = NaN
    2121                lowerelements               = NaN

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

    r16764 r17610  
    113113                        %CHECK THAT NO rotation specified for FS Grounded ice at base
    114114                        if strcmp(meshtype(md.mesh),'3D') & md.flowequation.isFS,
    115                                 pos=find(md.mask.groundedice_levelset>0. & md.mesh.vertexonbed);
     115                                pos=find(md.mask.groundedice_levelset>0. & md.mesh.vertexonbase);
    116116                                if any(~isnan(md.stressbalance.referential(pos,:))),
    117117                                        md = checkmessage(md,['no referential should be specified for basal vertices of grounded ice']);

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

    r17480 r17610  
    162162                #CHECK THAT NO rotation specified for FS Grounded ice at base
    163163                if m.strcmp(md.mesh.meshtype(),'3D') and md.flowequation.isFS:
    164                         pos=numpy.nonzero(numpy.logical_and(md.mask.groundedice_levelset,md.mesh.vertexonbed))
     164                        pos=numpy.nonzero(numpy.logical_and(md.mask.groundedice_levelset,md.mesh.vertexonbase))
    165165                        if numpy.any(numpy.logical_not(numpy.isnan(md.stressbalance.referential[pos,:]))):
    166166                                md.checkmessage("no referential should be specified for basal vertices of grounded ice")

  • issm/trunk-jpl/src/m/consistency/checkfield.m

    r16820 r17610  
    2525%
    2626%   Example:
    27 %      md = checkfield(md,'mesh.elementonbed','size',[md.mesh.numberofelements 1],'values',[0 1]);
     27%      md = checkfield(md,'mesh.elementonbase','size',[md.mesh.numberofelements 1],'values',[0 1]);
    2828
    2929%get options

  • issm/trunk-jpl/src/m/consistency/checkfield.py

    r17480 r17610  
    3232
    3333           Example:
    34               md = checkfield(md,'mesh.elementonbed','size',[md.mesh.numberofelements 1],'values',[0 1]);
     34              md = checkfield(md,'mesh.elementonbase','size',[md.mesh.numberofelements 1],'values',[0 1]);
    3535        """
    3636

  • issm/trunk-jpl/src/m/contrib/bamg/yams.m

    r15749 r17610  
    106106%Fill in rest of fields:
    107107md.mesh.z=zeros(md.mesh.numberofvertices,1);
    108 md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     108md.mesh.vertexonbase=ones(md.mesh.numberofvertices,1);
    109109md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    110 md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     110md.mesh.elementonbase=ones(md.mesh.numberofelements,1);
    111111md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    112112if strcmpi(Names.interp,'node'),

  • issm/trunk-jpl/src/m/contrib/dassflow/importgmsh.m

    r16395 r17610  
    8585md.mesh.segmentmarkers=segmentmarkers;
    8686md.mesh.segments=segments;
    87 md.mesh.vertexonbed=zeros(md.mesh.numberofvertices,1);
    88 md.mesh.vertexonbed(find(vertexflags(md.mesh,1)))=1;
     87md.mesh.vertexonbase=zeros(md.mesh.numberofvertices,1);
     88md.mesh.vertexonbase(find(vertexflags(md.mesh,1)))=1;
    8989md.mesh.vertexonsurface=zeros(md.mesh.numberofvertices,1);
    9090md.mesh.vertexonsurface(find(vertexflags(md.mesh,3)))=1;

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

    r17572 r17610  
    195195def MaterialsMantleDensityEnum(): return StringToEnum("MaterialsMantleDensity")[0]
    196196def MeshAverageVertexConnectivityEnum(): return StringToEnum("MeshAverageVertexConnectivity")[0]
    197 def MeshElementonbedEnum(): return StringToEnum("MeshElementonbed")[0]
     197def MeshElementonbaseEnum(): return StringToEnum("MeshElementonbase")[0]
    198198def MeshElementonsurfaceEnum(): return StringToEnum("MeshElementonsurface")[0]
    199199def MeshElements2dEnum(): return StringToEnum("MeshElements2d")[0]
    … …  
    206206def MeshNumberofverticesEnum(): return StringToEnum("MeshNumberofvertices")[0]
    207207def MeshUpperelementsEnum(): return StringToEnum("MeshUpperelements")[0]
    208 def MeshVertexonbedEnum(): return StringToEnum("MeshVertexonbed")[0]
     208def MeshVertexonbaseEnum(): return StringToEnum("MeshVertexonbase")[0]
    209209def MeshVertexonsurfaceEnum(): return StringToEnum("MeshVertexonsurface")[0]
    210210def MeshXEnum(): return StringToEnum("MeshX")[0]

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

    r16395 r17610  
    3131
    3232%Deal with vertices on bed
    33 md.mesh.vertexonbed=zeros(md.mesh.numberofvertices,1);
    34 md.mesh.vertexonbed(find(vertexflags(md.mesh,1)))=1;
     33md.mesh.vertexonbase=zeros(md.mesh.numberofvertices,1);
     34md.mesh.vertexonbase(find(vertexflags(md.mesh,1)))=1;
    3535md.mesh.vertexonsurface=zeros(md.mesh.numberofvertices,1);
    3636md.mesh.vertexonsurface(find(vertexflags(md.mesh,3)))=1;

  • issm/trunk-jpl/test/NightlyRun/test1101.m

    r16506 r17610  
    2525        md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2626
    27         pos=find(md.mesh.vertexonbed);
     27        pos=find(md.mesh.vertexonbase);
    2828        md.stressbalance.spcvx(pos)=0.;
    2929        md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1101.py

    r15771 r17610  
    3939        md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    4040
    41         pos=numpy.nonzero(md.mesh.vertexonbed)
     41        pos=numpy.nonzero(md.mesh.vertexonbase)
    4242        md.stressbalance.spcvx[pos]=0.
    4343        md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1102.m

    r15771 r17610  
    2828
    2929        %Create dirichlet on the bed only
    30         pos=find(md.mesh.vertexonbed);
     30        pos=find(md.mesh.vertexonbase);
    3131        md.stressbalance.spcvx(pos)=0.;
    3232        md.stressbalance.spcvy(pos)=0.;
    … …  
    3636%       posx=find(md.mesh.x==0.);
    3737%       posx2=find(md.mesh.x==max(md.mesh.x));
    38 %       posx=find(md.mesh.x==0. & md.mesh.y~=0. & md.mesh.y~=max(md.mesh.y) & ~md.mesh.vertexonbed);
    39 %       posx2=find(md.mesh.x==max(md.mesh.x) &  md.mesh.y~=0. & md.mesh.y~=max(md.mesh.y) & ~md.mesh.vertexonbed);
     38%       posx=find(md.mesh.x==0. & md.mesh.y~=0. & md.mesh.y~=max(md.mesh.y) & ~md.mesh.vertexonbase);
     39%       posx2=find(md.mesh.x==max(md.mesh.x) &  md.mesh.y~=0. & md.mesh.y~=max(md.mesh.y) & ~md.mesh.vertexonbase);
    4040
    41 %       posy=find(md.mesh.y==0. & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x) & ~md.mesh.vertexonbed); %Don't take the same nodes two times
    42 %       posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x) & ~md.mesh.vertexonbed);
     41%       posy=find(md.mesh.y==0. & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x) & ~md.mesh.vertexonbase); %Don't take the same nodes two times
     42%       posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x) & ~md.mesh.vertexonbase);
    4343
    4444%       md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2];

  • issm/trunk-jpl/test/NightlyRun/test1102.py

    r15771 r17610  
    4242
    4343        #Create dirichlet on the bed only
    44         pos=numpy.nonzero(md.mesh.vertexonbed)
     44        pos=numpy.nonzero(md.mesh.vertexonbase)
    4545        md.stressbalance.spcvx[pos]=0.
    4646        md.stressbalance.spcvy[pos]=0.
    … …  
    5050#       posx=numpy.nonzero(md.mesh.x==0.)[0]
    5151#       posx2=numpy.nonzero(md.mesh.x==numpy.max(md.mesh.x))[0]
    52 #       posx=numpy.nonzero(logical_and_n(md.mesh.x==0.,md.mesh.y!=0.,md.mesh.y!=numpy.max(md.mesh.y),numpy.logical_not(md.mesh.vertexonbed)))[0]
    53 #       posx2=numpy.nonzero(logical_and_n(md.mesh.x==numpy.max(md.mesh.x),md.mesh.y!=0.,md.mesh.y!=numpy.max(md.mesh.y),numpy.logical_not(md.mesh.vertexonbed)))[0]
     52#       posx=numpy.nonzero(logical_and_n(md.mesh.x==0.,md.mesh.y!=0.,md.mesh.y!=numpy.max(md.mesh.y),numpy.logical_not(md.mesh.vertexonbase)))[0]
     53#       posx2=numpy.nonzero(logical_and_n(md.mesh.x==numpy.max(md.mesh.x),md.mesh.y!=0.,md.mesh.y!=numpy.max(md.mesh.y),numpy.logical_not(md.mesh.vertexonbase)))[0]
    5454
    55 #       posy=numpy.nonzero(logical_and_n(md.mesh.y==0.,md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x),numpy.logical_not(md.mesh.vertexonbed)))[0]    #Don't take the same nodes two times
    56 #       posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x),numpy.logical_not(md.mesh.vertexonbed)))[0]
     55#       posy=numpy.nonzero(logical_and_n(md.mesh.y==0.,md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x),numpy.logical_not(md.mesh.vertexonbase)))[0]    #Don't take the same nodes two times
     56#       posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x),numpy.logical_not(md.mesh.vertexonbase)))[0]
    5757
    5858#       md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1))))

  • issm/trunk-jpl/test/NightlyRun/test1103.m

    r15771 r17610  
    2424        md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    2525        md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    26         pos=find(md.mesh.vertexonbed);
     26        pos=find(md.mesh.vertexonbase);
    2727        md.stressbalance.spcvx(pos)=0.;
    2828        md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1103.py

    r15771 r17610  
    3838        md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    3939        md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    40         pos=numpy.nonzero(md.mesh.vertexonbed)
     40        pos=numpy.nonzero(md.mesh.vertexonbase)
    4141        md.stressbalance.spcvx[pos]=0.
    4242        md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1104.m

    r15771 r17610  
    2121        md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2222
    23         pos=find(md.mesh.vertexonbed);
     23        pos=find(md.mesh.vertexonbase);
    2424        md.stressbalance.spcvx(pos)=0.;
    2525        md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1104.py

    r15771 r17610  
    3333        md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    3434
    35         pos=numpy.nonzero(md.mesh.vertexonbed)
     35        pos=numpy.nonzero(md.mesh.vertexonbase)
    3636        md.stressbalance.spcvx[pos]=0.
    3737        md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1105.m

    r15803 r17610  
    3434
    3535        %Add spc on the corners
    36         pos=find((md.mesh.x==0. | md.mesh.x==L) & (md.mesh.y==0. | md.mesh.y==L) & md.mesh.vertexonbed);
     36        pos=find((md.mesh.x==0. | md.mesh.x==L) & (md.mesh.y==0. | md.mesh.y==L) & md.mesh.vertexonbase);
    3737        md.stressbalance.spcvx(pos)=0.;
    3838        md.stressbalance.spcvy(pos)=0.;
    … …  
    5858       
    5959        %Spc the bed at zero for vz
    60         pos=find(md.mesh.vertexonbed);
     60        pos=find(md.mesh.vertexonbase);
    6161        md.stressbalance.spcvz(pos)=0.;
    6262

  • issm/trunk-jpl/test/NightlyRun/test1105.py

    r15771 r17610  
    4848
    4949        #Add spc on the corners
    50         pos=numpy.nonzero(logical_and_n(numpy.logical_or(md.mesh.x==0.,md.mesh.x==L),numpy.logical_or(md.mesh.y==0.,md.mesh.y==L),md.mesh.vertexonbed))
     50        pos=numpy.nonzero(logical_and_n(numpy.logical_or(md.mesh.x==0.,md.mesh.x==L),numpy.logical_or(md.mesh.y==0.,md.mesh.y==L),md.mesh.vertexonbase))
    5151        md.stressbalance.spcvx[pos]=0.
    5252        md.stressbalance.spcvy[pos]=0.
    … …  
    7171       
    7272        #Spc the bed at zero for vz
    73         pos=numpy.nonzero(md.mesh.vertexonbed)
     73        pos=numpy.nonzero(md.mesh.vertexonbase)
    7474        md.stressbalance.spcvz[pos]=0.
    7575

  • issm/trunk-jpl/test/NightlyRun/test1107.m

    r15771 r17610  
    2626
    2727        %Create MPCs to have periodic boundary conditions
    28         posx=find(md.mesh.x==0. & ~(md.mesh.y==0. & md.mesh.vertexonbed) & ~(md.mesh.y==L & md.mesh.vertexonbed));
    29         posx2=find(md.mesh.x==max(md.mesh.x) & ~(md.mesh.y==0. & md.mesh.vertexonbed) & ~(md.mesh.y==L & md.mesh.vertexonbed));
     28        posx=find(md.mesh.x==0. & ~(md.mesh.y==0. & md.mesh.vertexonbase) & ~(md.mesh.y==L & md.mesh.vertexonbase));
     29        posx2=find(md.mesh.x==max(md.mesh.x) & ~(md.mesh.y==0. & md.mesh.vertexonbase) & ~(md.mesh.y==L & md.mesh.vertexonbase));
    3030
    3131        posy=find(md.mesh.y==0. & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x)); %Don't take the same nodes two times
    … …  
    3535
    3636        %Add spc on the corners
    37         pos=find((md.mesh.x==0. | md.mesh.x==L) & (md.mesh.y==0. | md.mesh.y==L) & md.mesh.vertexonbed);
     37        pos=find((md.mesh.x==0. | md.mesh.x==L) & (md.mesh.y==0. | md.mesh.y==L) & md.mesh.vertexonbase);
    3838        md.stressbalance.spcvy(:)=0.;
    3939        md.stressbalance.spcvx(pos)=0.;
    … …  
    5353       
    5454        %Spc the bed at zero for vz
    55         pos=find(md.mesh.vertexonbed);
     55        pos=find(md.mesh.vertexonbase);
    5656        md.stressbalance.spcvz(pos)=0.;
    5757

  • issm/trunk-jpl/test/NightlyRun/test1107.py

    r15771 r17610  
    4040
    4141        #Create MPCs to have periodic boundary conditions
    42 #       posx=find(md.mesh.x==0. & ~(md.mesh.y==0. & md.mesh.vertexonbed) & ~(md.mesh.y==L & md.mesh.vertexonbed));
    43         posx=numpy.nonzero(logical_and_n(md.mesh.x==0.,numpy.logical_not(numpy.logical_and(md.mesh.y==0.,md.mesh.vertexonbed)),numpy.logical_not(numpy.logical_and(md.mesh.y==L,md.mesh.vertexonbed))))[0]
    44 #       posx2=find(md.mesh.x==max(md.mesh.x) & ~(md.mesh.y==0. & md.mesh.vertexonbed) & ~(md.mesh.y==L & md.mesh.vertexonbed));
    45         posx2=numpy.nonzero(logical_and_n(md.mesh.x==numpy.max(md.mesh.x),numpy.logical_not(numpy.logical_and(md.mesh.y==0.,md.mesh.vertexonbed)),numpy.logical_not(numpy.logical_and(md.mesh.y==L,md.mesh.vertexonbed))))[0]
     42#       posx=find(md.mesh.x==0. & ~(md.mesh.y==0. & md.mesh.vertexonbase) & ~(md.mesh.y==L & md.mesh.vertexonbase));
     43        posx=numpy.nonzero(logical_and_n(md.mesh.x==0.,numpy.logical_not(numpy.logical_and(md.mesh.y==0.,md.mesh.vertexonbase)),numpy.logical_not(numpy.logical_and(md.mesh.y==L,md.mesh.vertexonbase))))[0]
     44#       posx2=find(md.mesh.x==max(md.mesh.x) & ~(md.mesh.y==0. & md.mesh.vertexonbase) & ~(md.mesh.y==L & md.mesh.vertexonbase));
     45        posx2=numpy.nonzero(logical_and_n(md.mesh.x==numpy.max(md.mesh.x),numpy.logical_not(numpy.logical_and(md.mesh.y==0.,md.mesh.vertexonbase)),numpy.logical_not(numpy.logical_and(md.mesh.y==L,md.mesh.vertexonbase))))[0]
    4646
    4747        posy=numpy.nonzero(logical_and_n(md.mesh.y==0.,md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x)))[0]    #Don't take the same nodes two times
    … …  
    5151
    5252        #Add spc on the corners
    53         pos=numpy.nonzero(logical_and_n(numpy.logical_or(md.mesh.x==0.,md.mesh.x==L),numpy.logical_or(md.mesh.y==0.,md.mesh.y==L),md.mesh.vertexonbed))
     53        pos=numpy.nonzero(logical_and_n(numpy.logical_or(md.mesh.x==0.,md.mesh.x==L),numpy.logical_or(md.mesh.y==0.,md.mesh.y==L),md.mesh.vertexonbase))
    5454        md.stressbalance.spcvy[:]=0.
    5555        md.stressbalance.spcvx[pos]=0.
    … …  
    6868       
    6969        #Spc the bed at zero for vz
    70         pos=numpy.nonzero(md.mesh.vertexonbed)
     70        pos=numpy.nonzero(md.mesh.vertexonbase)
    7171        md.stressbalance.spcvz[pos]=0.
    7272

  • issm/trunk-jpl/test/NightlyRun/test1108.m

    r17557 r17610  
    2222        md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2323       
    24         pos=find(md.mesh.vertexonbed & (md.mesh.x==0. | md.mesh.x==max(md.mesh.x)) & (md.mesh.y==0. | md.mesh.y==max(md.mesh.y)));
     24        pos=find(md.mesh.vertexonbase & (md.mesh.x==0. | md.mesh.x==max(md.mesh.x)) & (md.mesh.y==0. | md.mesh.y==max(md.mesh.y)));
    2525        md.stressbalance.spcvx(pos)=0.;
    2626        md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1108.py

    r15771 r17610  
    3434        md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    3535       
    36         pos=numpy.nonzero(logical_and_n(md.mesh.vertexonbed,numpy.logical_or(md.mesh.x==0.,md.mesh.x==numpy.max(md.mesh.x)),numpy.logical_or(md.mesh.y==0.,md.mesh.y==numpy.max(md.mesh.y))))
     36        pos=numpy.nonzero(logical_and_n(md.mesh.vertexonbase,numpy.logical_or(md.mesh.x==0.,md.mesh.x==numpy.max(md.mesh.x)),numpy.logical_or(md.mesh.y==0.,md.mesh.y==numpy.max(md.mesh.y))))
    3737        md.stressbalance.spcvx[pos]=0.
    3838        md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1109.m

    r15771 r17610  
    3131
    3232        %Create spcs on the bed
    33         pos=find(md.mesh.vertexonbed);
     33        pos=find(md.mesh.vertexonbase);
    3434        md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    3535        md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);

  • issm/trunk-jpl/test/NightlyRun/test1110.m

    r16608 r17610  
    2626        if (i==1 | i==3),
    2727                %Create dirichlet on the bed if no slip
    28                 pos=find(md.mesh.vertexonbed);
     28                pos=find(md.mesh.vertexonbase);
    2929                md.stressbalance.spcvx(pos)=0.;
    3030                md.stressbalance.spcvy(pos)=0.;
    3131                md.stressbalance.spcvz(pos)=0.;
    3232        else
    33                 pos=find(md.mesh.vertexonbed & (md.mesh.x==0. | md.mesh.x==max(md.mesh.x)) & (md.mesh.y==0. | md.mesh.y==max(md.mesh.y)));
     33                pos=find(md.mesh.vertexonbase & (md.mesh.x==0. | md.mesh.x==max(md.mesh.x)) & (md.mesh.y==0. | md.mesh.y==max(md.mesh.y)));
    3434                md.stressbalance.spcvx(pos)=100.; %because we need a dirichlet somewhere
    3535                md.stressbalance.spcvy(pos)=0.;
    3636                md.stressbalance.spcvz(pos)=0.;
    3737        end
    38         pos=find(~md.mesh.vertexonbed);
     38        pos=find(~md.mesh.vertexonbase);
    3939        md.thermal.spctemperature(pos)=255.;
    4040

  • issm/trunk-jpl/test/NightlyRun/test1205.m

    r15771 r17610  
    2222
    2323%Spc the nodes on the bed
    24 pos=find(md.mesh.vertexonbed);
     24pos=find(md.mesh.vertexonbase);
    2525md.stressbalance.spcvx(pos)=0.;
    2626md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1205.py

    r15771 r17610  
    3535
    3636#Spc the nodes on the bed
    37 pos=numpy.nonzero(md.mesh.vertexonbed)
     37pos=numpy.nonzero(md.mesh.vertexonbase)
    3838md.stressbalance.spcvx[pos]=0.
    3939md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1206.m

    r15771 r17610  
    2222
    2323%Spc the nodes on the bed
    24 pos=find(md.mesh.vertexonbed);
     24pos=find(md.mesh.vertexonbase);
    2525md.stressbalance.spcvx(pos)=0.;
    2626md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1206.py

    r15771 r17610  
    3535
    3636#Spc the nodes on the bed
    37 pos=numpy.nonzero(md.mesh.vertexonbed)
     37pos=numpy.nonzero(md.mesh.vertexonbase)
    3838md.stressbalance.spcvx[pos]=0.
    3939md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1207.m

    r15771 r17610  
    2222
    2323%Spc the nodes on the bed
    24 pos=find(md.mesh.vertexonbed);
     24pos=find(md.mesh.vertexonbase);
    2525md.stressbalance.spcvx(pos)=0.;
    2626md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1207.py

    r15771 r17610  
    3535
    3636#Spc the nodes on the bed
    37 pos=numpy.nonzero(md.mesh.vertexonbed)
     37pos=numpy.nonzero(md.mesh.vertexonbase)
    3838md.stressbalance.spcvx[pos]=0.
    3939md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1208.m

    r17555 r17610  
    1313
    1414%Spc the nodes on the bed
    15 pos=find(md.mesh.vertexonbed);
     15pos=find(md.mesh.vertexonbase);
    1616md.stressbalance.spcvx(pos)=0.;
    1717md.stressbalance.spcvy(pos)=0.;

  • issm/trunk-jpl/test/NightlyRun/test1208.py

    r17555 r17610  
    2626
    2727#Spc the nodes on the bed
    28 pos=numpy.nonzero(md.mesh.vertexonbed)
     28pos=numpy.nonzero(md.mesh.vertexonbase)
    2929md.stressbalance.spcvx[pos]=0.
    3030md.stressbalance.spcvy[pos]=0.

  • issm/trunk-jpl/test/NightlyRun/test1302.m

    r15565 r17610  
    1212
    1313%Thermal boundary conditions
    14 pos1=find(md.mesh.elementonbed);     md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10.;
     14pos1=find(md.mesh.elementonbase);     md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10.;
    1515pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0.;
    1616md.initialization.vz=0.1*ones(md.mesh.numberofvertices,1);

  • issm/trunk-jpl/test/NightlyRun/test1302.py

    r15565 r17610  
    2626
    2727#Thermal boundary conditions
    28 pos1=numpy.nonzero(md.mesh.elementonbed)[0]
     28pos1=numpy.nonzero(md.mesh.elementonbase)[0]
    2929md.thermal.spctemperature[md.mesh.elements[pos1,0:3]-1]=10.
    3030pos2=numpy.nonzero(md.mesh.elementonsurface)[0]

  • issm/trunk-jpl/test/NightlyRun/test1303.m

    r15565 r17610  
    1212md=setflowequation(md,'HO','all');
    1313
    14 pos1=find(md.mesh.elementonbed);     md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10.;
     14pos1=find(md.mesh.elementonbase);     md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10.;
    1515pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0.;
    1616md.initialization.pressure=zeros(md.mesh.numberofvertices,1);

  • issm/trunk-jpl/test/NightlyRun/test1303.py

    r15565 r17610  
    2626md=setflowequation(md,'HO','all')
    2727
    28 pos1=numpy.nonzero(md.mesh.elementonbed)[0]
     28pos1=numpy.nonzero(md.mesh.elementonbase)[0]
    2929md.thermal.spctemperature[md.mesh.elements[pos1,0:3]-1]=10.
    3030pos2=numpy.nonzero(md.mesh.elementonsurface)[0]

  • issm/trunk-jpl/test/NightlyRun/test703.m

    r17590 r17610  
    4747md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
    4848md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);
    49 posb=find((md.mesh.x>0) & md.mesh.vertexonbed);
     49posb=find((md.mesh.x>0) & md.mesh.vertexonbase);
    5050md.basalforcings.melting_rate(posb)=18;
    5151md.initialization.vx=zeros(md.mesh.numberofvertices,1);
Note: See TracChangeset for help on using the changeset viewer.