Changeset 9729


Ignore:
Timestamp:
09/09/11 14:01:36 (14 years ago)
Author:
seroussi
Message:

added mode fields in mesh

Location:
issm/trunk
Files:
4 added
4 deleted
76 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h

    r9728 r9729  
    158158        MeshLowerelementsEnum,
    159159        MeshUpperelementsEnum,
     160        MeshElementonbedEnum,
     161        MeshElementonsurfaceEnum,
     162        MeshVertexonbedEnum,
     163        MeshVertexonsurfaceEnum,
    160164        /*}}}*/
    161165        /*Datasets {{{1*/
    … …  
    308312        ConstantEnum,
    309313        ConvergedEnum,
    310         ElementonbedEnum,
    311         ElementonsurfaceEnum,
    312314        FillEnum,
    313315        FractionIncrementEnum,
    … …  
    327329        GroundinglineMeltingRateEnum,
    328330        MisfitEnum,
    329         NodeonbedEnum,
    330         NodeonsurfaceEnum,
    331331        NumberNodeToElementConnectivityEnum,
    332332        PressureEnum,

  • issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.cpp

    r9728 r9729  
    162162                case MeshLowerelementsEnum : return "MeshLowerelements";
    163163                case MeshUpperelementsEnum : return "MeshUpperelements";
     164                case MeshElementonbedEnum : return "MeshElementonbed";
     165                case MeshElementonsurfaceEnum : return "MeshElementonsurface";
     166                case MeshVertexonbedEnum : return "MeshVertexonbed";
     167                case MeshVertexonsurfaceEnum : return "MeshVertexonsurface";
    164168                case ConstraintsEnum : return "Constraints";
    165169                case ElementsEnum : return "Elements";
    … …  
    275279                case ConstantEnum : return "Constant";
    276280                case ConvergedEnum : return "Converged";
    277                 case ElementonbedEnum : return "Elementonbed";
    278                 case ElementonsurfaceEnum : return "Elementonsurface";
    279281                case FillEnum : return "Fill";
    280282                case FractionIncrementEnum : return "FractionIncrement";
    … …  
    294296                case GroundinglineMeltingRateEnum : return "GroundinglineMeltingRate";
    295297                case MisfitEnum : return "Misfit";
    296                 case NodeonbedEnum : return "Nodeonbed";
    297                 case NodeonsurfaceEnum : return "Nodeonsurface";
    298298                case NumberNodeToElementConnectivityEnum : return "NumberNodeToElementConnectivity";
    299299                case PressureEnum : return "Pressure";

  • issm/trunk/src/c/modules/ModelProcessorx/Balancethickness/CreateNodesBalancethickness.cpp

    r9725 r9729  
    4949
    5050        /*First fetch data: */
    51         iomodel->FetchData(7,ElementsEnum,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     51        iomodel->FetchData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5252
    5353        if(continuous_galerkin){
    … …  
    8888
    8989        /*Clean fetched data: */
    90         iomodel->DeleteData(7,ElementsEnum,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     90        iomodel->DeleteData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    9191
    9292        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Balancethickness/UpdateElementsBalancethickness.cpp

    r9725 r9729  
    4848
    4949        if (dim==3){
    50                 iomodel->FetchDataToInput(elements,ElementonbedEnum);
    51                 iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     50                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     51                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    5252        }
    5353        /*Free data: */

  • issm/trunk/src/c/modules/ModelProcessorx/BedSlope/CreateNodesBedSlope.cpp

    r9725 r9729  
    3636       
    3737        /*First fetch data: */
    38         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3939
    4040        for (i=0;i<numberofvertices;i++){
    … …  
    4848
    4949        /*Clean fetched data: */
    50         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     50        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5151       
    5252        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/BedSlope/UpdateElementsBedSlope.cpp

    r9725 r9729  
    3939
    4040        if (dim==3){
    41                 iomodel->FetchDataToInput(elements,ElementonbedEnum);
    42                 iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     41                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     42                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4343        }
    4444       

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp

    r9725 r9729  
    124124
    125125        /*create penalties for nodes on the base of icesheet. We must have wb=ub*db/dx+vb*db/dy */
    126         iomodel->FetchData(&nodeonbed,NULL,NULL,NodeonbedEnum);
     126        iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    127127        iomodel->FetchData(&nodeonicesheet,NULL,NULL,MaskVertexongroundediceEnum);
    128128        iomodel->FetchData(&nodeonstokes,NULL,NULL,FlowequationBorderstokesEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateNodesDiagnosticHoriz.cpp

    r9725 r9729  
    4545
    4646        /*Create nodes: */
    47         iomodel->FetchData(9,NodeonbedEnum,NodeonsurfaceEnum,FlowequationBordermacayealEnum,FlowequationBorderstokesEnum,
     47        iomodel->FetchData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBordermacayealEnum,FlowequationBorderstokesEnum,
    4848                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    4949       
    … …  
    5858
    5959        /*Clean fetched data: */
    60         iomodel->DeleteData(9,NodeonbedEnum,NodeonsurfaceEnum,FlowequationBordermacayealEnum,FlowequationBorderstokesEnum,
     60        iomodel->DeleteData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBordermacayealEnum,FlowequationBorderstokesEnum,
    6161                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    6262

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/UpdateElementsDiagnosticHoriz.cpp

    r9725 r9729  
    6464
    6565        if (dim==3){
    66                 iomodel->FetchDataToInput(elements,ElementonbedEnum);
    67                 iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     66                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     67                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    6868                iomodel->FetchDataToInput(elements,VzEnum);
    6969                iomodel->FetchDataToInput(elements,SurfaceforcingsAccumulationRateEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateNodesDiagnosticHutter.cpp

    r9725 r9729  
    4444
    4545        /*First fetch data: */
    46         iomodel->FetchData(7,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,ElementsEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     46        iomodel->FetchData(7,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,ElementsEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4747        CreateNumberNodeToElementConnectivity(iomodel);
    4848
    … …  
    5757
    5858        /*Clean fetched data: */
    59         iomodel->DeleteData(7,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,ElementsEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     59        iomodel->DeleteData(7,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,ElementsEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    6060
    6161        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/CreateNodesDiagnosticVert.cpp

    r9725 r9729  
    4444       
    4545        /*First fetch data: */
    46         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     46        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4747
    4848        for (i=0;i<numberofvertices;i++){
    … …  
    5656
    5757        /*Clean fetched data: */
    58         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     58        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5959       
    6060        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/UpdateElementsDiagnosticVert.cpp

    r9725 r9729  
    4444        iomodel->FetchDataToInput(elements,BedEnum);
    4545        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    46         iomodel->FetchDataToInput(elements,ElementonbedEnum);
    47         iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     46        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     47        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4848        iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    4949        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Enthalpy/CreateNodesEnthalpy.cpp

    r9725 r9729  
    3636
    3737        /*Create nodes and vertices: */
    38         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3939
    4040        for (i=0;i<numberofvertices;i++){
    … …  
    4848
    4949        /*Clean fetched data: */
    50         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     50        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5151       
    5252        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Enthalpy/UpdateElementsEnthalpy.cpp

    r9725 r9729  
    4646        iomodel->FetchDataToInput(elements,FrictionQEnum);
    4747        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    48         iomodel->FetchDataToInput(elements,ElementonbedEnum);
    49         iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     48        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     49        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    5050        iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    5151        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Hydrology/CreateNodesHydrology.cpp

    r9725 r9729  
    3636
    3737        /*Create nodes and vertices: */
    38         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3939        for (i=0;i<numberofvertices;i++){
    4040
    … …  
    4545                }
    4646        }
    47         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     47        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4848       
    4949        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Hydrology/UpdateElementsHydrology.cpp

    r9725 r9729  
    3939        iomodel->FetchDataToInput(elements,FrictionQEnum);
    4040        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    41         iomodel->FetchDataToInput(elements,ElementonbedEnum);
    42         iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     41        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     42        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4343        iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    4444        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateLoadsMelting.cpp

    r9725 r9729  
    3535
    3636        //create penalties for nodes: no node can have a temperature over the melting point
    37         iomodel->FetchData(2,NodeonbedEnum,ElementsEnum);
     37        iomodel->FetchData(2,MeshVertexonbedEnum,ElementsEnum);
    3838        CreateSingleNodeToElementConnectivity(iomodel);
    3939
    4040        for (i=0;i<numberofvertices;i++){
    4141                if((iomodel->my_vertices[i]==1)){
    42                         if (iomodel->Data(NodeonbedEnum)[i]){
     42                        if (iomodel->Data(MeshVertexonbedEnum)[i]){
    4343                                loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,MeltingAnalysisEnum));
    4444                        }
    4545                }
    4646        }
    47         iomodel->DeleteData(2,NodeonbedEnum,ElementsEnum);
     47        iomodel->DeleteData(2,MeshVertexonbedEnum,ElementsEnum);
    4848
    4949        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateNodesMelting.cpp

    r9725 r9729  
    3636
    3737        /*First fetch data: */
    38         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3939        for (i=0;i<numberofvertices;i++){
    4040
    … …  
    4646                }
    4747        }
    48         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     48        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4949
    5050        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/UpdateElementsMelting.cpp

    r9725 r9729  
    4747        iomodel->FetchDataToInput(elements,FrictionQEnum);
    4848        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    49         iomodel->FetchDataToInput(elements,ElementonbedEnum);
    50         iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     49        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     50        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    5151        iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    5252        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp

    r9725 r9729  
    6464        double *nodeonbed=NULL;
    6565        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,PrognosticVertexPairingEnum);
    66         iomodel->FetchData(&nodeonbed,NULL,NULL,NodeonbedEnum);
     66        iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    6767
    6868        for(i=0;i<numvertex_pairing;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp

    r9725 r9729  
    4949
    5050        /*First fetch data: */
    51         iomodel->FetchData(7,ElementsEnum,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     51        iomodel->FetchData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5252        if(continuous_galerkin){
    5353
    … …  
    8888
    8989        /*Clean fetched data: */
    90         iomodel->DeleteData(7,ElementsEnum,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     90        iomodel->DeleteData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    9191
    9292        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/UpdateElementsPrognostic.cpp

    r9725 r9729  
    5454       
    5555        if (dim==3){
    56                 iomodel->FetchDataToInput(elements,ElementonbedEnum);
    57                 iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     56                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     57                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    5858                iomodel->FetchDataToInput(elements,PressureEnum);
    5959                iomodel->FetchDataToInput(elements,TemperatureEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/SurfaceSlope/CreateNodesSurfaceSlope.cpp

    r9725 r9729  
    3636       
    3737        /*First fetch data: */
    38         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3939
    4040        for (i=0;i<numberofvertices;i++){
    … …  
    4949
    5050        /*Clean fetched data: */
    51         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     51        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5252       
    5353        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/SurfaceSlope/UpdateElementsSurfaceSlope.cpp

    r9725 r9729  
    3939       
    4040        if (dim==3){
    41                 iomodel->FetchDataToInput(elements,ElementonbedEnum);
    42                 iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     41                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     42                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4343        }
    4444       

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateNodesThermal.cpp

    r9725 r9729  
    3636
    3737        /*Create nodes and vertices: */
    38         iomodel->FetchData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3939
    4040        for (i=0;i<numberofvertices;i++){
    … …  
    4848
    4949        /*Clean fetched data: */
    50         iomodel->DeleteData(6,NodeonbedEnum,NodeonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     50        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5151       
    5252        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/UpdateElementsThermal.cpp

    r9725 r9729  
    4848        iomodel->FetchDataToInput(elements,FrictionQEnum);
    4949        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    50         iomodel->FetchDataToInput(elements,ElementonbedEnum);
    51         iomodel->FetchDataToInput(elements,ElementonsurfaceEnum);
     50        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
     51        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    5252        iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    5353        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);

  • issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.cpp

    r9728 r9729  
    160160        else if (strcmp(name,"MeshLowerelements")==0) return MeshLowerelementsEnum;
    161161        else if (strcmp(name,"MeshUpperelements")==0) return MeshUpperelementsEnum;
     162        else if (strcmp(name,"MeshElementonbed")==0) return MeshElementonbedEnum;
     163        else if (strcmp(name,"MeshElementonsurface")==0) return MeshElementonsurfaceEnum;
     164        else if (strcmp(name,"MeshVertexonbed")==0) return MeshVertexonbedEnum;
     165        else if (strcmp(name,"MeshVertexonsurface")==0) return MeshVertexonsurfaceEnum;
    162166        else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    163167        else if (strcmp(name,"Elements")==0) return ElementsEnum;
    … …  
    273277        else if (strcmp(name,"Constant")==0) return ConstantEnum;
    274278        else if (strcmp(name,"Converged")==0) return ConvergedEnum;
    275         else if (strcmp(name,"Elementonbed")==0) return ElementonbedEnum;
    276         else if (strcmp(name,"Elementonsurface")==0) return ElementonsurfaceEnum;
    277279        else if (strcmp(name,"Fill")==0) return FillEnum;
    278280        else if (strcmp(name,"FractionIncrement")==0) return FractionIncrementEnum;
    … …  
    292294        else if (strcmp(name,"GroundinglineMeltingRate")==0) return GroundinglineMeltingRateEnum;
    293295        else if (strcmp(name,"Misfit")==0) return MisfitEnum;
    294         else if (strcmp(name,"Nodeonbed")==0) return NodeonbedEnum;
    295         else if (strcmp(name,"Nodeonsurface")==0) return NodeonsurfaceEnum;
    296296        else if (strcmp(name,"NumberNodeToElementConnectivity")==0) return NumberNodeToElementConnectivityEnum;
    297297        else if (strcmp(name,"Pressure")==0) return PressureEnum;

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r9728 r9729  
    65756575
    65766576        bool onbed;
    6577         inputs->GetParameterValue(&onbed,ElementonbedEnum);
     6577        inputs->GetParameterValue(&onbed,MeshElementonbedEnum);
    65786578        return onbed;
    65796579}
    … …  
    66516651
    66526652        bool onsurface;
    6653         inputs->GetParameterValue(&onsurface,ElementonsurfaceEnum);
     6653        inputs->GetParameterValue(&onsurface,MeshElementonsurfaceEnum);
    66546654        return onsurface;
    66556655}

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r9728 r9729  
    40014001       
    40024002        bool onbed;
    4003         inputs->GetParameterValue(&onbed,ElementonbedEnum);
     4003        inputs->GetParameterValue(&onbed,MeshElementonbedEnum);
    40044004        return onbed;
    40054005}

  • issm/trunk/src/c/objects/Node.cpp

    r9719 r9729  
    5454        //intialize inputs, and add as many inputs per element as requested:
    5555        this->inputs=new Inputs();
    56         if (iomodel->Data(NodeonbedEnum))      this->inputs->AddInput(new BoolInput(NodeonbedEnum,(IssmBool)iomodel->Data(NodeonbedEnum)[io_index]));
    57         if (iomodel->Data(NodeonsurfaceEnum))  this->inputs->AddInput(new BoolInput(NodeonsurfaceEnum,(IssmBool)iomodel->Data(NodeonsurfaceEnum)[io_index]));
     56        if (iomodel->Data(MeshVertexonbedEnum))      this->inputs->AddInput(new BoolInput(MeshVertexonbedEnum,(IssmBool)iomodel->Data(MeshVertexonbedEnum)[io_index]));
     57        if (iomodel->Data(MeshVertexonsurfaceEnum))  this->inputs->AddInput(new BoolInput(MeshVertexonsurfaceEnum,(IssmBool)iomodel->Data(MeshVertexonsurfaceEnum)[io_index]));
    5858        if (iomodel->Data(MaskVertexonfloatingiceEnum)) this->inputs->AddInput(new BoolInput(MaskVertexonfloatingiceEnum,(IssmBool)iomodel->Data(MaskVertexonfloatingiceEnum)[io_index]));
    5959        if (iomodel->Data(MaskVertexongroundediceEnum)) this->inputs->AddInput(new BoolInput(MaskVertexongroundediceEnum,(IssmBool)iomodel->Data(MaskVertexongroundediceEnum)[io_index]));
    … …  
    7575                if (dim==3){
    7676                        /*We have a  3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    77                         if (!iomodel->Data(NodeonbedEnum)) _error_("iomodel->nodeonbed is NULL");
     77                        if (!iomodel->Data(MeshVertexonbedEnum)) _error_("iomodel->nodeonbed is NULL");
    7878                        if (!iomodel->Data(FlowequationVertexEquationEnum)) _error_("iomodel->vertices_type is NULL");
    79                         if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealApproximationEnum && !iomodel->Data(NodeonbedEnum)[io_index]){
     79                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealApproximationEnum && !iomodel->Data(MeshVertexonbedEnum)[io_index]){
    8080                                for(k=1;k<=gsize;k++) this->FreezeDof(k);
    8181                        }
    8282                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealPattynApproximationEnum && iomodel->Data(FlowequationBordermacayealEnum)[io_index]){
    83                                 if(!iomodel->Data(NodeonbedEnum)[io_index]){
     83                                if(!iomodel->Data(MeshVertexonbedEnum)[io_index]){
    8484                                        for(k=1;k<=gsize;k++) this->FreezeDof(k);
    8585                                }
    8686                        }
    8787                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealStokesApproximationEnum && iomodel->Data(FlowequationBordermacayealEnum)[io_index]){
    88                                 if(!iomodel->Data(NodeonbedEnum)[io_index]){
     88                                if(!iomodel->Data(MeshVertexonbedEnum)[io_index]){
    8989                                        for(k=1;k<=2;k++) this->FreezeDof(k);
    9090                                }
    … …  
    121121                if (dim==3){
    122122                        /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    123                         _assert_(iomodel->Data(NodeonbedEnum));
    124                         if (!iomodel->Data(NodeonbedEnum)[io_index]){
     123                        _assert_(iomodel->Data(MeshVertexonbedEnum));
     124                        if (!iomodel->Data(MeshVertexonbedEnum)[io_index]){
    125125                                for(k=1;k<=gsize;k++){
    126126                                        this->FreezeDof(k);
    … …  
    738738
    739739        /*recover parameters: */
    740         inputs->GetParameterValue(&onbed,NodeonbedEnum);
     740        inputs->GetParameterValue(&onbed,MeshVertexonbedEnum);
    741741
    742742        return onbed;
    … …  
    771771
    772772        /*recover parameters: */
    773         inputs->GetParameterValue(&onsurface,NodeonsurfaceEnum);
     773        inputs->GetParameterValue(&onsurface,MeshVertexonsurfaceEnum);
    774774
    775775        return onsurface;

  • issm/trunk/src/m/classes/mesh.m

    r9728 r9729  
    2222                numberofvertices2d    = modelfield('default',0,'marshall',true,'format','Integer');
    2323                numberofelements2d = modelfield('default',0,'marshall',true,'format','Integer');
    24                 nodeconnectivity    = modelfield('default',NaN,'marshall',false);
     24                vertexconnectivity    = modelfield('default',NaN,'marshall',false);
    2525                elementconnectivity = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    26                 uppernodes           = modelfield('default',NaN,'marshall',false);
     26                uppervertex           = modelfield('default',NaN,'marshall',false);
    2727                upperelements        = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    2828                lowerelements        = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    29                 lowernodes           = modelfield('default',NaN,'marshall',false);
     29                lowervertex           = modelfield('default',NaN,'marshall',false);
     30                elementonbed      = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
     31                elementonsurface  = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
     32                vertexonbed         = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',1);
     33                vertexonsurface     = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',1);
    3034        end
    3135        methods

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

    r9728 r9729  
    5252                 y2d                = modelfield('default',NaN,'marshall',false);
    5353
    54                  elementonbed      = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    55                  elementonsurface  = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    56                  nodeonbed         = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',1);
    57                  nodeonsurface     = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',1);
    5854                 %}}}
    5955         end
    … …  
    311307                         if isfield(structmd,'numberofelements2d'), md.mesh.numberofelements2d=structmd.numberofelements2d; end
    312308                         if isfield(structmd,'numberofnodes2d'), md.mesh.numberofvertices2d=structmd.numberofnodes2d; end
    313                          if isfield(structmd,'nodeconnectivity'), md.mesh.nodeconnectivityension=structmd.nodeconnectivity; end
    314                          if isfield(structmd,'elementconnectivity'), md.mesh.elementconnectivityension=structmd.elementconnectivity; end
    315                          if isfield(structmd,'uppernodes'), md.mesh.uppernodesension=structmd.uppernodes; end
    316                          if isfield(structmd,'lowernodes'), md.mesh.lowernodesension=structmd.lowernodes; end
    317                          if isfield(structmd,'upperelements'), md.mesh.upperelementsension=structmd.upperelements; end
    318                          if isfield(structmd,'lowerelements'), md.mesh.lowerelementsension=structmd.lowerelements; end
     309                         if isfield(structmd,'nodeconnectivity'), md.mesh.vertexconnectivity=structmd.nodeconnectivity; end
     310                         if isfield(structmd,'elementconnectivity'), md.mesh.elementconnectivity=structmd.elementconnectivity; end
     311                         if isfield(structmd,'uppernodes'), md.mesh.uppervertex=structmd.uppernodes; end
     312                         if isfield(structmd,'lowernodes'), md.mesh.lowervertex=structmd.lowernodes; end
     313                         if isfield(structmd,'upperelements'), md.mesh.upperelements=structmd.upperelements; end
     314                         if isfield(structmd,'lowerelements'), md.mesh.lowerelements=structmd.lowerelements; end
     315                         if isfield(structmd,'elementonbed'), md.mesh.elementonbed=structmd.elementonbed; end
     316                         if isfield(structmd,'elementonsurface'), md.mesh.elementonsurface=structmd.elementonsurface; end
     317                         if isfield(structmd,'nodeonsurface'), md.mesh.vertexonsurface=structmd.nodeonsurface; end
     318                         if isfield(structmd,'nodeonbed'), md.mesh.vertexonbed=structmd.nodeonbed; end
    319319
    320320                         %Field changes

  • issm/trunk/src/m/model/bamg.m

    r9728 r9729  
    329329md.mesh.numberofvertices=length(md.x);
    330330md.z=zeros(md.mesh.numberofvertices,1);
    331 md.nodeonbed=ones(md.mesh.numberofvertices,1);
     331md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    332332md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    333 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    334 md.elementonbed=ones(md.mesh.numberofelements,1);
    335 md.elementonsurface=ones(md.mesh.numberofelements,1);
     333md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     334md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     335md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    336336md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    337337md.mesh.elementconnectivity=md.private.bamg.mesh.ElementConnectivity;

  • issm/trunk/src/m/model/collapse.m

    r9728 r9729  
    4141
    4242%bedinfo and surface info
    43 md.elementonbed=ones(md.mesh.numberofelements2d,1);
    44 md.elementonsurface=ones(md.mesh.numberofelements2d,1);
    45 md.nodeonbed=ones(md.mesh.numberofvertices2d,1);
    46 md.nodeonsurface=ones(md.mesh.numberofvertices2d,1);
     43md.mesh.elementonbed=ones(md.mesh.numberofelements2d,1);
     44md.mesh.elementonsurface=ones(md.mesh.numberofelements2d,1);
     45md.mesh.vertexonbed=ones(md.mesh.numberofvertices2d,1);
     46md.mesh.vertexonsurface=ones(md.mesh.numberofvertices2d,1);
    4747
    4848%elementstype
    … …  
    9898
    9999%Keep a trace of lower and upper nodes
    100 md.mesh.lowernodes=NaN;
    101 md.mesh.uppernodes=NaN;
     100md.mesh.lowervertex=NaN;
     101md.mesh.uppervertex=NaN;
    102102
    103103%Remove old mesh

  • issm/trunk/src/m/model/contourenvelope.m

    r9728 r9729  
    3535%Now, build the connectivity tables for this mesh.
    3636%Computing connectivity
    37 if size(md.mesh.nodeconnectivity,1)~=md.mesh.numberofvertices,
    38         md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     37if size(md.mesh.vertexconnectivity,1)~=md.mesh.numberofvertices,
     38        md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    3939end
    4040if size(md.mesh.elementconnectivity,1)~=md.mesh.numberofelements,
    41         md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     41        md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    4242end
    4343

  • issm/trunk/src/m/model/display/displaymesh.m

    r9719 r9729  
    3838fielddisplay(md,'bamg','Geometry and 2d mesh properties (if generated by Bamg)');
    3939fielddisplay(md,'penalties','penalties list');
    40 fielddisplay(md,'nodeonbed','lower nodes flags list');
    41 fielddisplay(md,'elementonbed','lower elements flags list');
    42 fielddisplay(md,'nodeonsurface','upper nodes flags list');
    43 fielddisplay(md,'elementonsurface','upper elements flags list');
     40fielddisplay(md,'mesh.vertexonbed','lower nodes flags list');
     41fielddisplay(md,'mesh.elementonbed','lower elements flags list');
     42fielddisplay(md,'mesh.vertexonsurface','upper nodes flags list');
     43fielddisplay(md,'mesh.elementonsurface','upper elements flags list');

  • issm/trunk/src/m/model/display/displayparameters.m

    r9610 r9729  
    1717fielddisplay(md,'bathymetry','bathymetry elevation (with respect to sea level) [m]');
    1818fielddisplay(md,'firn_layer','firn layer height [m]');
    19 fielddisplay(md,'elementonbed','element on bed flags list');
    20 fielddisplay(md,'elementonsurface','element on surface flags list');
    21 fielddisplay(md,'nodeonbed','node on bed flags list');
    22 fielddisplay(md,'nodeonsurface','node on surface flags list');
     19fielddisplay(md,'mesh.elementonbed','element on bed flags list');
     20fielddisplay(md,'mesh.elementonsurface','element on surface flags list');
     21fielddisplay(md,'mesh.vertexonbed','node on bed flags list');
     22fielddisplay(md,'mesh.vertexonsurface','node on surface flags list');
    2323
    2424disp(sprintf('\n      physical parameters:'));

  • issm/trunk/src/m/model/extrude.m

    r9728 r9729  
    8787
    8888%Keep a trace of lower and upper nodes
    89 mesh.lowernodes=NaN*ones(number_nodes3d,1);
    90 mesh.uppernodes=NaN*ones(number_nodes3d,1);
    91 mesh.lowernodes(md.mesh.numberofvertices+1:end)=1:(numlayers-1)*md.mesh.numberofvertices;
    92 mesh.uppernodes(1:(numlayers-1)*md.mesh.numberofvertices)=md.mesh.numberofvertices+1:number_nodes3d;
    93 md.mesh.lowernodes=mesh.lowernodes;
    94 md.mesh.uppernodes=mesh.uppernodes;
     89mesh.lowervertex=NaN*ones(number_nodes3d,1);
     90mesh.uppervertex=NaN*ones(number_nodes3d,1);
     91mesh.lowervertex(md.mesh.numberofvertices+1:end)=1:(numlayers-1)*md.mesh.numberofvertices;
     92mesh.uppervertex(1:(numlayers-1)*md.mesh.numberofvertices)=md.mesh.numberofvertices+1:number_nodes3d;
     93md.mesh.lowervertex=mesh.lowervertex;
     94md.mesh.uppervertex=mesh.uppervertex;
    9595
    9696%same for lower and upper elements
    … …  
    148148
    149149%bedinfo and surface info
    150 md.elementonbed=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',1);
    151 md.elementonsurface=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',md.mesh.numberoflayers-1);
    152 md.nodeonbed=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',1);
    153 md.nodeonsurface=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',md.mesh.numberoflayers);
     150md.mesh.elementonbed=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',1);
     151md.mesh.elementonsurface=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',md.mesh.numberoflayers-1);
     152md.mesh.vertexonbed=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',1);
     153md.mesh.vertexonsurface=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',md.mesh.numberoflayers);
    154154
    155155%elementstype

  • issm/trunk/src/m/model/mesh/findsegments.m

    r9728 r9729  
    1919                error(' ''mesh.elementconnectivity'' option does not have thge right size.');
    2020        else
    21                 mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     21                mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    2222        end
    2323end

  • issm/trunk/src/m/model/mesh/meshconvert.m

    r9725 r9729  
    4040md.mesh.numberofvertices=length(md.x);
    4141md.z=zeros(md.mesh.numberofvertices,1);
    42 md.nodeonbed=ones(md.mesh.numberofvertices,1);
     42md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    4343md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    44 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    45 md.elementonbed=ones(md.mesh.numberofelements,1);
    46 md.elementonsurface=ones(md.mesh.numberofelements,1);
     44md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     45md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     46md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    4747md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;

  • issm/trunk/src/m/model/mesh/meshnodensity.m

    r9728 r9729  
    5959md.z=zeros(md.mesh.numberofvertices,1);
    6060md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    61 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    62 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    63 md.elementonbed=ones(md.mesh.numberofelements,1);
    64 md.elementonsurface=ones(md.mesh.numberofelements,1);
     61md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     62md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     63md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     64md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    6565
    6666%Now, build the connectivity tables for this mesh.
    67 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    68 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     67md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     68md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    6969
    7070%type of model

  • issm/trunk/src/m/model/mesh/meshrefine.m

    r9728 r9729  
    2323md.z=zeros(md.mesh.numberofvertices,1);
    2424md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    25 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    26 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    27 md.elementonbed=ones(md.mesh.numberofelements,1);
    28 md.elementonsurface=ones(md.mesh.numberofelements,1);
     25md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     26md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     27md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     28md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    2929
    3030%Now, build the connectivity tables for this mesh.
    31 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    32 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     31md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     32md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    3333
    3434%type of model

  • issm/trunk/src/m/model/mesh/meshyams.m

    r9728 r9729  
    9595        %rifts, because the segments are used in YamsCall to freeze the rifts elements during refinement.
    9696        if md.rifts.numrifts,
    97                 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    98                 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     97                md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     98                md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    9999                md.mesh.segments=findsegments(md);
    100100                md=meshyamsrecreateriftsegments(md);
    … …  
    106106
    107107%Now, build the connectivity tables for this mesh.
    108 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    109 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     108md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     109md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    110110
    111111%recreate segments
    … …  
    115115%Fill in rest of fields:
    116116md.z=zeros(md.mesh.numberofvertices,1);
    117 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    118 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    119 md.elementonbed=ones(md.mesh.numberofelements,1);
    120 md.elementonsurface=ones(md.mesh.numberofelements,1);
     117md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     118md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     119md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     120md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    121121if ~strcmp(groundeddomain,'N/A'),
    122122        nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);

  • issm/trunk/src/m/model/mesh/rifts/meshaddrifts.m

    r9728 r9729  
    8181%finish up "a la" mesh.h
    8282md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    83 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    84 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    85 md.elementonbed=ones(md.mesh.numberofelements,1);
    86 md.elementonsurface=ones(md.mesh.numberofelements,1);
     83md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     84md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     85md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     86md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    8787
    8888%Now, build the connectivity tables for this mesh.
    89 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    90 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     89md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     90md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    9191
    9292%type of model

  • issm/trunk/src/m/model/mesh/rifts/meshprocessoutsiderifts.m

    r9725 r9729  
    8989md.rifts.numrifts=length(md.rifts.riftstruct);
    9090md.flowequation.element_equation=3*ones(md.mesh.numberofelements,1);
    91 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    92 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    93 md.elementonbed=ones(md.mesh.numberofelements,1);
    94 md.elementonsurface=ones(md.mesh.numberofelements,1);
     91md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     92md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     93md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     94md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);

  • issm/trunk/src/m/model/mesh/rifts/meshprocessrifts.m

    r9728 r9729  
    3939md.rifts.numrifts=length(md.rifts.riftstruct);
    4040md.flowequation.element_equation=3*ones(md.mesh.numberofelements,1);
    41 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    42 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    43 md.elementonbed=ones(md.mesh.numberofelements,1);
    44 md.elementonsurface=ones(md.mesh.numberofelements,1);
     41md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     42md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     43md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     44md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    4545
    4646%get coordinates of rift tips

  • issm/trunk/src/m/model/mesh/setmesh.m

    r9728 r9729  
    7373md.z=zeros(md.mesh.numberofvertices,1);
    7474md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    75 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    76 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    77 md.elementonbed=ones(md.mesh.numberofelements,1);
    78 md.elementonsurface=ones(md.mesh.numberofelements,1);
     75md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     76md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     77md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     78md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    7979
    8080%Now, build the connectivity tables for this mesh.
    81 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    82 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     81md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     82md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    8383
    8484%type of model

  • issm/trunk/src/m/model/modelextract.m

    r9728 r9729  
    123123        md2.elements=elements_2;
    124124
    125         %mesh.uppernodes mesh.lowernodes
     125        %mesh.uppervertex mesh.lowervertex
    126126        if md1.dim==3
    127                 md2.mesh.uppernodes=md1.mesh.uppernodes(pos_node);
    128                 pos=find(~isnan(md2.mesh.uppernodes));
    129                 md2.mesh.uppernodes(pos)=Pnode(md2.mesh.uppernodes(pos));
    130 
    131                 md2.mesh.lowernodes=md1.mesh.lowernodes(pos_node);
    132                 pos=find(~isnan(md2.mesh.lowernodes));
    133                 md2.mesh.lowernodes(pos)=Pnode(md2.mesh.lowernodes(pos));
     127                md2.mesh.uppervertex=md1.mesh.uppervertex(pos_node);
     128                pos=find(~isnan(md2.mesh.uppervertex));
     129                md2.mesh.uppervertex(pos)=Pnode(md2.mesh.uppervertex(pos));
     130
     131                md2.mesh.lowervertex=md1.mesh.lowervertex(pos_node);
     132                pos=find(~isnan(md2.mesh.lowervertex));
     133                md2.mesh.lowervertex(pos)=Pnode(md2.mesh.lowervertex(pos));
    134134
    135135                md2.mesh.upperelements=md1.mesh.upperelements(pos_elem);
    … …  
    203203        %recreate segments
    204204        if md1.dim==2
    205                 md2.mesh.nodeconnectivity=NodeConnectivity(md2.elements,md2.numberofnodes);
    206                 md2.mesh.elementconnectivity=ElementConnectivity(md2.elements,md2.mesh.nodeconnectivity);
     205                md2.mesh.vertexconnectivity=NodeConnectivity(md2.elements,md2.numberofnodes);
     206                md2.mesh.elementconnectivity=ElementConnectivity(md2.elements,md2.mesh.vertexconnectivity);
    207207                md2.segments=contourenvelope(md2);
    208208                md2.mesh.vertexonboundary=zeros(numberofnodes2,1); md2.nodeonboundary(md2.segments(:,1:2))=1;

  • issm/trunk/src/m/model/partition/AreaAverageOntoPartition.m

    r9728 r9729  
    2222        md.mesh.numberofelements=md.mesh.numberofelements2d;
    2323        md.vertex_weight=[];
    24         md.mesh.nodeconnectivity=[];
     24        md.mesh.vertexconnectivity=[];
    2525
    2626        %run connectivity routine

  • issm/trunk/src/m/model/partition/adjacency.m

    r9728 r9729  
    1919
    2020%get node connectivity
    21 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     21md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    2222
    23 connectivity=md.mesh.nodeconnectivity(:,1:end-1);
     23connectivity=md.mesh.vertexconnectivity(:,1:end-1);
    2424pos=find(connectivity);
    2525connectivity(pos)=areas(connectivity(pos))/3;

  • issm/trunk/src/m/model/partition/partitioner.m

    r9728 r9729  
    4040        md.mesh.numberofelements=md.mesh.numberofelements2d;
    4141        md.qmu.vertex_weight=[];
    42         md.mesh.nodeconnectivity=[];
     42        md.mesh.vertexconnectivity=[];
    4343end
    4444

  • issm/trunk/src/m/model/setmask2.m

    r9728 r9729  
    2828
    2929%Now, build the connectivity tables for this mesh.
    30 if size(md.mesh.nodeconnectivity,1)~=md.mesh.numberofvertices,
    31         md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     30if size(md.mesh.vertexconnectivity,1)~=md.mesh.numberofvertices,
     31        md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    3232end
    3333if size(md.mesh.elementconnectivity,1)~=md.mesh.numberofelements,
    34         md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     34        md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    3535end
    3636
    … …  
    125125%check that no node thinks it's on an ice shelf or ice sheet, and lies actually in the middle of the water.
    126126nodesgrounded=find(~vertexonwater);
    127 lengthconnectivity=size(md.mesh.nodeconnectivity,2);
    128 groundedcounters=md.mesh.nodeconnectivity(nodesgrounded,lengthconnectivity);
    129 groundedconnectivity=md.mesh.nodeconnectivity(nodesgrounded,1:lengthconnectivity-1);
     127lengthconnectivity=size(md.mesh.vertexconnectivity,2);
     128groundedcounters=md.mesh.vertexconnectivity(nodesgrounded,lengthconnectivity);
     129groundedconnectivity=md.mesh.vertexconnectivity(nodesgrounded,1:lengthconnectivity-1);
    130130pos=find(groundedconnectivity);
    131131groundedconnectivity(pos)=elementonwater(groundedconnectivity(pos));

  • issm/trunk/src/m/utils/BC/SetIceSheetBC.m

    r9725 r9729  
    6060if (length(md.initialization.temperature)==md.mesh.numberofvertices),
    6161        md.thermal.spctemperature=NaN*ones(md.mesh.numberofvertices,1);
    62         pos=find(md.nodeonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
     62        pos=find(md.mesh.vertexonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
    6363        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
    6464                md.basalforcings.geothermalflux=50*10^-3*ones(md.mesh.numberofvertices,1); %50 mW/m^2

  • issm/trunk/src/m/utils/BC/SetIceShelfBC.m

    r9725 r9729  
    9292if (length(md.initialization.temperature)==md.mesh.numberofvertices),
    9393        md.thermal.spctemperature=NaN*ones(md.mesh.numberofvertices,1);
    94         pos=find(md.nodeonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
     94        pos=find(md.mesh.vertexonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
    9595        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
    9696                md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);

  • issm/trunk/src/m/utils/BC/SetMarineIceSheetBC.m

    r9725 r9729  
    103103if (length(md.initialization.temperature)==md.mesh.numberofvertices),
    104104        md.thermal.spctemperature=NaN*ones(md.mesh.numberofvertices,1);
    105         pos=find(md.nodeonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
     105        pos=find(md.mesh.vertexonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
    106106        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
    107107                md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);

  • issm/trunk/src/m/utils/Mesh/NodeInElement.m

    r2110 r9729  
    22%NODEINELEMENT: find for a list of nodes (in newx,newy), which elements in the mesh (elements,x,y) they belong to.
    33%
    4 %  Usage: node_in_element=NodeInElement(newx,newy,elements,x,y,md.nodeconnectivity);
     4%  Usage: node_in_element=NodeInElement(newx,newy,elements,x,y,md.mesh.vertexconnectivity);
    55%
    66%  See also Nodeconnectivity

  • issm/trunk/src/m/utils/Mesh/ProfileProjectOntoMesh.m

    r9728 r9729  
    4848
    4949%now, for each node, figure out which element it belongs to.
    50 node_in_element=NodeInElement(newx,newy,md.elements,md.x,md.y,md.mesh.nodeconnectivity);
     50node_in_element=NodeInElement(newx,newy,md.elements,md.x,md.y,md.mesh.vertexconnectivity);
    5151
    5252% eliminate nodes that don't fall in any element

  • issm/trunk/src/m/utils/Mesh/argusmesh.m

    r9725 r9729  
    8383md.mesh.numberofvertices=size(md.x,1);
    8484md.mesh.numberofelements=size(md.elements,1);
    85 md.nodeonbed=ones(md.mesh.numberofvertices,1);
    86 md.nodeonsurface=ones(md.mesh.numberofvertices,1);
    87 md.elementonbed=ones(md.mesh.numberofelements,1);
    88 md.elementonsurface=ones(md.mesh.numberofelements,1);
     85md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
     86md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
     87md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
     88md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    8989md.mesh.dimension=2;
    9090md=addnote(md,notes);

  • issm/trunk/src/m/utils/Mesh/squaremesh.m

    r9728 r9729  
    6161md.mesh.numberofvertices=nods;
    6262md.mesh.vertexonboundary=zeros(nods,1);md.mesh.vertexonboundary(segments(:,1:2))=1;
    63 md.nodeonbed=ones(nods,1);
    64 md.nodeonsurface=ones(nods,1);
     63md.mesh.vertexonbed=ones(nods,1);
     64md.mesh.vertexonsurface=ones(nods,1);
    6565
    6666%plug elements
    … …  
    6868md.mesh.segments=segments;
    6969md.mesh.numberofelements=nel;
    70 md.elementonbed=ones(nel,1);
    71 md.elementonsurface=ones(nel,1);
     70md.mesh.elementonbed=ones(nel,1);
     71md.mesh.elementonsurface=ones(nel,1);
    7272
    7373%Now, build the connectivity tables for this mesh.
    74 md.mesh.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    75 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.nodeconnectivity);
     74md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     75md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
    7676
    7777%plug other field

  • issm/trunk/template

    r9728 r9729  
    1111          x2d
    1212          y2d
    13 
    14           elementonbed
    15           elementonsurface
    16           nodeonbed
    17           nodeonsurface
    1813}}}
    1914

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

    r9725 r9729  
    2525        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2626
    27         pos=find(md.nodeonbed);
     27        pos=find(md.mesh.vertexonbed);
    2828        md.diagnostic.spcvx(pos)=0;
    2929        md.diagnostic.spcvy(pos)=0;

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

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

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

    r9725 r9729  
    2222        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    2323        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    24         pos=find(md.nodeonbed);
     24        pos=find(md.mesh.vertexonbed);
    2525        md.diagnostic.spcvx(pos)=0;
    2626        md.diagnostic.spcvy(pos)=0;

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

    r9725 r9729  
    2222        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2323
    24         pos=find(md.nodeonbed);
     24        pos=find(md.mesh.vertexonbed);
    2525        md.diagnostic.spcvx(pos)=0;
    2626        md.diagnostic.spcvy(pos)=0;

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

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

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

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

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

    r9725 r9729  
    3131
    3232        %Create spcs on the bed
    33         pos=find(md.nodeonbed);
     33        pos=find(md.mesh.vertexonbed);
    3434        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    3535        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);

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

    r9725 r9729  
    2525        if (i==1 | i==3),
    2626                %Create dirichlet on the bed if no slip
    27                 pos=find(md.nodeonbed);
     27                pos=find(md.mesh.vertexonbed);
    2828                md.diagnostic.spcvx(pos)=0;
    2929                md.diagnostic.spcvy(pos)=0;
    3030                md.diagnostic.spcvz(pos)=0;
    3131        else
    32                 pos=find(md.nodeonbed & (md.x==0 | md.x==max(md.x)) & (md.y==0 | md.y==max(md.y)));
     32                pos=find(md.mesh.vertexonbed & (md.x==0 | md.x==max(md.x)) & (md.y==0 | md.y==max(md.y)));
    3333                md.diagnostic.spcvx(pos)=100; %because we need a dirichlet somewhere
    3434                md.diagnostic.spcvy(pos)=0;
    3535                md.diagnostic.spcvz(pos)=0;
    3636        end
    37         pos=find(~md.nodeonbed);
     37        pos=find(~md.mesh.vertexonbed);
    3838        md.thermal.spctemperature(pos)=255;
    3939

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

    r9725 r9729  
    2222
    2323%Spc the nodes on the bed
    24 pos=find(md.nodeonbed);
     24pos=find(md.mesh.vertexonbed);
    2525md.diagnostic.spcvx(pos)=0;
    2626md.diagnostic.spcvy(pos)=0;

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

    r9725 r9729  
    2222
    2323%Spc the nodes on the bed
    24 pos=find(md.nodeonbed);
     24pos=find(md.mesh.vertexonbed);
    2525md.diagnostic.spcvx(pos)=0;
    2626md.diagnostic.spcvy(pos)=0;

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

    r9725 r9729  
    2222
    2323%Spc the nodes on the bed
    24 pos=find(md.nodeonbed);
     24pos=find(md.mesh.vertexonbed);
    2525md.diagnostic.spcvx(pos)=0;
    2626md.diagnostic.spcvy(pos)=0;

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

    r9703 r9729  
    1313
    1414%Spc the nodes on the bed
    15 pos=find(md.nodeonbed);
     15pos=find(md.mesh.vertexonbed);
    1616md.diagnostic.spcvx(pos)=0;
    1717md.diagnostic.spcvy(pos)=0;

  • issm/trunk/test/NightlyRun/test1301.m

    r9725 r9729  
    1515md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1616md.initialization.temperature=273.15*ones(md.mesh.numberofvertices,1);
    17 pos=find(md.nodeonsurface);
     17pos=find(md.mesh.vertexonsurface);
    1818md.thermal.spctemperature(pos)=md.initialization.temperature(pos);
    1919md.materials.rheology_B=paterson(md.initialization.temperature);

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

    r9725 r9729  
    1212
    1313%Thermal boundary conditions
    14 pos1=find(md.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
    15 pos2=find(md.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
     14pos1=find(md.mesh.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
     15pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
    1616md.initialization.vz=0.1*ones(md.mesh.numberofvertices,1);
    1717md.initialization.vel=sqrt( md.initialization.vx.^2+ md.initialization.vy.^2+ md.initialization.vz.^2);

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

    r9725 r9729  
    1111md=extrude(md,11,2);
    1212md=setflowequation(md,'Pattyn','all');
    13 pos1=find(md.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
    14 pos2=find(md.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
     13pos1=find(md.mesh.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
     14pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
    1515md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1616

  • issm/trunk/test/NightlyRun/test1304.m

    r9725 r9729  
    1212md=setflowequation(md,'Pattyn','all');
    1313
    14 pos2=find(md.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
     14pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
    1515md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1616md.basalforcings.geothermalflux(:)=0.1; %100mW/m^2
Note: See TracChangeset for help on using the changeset viewer.