Changeset 9733


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

keep building mesh

Location:
issm/trunk
Files:
3 added
3 deleted
147 edited

Legend:

Unmodified
Added
Removed

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

    r9731 r9733  
    163163        MeshVertexonsurfaceEnum,
    164164        MeshElements2dEnum,
     165        MeshElementsEnum,
     166        MeshEdgesEnum,
    165167        /*}}}*/
    166168        /*Datasets {{{1*/
    167169        ConstraintsEnum,
    168         ElementsEnum,
    169170        LoadsEnum,
    170171        MaterialsEnum,
    … …  
    474475        YEnum,
    475476        ZEnum,
    476         EdgesEnum,
    477477        XEnum,
    478478        OutputfilenameEnum,

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

    r9731 r9733  
    167167                case MeshVertexonsurfaceEnum : return "MeshVertexonsurface";
    168168                case MeshElements2dEnum : return "MeshElements2d";
     169                case MeshElementsEnum : return "MeshElements";
     170                case MeshEdgesEnum : return "MeshEdges";
    169171                case ConstraintsEnum : return "Constraints";
    170                 case ElementsEnum : return "Elements";
    171172                case LoadsEnum : return "Loads";
    172173                case MaterialsEnum : return "Materials";
    … …  
    417418                case YEnum : return "Y";
    418419                case ZEnum : return "Z";
    419                 case EdgesEnum : return "Edges";
    420420                case XEnum : return "X";
    421421                case OutputfilenameEnum : return "Outputfilename";

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

    r9725 r9733  
    3636
    3737                /*Get edges and elements*/
    38                 iomodel->FetchData(3,EdgesEnum,ElementsEnum,ThicknessEnum);
     38                iomodel->FetchData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
    3939
    4040                /*First load data:*/
    … …  
    4242
    4343                        /*Get left and right elements*/
    44                         element=(int)iomodel->Data(EdgesEnum)[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
     44                        element=(int)iomodel->Data(MeshEdgesEnum)[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
    4545
    4646                        /*Now, if this element is not in the partition, pass: */
    … …  
    5252
    5353                /*Free data: */
    54                 iomodel->DeleteData(3,EdgesEnum,ElementsEnum,ThicknessEnum);
     54                iomodel->DeleteData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
    5555        }
    5656

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

    r9729 r9733  
    4949
    5050        /*First fetch data: */
    51         iomodel->FetchData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     51        iomodel->FetchData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5252
    5353        if(continuous_galerkin){
    … …  
    7272
    7373                                        //Get index of the vertex on which the current node is located
    74                                         vertex_id=(int)*(iomodel->Data(ElementsEnum)+3*i+j); //(Matlab indexing)
     74                                        vertex_id=(int)*(iomodel->Data(MeshElementsEnum)+3*i+j); //(Matlab indexing)
    7575                                        io_index=vertex_id-1;                      //(C indexing)
    7676                                        _assert_(vertex_id>0 && vertex_id<=numberofvertices);
    … …  
    8888
    8989        /*Clean fetched data: */
    90         iomodel->DeleteData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     90        iomodel->DeleteData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    9191
    9292        /*Assign output pointer: */

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

    r9729 r9733  
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    24         iomodel->FetchData(1,ElementsEnum);
     24        iomodel->FetchData(1,MeshElementsEnum);
    2525
    2626        /*Update elements: */
    … …  
    5252        }
    5353        /*Free data: */
    54         iomodel->DeleteData(1,ElementsEnum);
     54        iomodel->DeleteData(1,MeshElementsEnum);
    5555}

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

    r9729 r9733  
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    24         iomodel->FetchData(1,ElementsEnum);
     24        iomodel->FetchData(1,MeshElementsEnum);
    2525
    2626        /*Update elements: */
    … …  
    4444       
    4545        /*Free data: */
    46         iomodel->DeleteData(1,ElementsEnum);
     46        iomodel->DeleteData(1,MeshElementsEnum);
    4747}

  • issm/trunk/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

    r9725 r9733  
    3535
    3636        /*Fetch data needed: */
    37         iomodel->FetchData(1,ElementsEnum);
     37        iomodel->FetchData(1,MeshElementsEnum);
    3838        iomodel->FetchDataToInput(elements,InversionVxObsEnum);
    3939        iomodel->FetchDataToInput(elements,InversionVyObsEnum);
    … …  
    6666       
    6767        /*Free data: */
    68         iomodel->DeleteData(1+4+5,ElementsEnum,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum,BalancethicknessThickeningRateEnum,VxEnum,VyEnum,FrictionCoefficientEnum,MaterialsRheologyBEnum);
     68        iomodel->DeleteData(1+4+5,MeshElementsEnum,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum,BalancethicknessThickeningRateEnum,VxEnum,VyEnum,FrictionCoefficientEnum,MaterialsRheologyBEnum);
    6969}

  • issm/trunk/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp

    r9728 r9733  
    3737
    3838        /*First create the elements, vertices, nodes and material properties, if they don't already exist */
    39         elements  = new Elements(ElementsEnum);
     39        elements  = new Elements(MeshElementsEnum);
    4040        vertices  = new Vertices(VerticesEnum);
    4141        materials = new Materials(MaterialsEnum);
    … …  
    4545       
    4646        /*Fetch data needed: */
    47         iomodel->FetchData(4,ElementsEnum,MeshElementconnectivityEnum,MaterialsRheologyBEnum,MaterialsRheologyNEnum);
     47        iomodel->FetchData(4,MeshElementsEnum,MeshElementconnectivityEnum,MaterialsRheologyBEnum,MaterialsRheologyNEnum);
    4848        if(dim==3)          iomodel->FetchData(2,MeshUpperelementsEnum,MeshLowerelementsEnum);
    4949        if(control_analysis)iomodel->FetchData(3,InversionControlParametersEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
    … …  
    6363       
    6464        /*Free data: */
    65         iomodel->DeleteData(9,ElementsEnum,MeshElementconnectivityEnum,MeshUpperelementsEnum,MeshLowerelementsEnum,
     65        iomodel->DeleteData(9,MeshElementsEnum,MeshElementconnectivityEnum,MeshUpperelementsEnum,MeshLowerelementsEnum,
    6666                                MaterialsRheologyBEnum,MaterialsRheologyNEnum,InversionControlParametersEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
    6767

  • issm/trunk/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp

    r9725 r9733  
    3232        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    3333        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    34         elements=iomodel->Data(ElementsEnum);
     34        elements=iomodel->Data(MeshElementsEnum);
    3535
    3636        /*Some checks if debugging*/

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

    r9725 r9733  
    3535        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    3636        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    37         elements=iomodel->Data(ElementsEnum);
     37        elements=iomodel->Data(MeshElementsEnum);
    3838
    3939        /*Some checks if debugging*/

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

    r9729 r9733  
    128128        iomodel->FetchData(&nodeonstokes,NULL,NULL,FlowequationBorderstokesEnum);
    129129        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    130         iomodel->FetchData(1,ElementsEnum);
     130        iomodel->FetchData(1,MeshElementsEnum);
    131131        CreateSingleNodeToElementConnectivity(iomodel);
    132132       
    … …  
    146146        xfree((void**)&nodeonicesheet);
    147147        xfree((void**)&vertices_type);
    148         iomodel->DeleteData(1,ElementsEnum);
     148        iomodel->DeleteData(1,MeshElementsEnum);
    149149
    150150        /*Create Penpair for penalties: */

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

    r9729 r9733  
    3535
    3636        /*Fetch data needed: */
    37         iomodel->FetchData(2,ElementsEnum,FlowequationElementEquationEnum);
     37        iomodel->FetchData(2,MeshElementsEnum,FlowequationElementEquationEnum);
    3838
    3939        /*Update elements: */
    … …  
    9595       
    9696        /*Free data: */
    97         iomodel->DeleteData(2,ElementsEnum,FlowequationElementEquationEnum);
     97        iomodel->DeleteData(2,MeshElementsEnum,FlowequationElementEquationEnum);
    9898}

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

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

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

    r9725 r9733  
    2727        if (!ishutter)return;
    2828
    29         iomodel->FetchData(2,ElementsEnum,FlowequationElementEquationEnum);
     29        iomodel->FetchData(2,MeshElementsEnum,FlowequationElementEquationEnum);
    3030
    3131        /*Update elements: */
    … …  
    4343       
    4444        /*Free data: */
    45         iomodel->DeleteData(2,ElementsEnum,FlowequationElementEquationEnum);
     45        iomodel->DeleteData(2,MeshElementsEnum,FlowequationElementEquationEnum);
    4646}

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

    r9729 r9733  
    2727
    2828        /*Fetch data needed: */
    29         iomodel->FetchData(1,ElementsEnum);
     29        iomodel->FetchData(1,MeshElementsEnum);
    3030
    3131        /*Update elements: */
    … …  
    5555
    5656        /*Free data: */
    57         iomodel->DeleteData(1,ElementsEnum);
     57        iomodel->DeleteData(1,MeshElementsEnum);
    5858       
    5959}

  • issm/trunk/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp

    r9731 r9733  
    6767        if(dim==2){
    6868                /*load elements: */
    69                 iomodel->FetchData(&elements,NULL,NULL,ElementsEnum);
     69                iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
    7070        }
    7171        else{
    … …  
    101101
    102102        /*Start figuring out, out of the partition, which elements belong to this cpu: */
    103         iomodel->FetchData(&elements,NULL,NULL,ElementsEnum);
     103        iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
    104104        for (i=0;i<numberofelements;i++){
    105105

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

    r9729 r9733  
    2727
    2828        /*Fetch data needed: */
    29         iomodel->FetchData(1,ElementsEnum);
     29        iomodel->FetchData(1,MeshElementsEnum);
    3030
    3131        /*Update elements: */
    … …  
    6161       
    6262        /*Free data: */
    63         iomodel->DeleteData(1,ElementsEnum);
     63        iomodel->DeleteData(1,MeshElementsEnum);
    6464}

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

    r9729 r9733  
    2020        /*Fetch data needed: */
    2121        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    22         iomodel->FetchData(1,ElementsEnum);
     22        iomodel->FetchData(1,MeshElementsEnum);
    2323
    2424        /*Update elements: */
    … …  
    5757
    5858        /*Free data: */
    59         iomodel->DeleteData(1,ElementsEnum);
     59        iomodel->DeleteData(1,MeshElementsEnum);
    6060}

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

    r9729 r9733  
    3535
    3636        //create penalties for nodes: no node can have a temperature over the melting point
    37         iomodel->FetchData(2,MeshVertexonbedEnum,ElementsEnum);
     37        iomodel->FetchData(2,MeshVertexonbedEnum,MeshElementsEnum);
    3838        CreateSingleNodeToElementConnectivity(iomodel);
    3939
    … …  
    4545                }
    4646        }
    47         iomodel->DeleteData(2,MeshVertexonbedEnum,ElementsEnum);
     47        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshElementsEnum);
    4848
    4949        /*Assign output pointer: */

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

    r9729 r9733  
    2727
    2828        /*Fetch data needed: */
    29         iomodel->FetchData(1,ElementsEnum);
     29        iomodel->FetchData(1,MeshElementsEnum);
    3030
    3131        /*Update elements: */
    … …  
    6060       
    6161        /*Free data: */
    62         iomodel->DeleteData(1,ElementsEnum);
     62        iomodel->DeleteData(1,MeshElementsEnum);
    6363}

  • issm/trunk/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

    r9725 r9733  
    109109
    110110        /*Get edges and elements*/
    111         iomodel->FetchData(&edges,&numberofedges,&cols,EdgesEnum);
    112         iomodel->FetchData(&elements,NULL,NULL,ElementsEnum);
     111        iomodel->FetchData(&edges,&numberofedges,&cols,MeshEdgesEnum);
     112        iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
    113113        if (cols!=4) _error_("field edges should have 4 columns");
    114114

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

    r9729 r9733  
    4141
    4242                /*Get edges and elements*/
    43                 iomodel->FetchData(3,EdgesEnum,ElementsEnum,ThicknessEnum);
     43                iomodel->FetchData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
    4444
    4545                /*First load data:*/
    … …  
    4747
    4848                        /*Get left and right elements*/
    49                         element=(int)(iomodel->Data(EdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
     49                        element=(int)(iomodel->Data(MeshEdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
    5050
    5151                        /*Now, if this element is not in the partition, pass: */
    … …  
    5757
    5858                /*Free data: */
    59                 iomodel->DeleteData(3,EdgesEnum,ElementsEnum,ThicknessEnum);
     59                iomodel->DeleteData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
    6060        }
    6161

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

    r9729 r9733  
    4949
    5050        /*First fetch data: */
    51         iomodel->FetchData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     51        iomodel->FetchData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5252        if(continuous_galerkin){
    5353
    … …  
    7272
    7373                                        //Get index of the vertex on which the current node is located
    74                                         vertex_id=(int)*(iomodel->Data(ElementsEnum)+3*i+j); //(Matlab indexing)
     74                                        vertex_id=(int)*(iomodel->Data(MeshElementsEnum)+3*i+j); //(Matlab indexing)
    7575                                        io_index=vertex_id-1;                      //(C indexing)
    7676                                        _assert_(vertex_id>0 && vertex_id<=numberofvertices);
    … …  
    8888
    8989        /*Clean fetched data: */
    90         iomodel->DeleteData(7,ElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     90        iomodel->DeleteData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    9191
    9292        /*Assign output pointer: */

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

    r9729 r9733  
    2424        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2525        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    26         iomodel->FetchData(1,ElementsEnum);
     26        iomodel->FetchData(1,MeshElementsEnum);
    2727
    2828        /*Update elements: */
    … …  
    6161       
    6262        /*Free data: */
    63         iomodel->DeleteData(1,ElementsEnum);
     63        iomodel->DeleteData(1,MeshElementsEnum);
    6464}

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

    r9729 r9733  
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    24         iomodel->FetchData(1,ElementsEnum);
     24        iomodel->FetchData(1,MeshElementsEnum);
    2525
    2626        /*Update elements: */
    … …  
    4444       
    4545        /*Free data: */
    46         iomodel->DeleteData(1,ElementsEnum);
     46        iomodel->DeleteData(1,MeshElementsEnum);
    4747}

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

    r9725 r9733  
    3636
    3737        //create penalties for nodes: no node can have a temperature over the melting point
    38         iomodel->FetchData(2,ThermalSpctemperatureEnum,ElementsEnum);
     38        iomodel->FetchData(2,ThermalSpctemperatureEnum,MeshElementsEnum);
    3939        CreateSingleNodeToElementConnectivity(iomodel);
    4040
    … …  
    4848                }
    4949        }
    50         iomodel->DeleteData(2,ThermalSpctemperatureEnum,ElementsEnum);
     50        iomodel->DeleteData(2,ThermalSpctemperatureEnum,MeshElementsEnum);
    5151
    5252        /*Assign output pointer: */

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

    r9729 r9733  
    2929
    3030        /*Fetch data needed: */
    31         iomodel->FetchData(1,ElementsEnum);
     31        iomodel->FetchData(1,MeshElementsEnum);
    3232
    3333        /*Update elements: */
    … …  
    6464
    6565        /*Free data: */
    66         iomodel->DeleteData(1,ElementsEnum);
     66        iomodel->DeleteData(1,MeshElementsEnum);
    6767}

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

    r9731 r9733  
    165165        else if (strcmp(name,"MeshVertexonsurface")==0) return MeshVertexonsurfaceEnum;
    166166        else if (strcmp(name,"MeshElements2d")==0) return MeshElements2dEnum;
     167        else if (strcmp(name,"MeshElements")==0) return MeshElementsEnum;
     168        else if (strcmp(name,"MeshEdges")==0) return MeshEdgesEnum;
    167169        else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    168         else if (strcmp(name,"Elements")==0) return ElementsEnum;
    169170        else if (strcmp(name,"Loads")==0) return LoadsEnum;
    170171        else if (strcmp(name,"Materials")==0) return MaterialsEnum;
    … …  
    415416        else if (strcmp(name,"Y")==0) return YEnum;
    416417        else if (strcmp(name,"Z")==0) return ZEnum;
    417         else if (strcmp(name,"Edges")==0) return EdgesEnum;
    418418        else if (strcmp(name,"X")==0) return XEnum;
    419419        else if (strcmp(name,"Outputfilename")==0) return OutputfilenameEnum;

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

    r9729 r9733  
    48534853                /*Recover vertices ids needed to initialize inputs*/
    48544854                for(i=0;i<6;i++){
    4855                         penta_vertex_ids[i]=(int)iomodel->Data(ElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     4855                        penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
    48564856                }
    48574857
    … …  
    49474947
    49484948                /*Step1: Get original input (to be depth avegaged): */
    4949                 if (object_enum==ElementsEnum)
     4949                if (object_enum==MeshElementsEnum)
    49504950                 original_input=(Input*)penta->inputs->GetInput(enum_type);
    49514951                else if (object_enum==MaterialsEnum)
    … …  
    50075007
    50085008        /*Finally, add to inputs*/
    5009         if (object_enum==ElementsEnum)
     5009        if (object_enum==MeshElementsEnum)
    50105010         this->inputs->AddInput((Input*)depth_averaged_input);
    50115011        else if (object_enum==MaterialsEnum)
    … …  
    50375037
    50385038                /*Step1: Extrude the original input: */
    5039                 if (object_type==ElementsEnum)
     5039                if (object_type==MeshElementsEnum)
    50405040                 original_input=(Input*)this->inputs->GetInput(enum_type);
    50415041                else if (object_type==MaterialsEnum)
    … …  
    50605060                        Input* copy=NULL;
    50615061                        copy=(Input*)original_input->copy();
    5062                         if (object_type==ElementsEnum)
     5062                        if (object_type==MeshElementsEnum)
    50635063                         penta->inputs->AddInput((Input*)copy);
    50645064                        else if (object_type==MaterialsEnum)
    … …  
    51605160        /*Checks if debuging*/
    51615161        /*{{{2*/
    5162         _assert_(iomodel->Data(ElementsEnum));
     5162        _assert_(iomodel->Data(MeshElementsEnum));
    51635163        /*}}}*/
    51645164
    51655165        /*Recover vertices ids needed to initialize inputs*/
    51665166        for(i=0;i<6;i++){
    5167                 penta_vertex_ids[i]=(int)iomodel->Data(ElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     5167                penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
    51685168        }
    51695169
    … …  
    75157515        /*Checks if debuging*/
    75167516        /*{{{2*/
    7517         _assert_(iomodel->Data(ElementsEnum));
     7517        _assert_(iomodel->Data(MeshElementsEnum));
    75187518        /*}}}*/
    75197519
    … …  
    75307530
    75317531        /*Recover vertices ids needed to initialize inputs*/
    7532         for(i=0;i<6;i++) penta_vertex_ids[i]=(int)iomodel->Data(ElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     7532        for(i=0;i<6;i++) penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
    75337533
    75347534        /*Recover nodes ids needed to initialize the node hook.*/
    … …  
    75367536                //go recover node ids, needed to initialize the node hook.
    75377537                //WARNING: We assume P1 elements here!!!!!
    7538                 penta_node_ids[i]=iomodel->nodecounter+(int)iomodel->Data(ElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     7538                penta_node_ids[i]=iomodel->nodecounter+(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
    75397539        }
    75407540

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

    r9218 r9733  
    101101                void   InputCreate(double scalar,int name,int code);
    102102                void   InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    103                 void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=ElementsEnum);
     103                void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
    104104                void   InputDuplicate(int original_enum,int new_enum);
    105105                void   InputScale(int enum_type,double scale_factor);

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

    r9729 r9733  
    31703170
    31713171        /*copy input of enum_type*/
    3172         if (object_enum==ElementsEnum)
     3172        if (object_enum==MeshElementsEnum)
    31733173         oldinput=(Input*)this->inputs->GetInput(enum_type);
    31743174        else if (object_enum==MaterialsEnum)
    … …  
    31833183
    31843184        /*Add new input to current element*/
    3185         if (object_enum==ElementsEnum)
     3185        if (object_enum==MeshElementsEnum)
    31863186         this->inputs->AddInput((Input*)newinput);
    31873187        else if (object_enum==MaterialsEnum)
    … …  
    32783278        /*Recover vertices ids needed to initialize inputs*/
    32793279        for(i=0;i<3;i++){
    3280                 tria_vertex_ids[i]=(int)iomodel->Data(ElementsEnum)[3*index+i]; //ids for vertices are in the elements array from Matlab
     3280                tria_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[3*index+i]; //ids for vertices are in the elements array from Matlab
    32813281        }
    32823282
    … …  
    39073907                /*Recover vertices ids needed to initialize inputs*/
    39083908                for(i=0;i<3;i++){
    3909                         tria_vertex_ids[i]=(int)iomodel->Data(ElementsEnum)[3*index+i]; //ids for vertices are in the elements array from Matlab
     3909                        tria_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[3*index+i]; //ids for vertices are in the elements array from Matlab
    39103910                }
    39113911
    … …  
    52145214        /*Checks if debuging*/
    52155215        /*{{{2*/
    5216         _assert_(iomodel->Data(ElementsEnum));
     5216        _assert_(iomodel->Data(MeshElementsEnum));
    52175217        /*}}}*/
    52185218
    … …  
    52365236        /*Recover vertices ids needed to initialize inputs*/
    52375237        for(i=0;i<3;i++){
    5238                 tria_vertex_ids[i]=(int)iomodel->Data(ElementsEnum)[3*index+i]; //ids for vertices are in the elements array from Matlab
     5238                tria_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[3*index+i]; //ids for vertices are in the elements array from Matlab
    52395239        }
    52405240
    … …  
    52495249                /*Continuous Galerkin*/
    52505250                for(i=0;i<3;i++){
    5251                         tria_node_ids[i]=iomodel->nodecounter+(int)*(iomodel->Data(ElementsEnum)+3*index+i); //ids for vertices are in the elements array from Matlab
     5251                        tria_node_ids[i]=iomodel->nodecounter+(int)*(iomodel->Data(MeshElementsEnum)+3*index+i); //ids for vertices are in the elements array from Matlab
    52525252                }
    52535253        }

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

    r9271 r9733  
    102102                void   InputCreate(double scalar,int name,int code);
    103103                void   InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    104                 void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=ElementsEnum);
     104                void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
    105105                void   InputDuplicate(int original_enum,int new_enum);
    106106                void   InputScale(int enum_type,double scale_factor);

  • issm/trunk/src/c/objects/Loads/Numericalflux.cpp

    r9725 r9733  
    6060
    6161        /*First, see wether this is an internal or boundary edge (if e2=NaN)*/
    62         if (isnan((double)iomodel->Data(EdgesEnum)[4*i+3])){ //edges are [node1 node2 elem1 elem2]
     62        if (isnan((double)iomodel->Data(MeshEdgesEnum)[4*i+3])){ //edges are [node1 node2 elem1 elem2]
    6363                /* Boundary edge, only one element */
    64                 e1=(int)iomodel->Data(EdgesEnum)[4*i+2];
     64                e1=(int)iomodel->Data(MeshEdgesEnum)[4*i+2];
    6565                e2=(int)UNDEF;
    6666                num_elems=1;
    … …  
    7171        else{
    7272                /* internal edge: connected to 2 elements */
    73                 e1=(int)iomodel->Data(EdgesEnum)[4*i+2];
    74                 e2=(int)iomodel->Data(EdgesEnum)[4*i+3];
     73                e1=(int)iomodel->Data(MeshEdgesEnum)[4*i+2];
     74                e2=(int)iomodel->Data(MeshEdgesEnum)[4*i+3];
    7575                num_elems=2;
    7676                num_nodes=4;
    … …  
    8181
    8282        /*1: Get vertices ids*/
    83         i1=(int)iomodel->Data(EdgesEnum)[4*i+0];
    84         i2=(int)iomodel->Data(EdgesEnum)[4*i+1];
     83        i1=(int)iomodel->Data(MeshEdgesEnum)[4*i+0];
     84        i2=(int)iomodel->Data(MeshEdgesEnum)[4*i+1];
    8585
    8686        if (numericalflux_type==InternalEnum){
    … …  
    9191                pos1=pos2=pos3=pos4=UNDEF;
    9292                for(j=0;j<3;j++){
    93                         if (iomodel->Data(ElementsEnum)[3*(e1-1)+j]==i1) pos1=j+1;
    94                         if (iomodel->Data(ElementsEnum)[3*(e1-1)+j]==i2) pos2=j+1;
    95                         if (iomodel->Data(ElementsEnum)[3*(e2-1)+j]==i1) pos3=j+1;
    96                         if (iomodel->Data(ElementsEnum)[3*(e2-1)+j]==i2) pos4=j+1;
     93                        if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i1) pos1=j+1;
     94                        if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i2) pos2=j+1;
     95                        if (iomodel->Data(MeshElementsEnum)[3*(e2-1)+j]==i1) pos3=j+1;
     96                        if (iomodel->Data(MeshElementsEnum)[3*(e2-1)+j]==i2) pos4=j+1;
    9797                }
    9898                _assert_(pos1!=UNDEF && pos2!=UNDEF && pos3!=UNDEF && pos4!=UNDEF);
    … …  
    110110                pos1=pos2=UNDEF;
    111111                for(j=0;j<3;j++){
    112                         if (iomodel->Data(ElementsEnum)[3*(e1-1)+j]==i1) pos1=j+1;
    113                         if (iomodel->Data(ElementsEnum)[3*(e1-1)+j]==i2) pos2=j+1;
     112                        if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i1) pos1=j+1;
     113                        if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i2) pos2=j+1;
    114114                }
    115115                _assert_(pos1!=UNDEF && pos2!=UNDEF);

  • issm/trunk/src/c/objects/Materials/Matice.cpp

    r9719 r9733  
    675675                /*Get B*/
    676676                if (iomodel->Data(MaterialsRheologyBEnum)) {
    677                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+i]-1)];
     677                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
    678678                        this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyBbarEnum,nodeinputs));
    679679                }
    … …  
    692692                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    693693                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    694                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+j]-1)];
    695                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    696                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     694                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
     695                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     696                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    697697                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    698698                                                }
    … …  
    714714                /*Get B*/
    715715                if (iomodel->Data(MaterialsRheologyBEnum)) {
    716                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+i]-1)];
     716                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
    717717                        this->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,nodeinputs));
    718718                }
    … …  
    731731                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    732732                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    733                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+j]-1)];
    734                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    735                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(ElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     733                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
     734                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     735                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    736736                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    737737                                                }

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

    r9731 r9733  
    3535                x2d                = modelfield('default',NaN,'marshall',false);
    3636                y2d                = modelfield('default',NaN,'marshall',false);
     37                elements            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
     38                edges               = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    3739        end
    3840        methods

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

    r9732 r9733  
    4343
    4444                 %FIXME: all other fields should belong to other classes
    45                  elements            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    4645                 x                   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    4746                 y                   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    4847                 z                   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    49                  edges               = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    5048
    5149                 %}}}
    … …  
    207205                         if isfield(structmd,'ishutter'), md.flowequation.ishutter=structmd.ishutter; end
    208206                         if isfield(structmd,'isstokes'), md.flowequation.isstokes=structmd.isstokes; end
    209                          if isfield(structmd,'elements_type'), md.flowequation.element_equation=structmd.elements_type; end
     207                         if isfield(structmd,'elements_type'), md.flowequation.element_equation=structmd.mesh.elements_type; end
    210208                         if isfield(structmd,'vertices_type'), md.flowequation.vertex_equation=structmd.vertices_type; end
    211209                         if isfield(structmd,'eps_rel'), md.steadystate.reltol=structmd.eps_rel; end
    … …  
    262260                         if isfield(structmd,'nodeonsurface'), md.mesh.vertexonsurface=structmd.nodeonsurface; end
    263261                         if isfield(structmd,'nodeonbed'), md.mesh.vertexonbed=structmd.nodeonbed; end
    264                          if isfield(structmd,'elements2d'), md.mesh.elements2d=structmd.elements2d; end
     262                         if isfield(structmd,'elements2d'), md.mesh.elements2d=structmd.mesh.elements2d; end
    265263                         if isfield(structmd,'y2d'), md.mesh.y2d=structmd.y2d; end
    266264                         if isfield(structmd,'x2d'), md.mesh.x2d=structmd.x2d; end
     265                         if isfield(structmd,'elements'), md.mesh.elements=structmd.mesh.elements; end
     266                         if isfield(structmd,'edges'), md.mesh.edges=structmd.mesh.edges; end
    267267
    268268                         %Field changes
    … …  
    295295                                 pos=find(structmd.pressureload(:,end)==119); md.pressureload(pos,end)=2;
    296296                         end
    297                          if (structmd.elements_type(end,end)>100),
    298                                  pos=find(structmd.elements_type==59); md.elements_type(pos,end)=0;
    299                                  pos=find(structmd.elements_type==55); md.elements_type(pos,end)=1;
    300                                  pos=find(structmd.elements_type==56); md.elements_type(pos,end)=2;
    301                                  pos=find(structmd.elements_type==60); md.elements_type(pos,end)=3;
    302                                  pos=find(structmd.elements_type==62); md.elements_type(pos,end)=4;
    303                                  pos=find(structmd.elements_type==57); md.elements_type(pos,end)=5;
    304                                  pos=find(structmd.elements_type==58); md.elements_type(pos,end)=6;
    305                                  pos=find(structmd.elements_type==61); md.elements_type(pos,end)=7;
     297                         if (structmd.mesh.elements_type(end,end)>100),
     298                                 pos=find(structmd.mesh.elements_type==59); md.mesh.elements_type(pos,end)=0;
     299                                 pos=find(structmd.mesh.elements_type==55); md.mesh.elements_type(pos,end)=1;
     300                                 pos=find(structmd.mesh.elements_type==56); md.mesh.elements_type(pos,end)=2;
     301                                 pos=find(structmd.mesh.elements_type==60); md.mesh.elements_type(pos,end)=3;
     302                                 pos=find(structmd.mesh.elements_type==62); md.mesh.elements_type(pos,end)=4;
     303                                 pos=find(structmd.mesh.elements_type==57); md.mesh.elements_type(pos,end)=5;
     304                                 pos=find(structmd.mesh.elements_type==58); md.mesh.elements_type(pos,end)=6;
     305                                 pos=find(structmd.mesh.elements_type==61); md.mesh.elements_type(pos,end)=7;
    306306                         end
    307307                         if isfield(structmd,'rheology_law') & isnumeric(structmd.rheology_law),

  • issm/trunk/src/m/kml/kml_mesh_elem.m

    r9725 r9733  
    8080        display('Averaging nodal data to element data.');
    8181        edata=zeros(1,md.mesh.numberofelements);
    82         for i=1:size(md.elements,1)
    83             for j=1:size(md.elements,2)
    84                 edata(i)=edata(i)+ndata(md.elements(i,j));
     82        for i=1:size(md.mesh.elements,1)
     83            for j=1:size(md.mesh.elements,2)
     84                edata(i)=edata(i)+ndata(md.mesh.elements(i,j));
    8585            end
    86             edata(i)=edata(i)/size(md.elements,2);
     86            edata(i)=edata(i)/size(md.mesh.elements,2);
    8787        end
    8888    else
    … …  
    126126    md.mesh.numberofelements,md.mesh.numberofvertices);
    127127% see matlab_oop, "initializing a handle object array"
    128 %kfold.feature   ={repmat(kml_placemark(),1,size(md.elements,1))};
    129 kfeat(size(md.elements,1))=kml_placemark();
     128%kfold.feature   ={repmat(kml_placemark(),1,size(md.mesh.elements,1))};
     129kfeat(size(md.mesh.elements,1))=kml_placemark();
    130130kfold.feature={kfeat};
    131131
    132132%  write each element as a polygon placemark
    133133
    134 disp(['Writing ' num2str(size(md.elements,1)) ' tria elements as KML polygons.']);
    135 for i=1:size(md.elements,1)
     134disp(['Writing ' num2str(size(md.mesh.elements,1)) ' tria elements as KML polygons.']);
     135for i=1:size(md.mesh.elements,1)
    136136    kplace=kml_placemark();
    137137    kplace.name      =sprintf('Element %d',i);
    … …  
    157157
    158158    kring=kml_linearring();
    159     kring.coords    =zeros(size(md.elements,2)+1,3);
     159    kring.coords    =zeros(size(md.mesh.elements,2)+1,3);
    160160
    161     for j=1:size(md.elements,2)
    162         kring.coords(j,:)=[md.mesh.long(md.elements(i,j)) md.mesh.lat(md.elements(i,j)) alt];
     161    for j=1:size(md.mesh.elements,2)
     162        kring.coords(j,:)=[md.mesh.long(md.mesh.elements(i,j)) md.mesh.lat(md.mesh.elements(i,j)) alt];
    163163    end
    164164    kring.coords(end,:)=kring.coords(1,:);

  • issm/trunk/src/m/kml/kml_mesh_write.m

    r9725 r9733  
    8686        display('Averaging nodal data to element data.');
    8787        edata=zeros(1,md.mesh.numberofelements);
    88         for i=1:size(md.elements,1)
    89             for j=1:size(md.elements,2)
    90                 edata(i)=edata(i)+ndata(md.elements(i,j));
     88        for i=1:size(md.mesh.elements,1)
     89            for j=1:size(md.mesh.elements,2)
     90                edata(i)=edata(i)+ndata(md.mesh.elements(i,j));
    9191            end
    92             edata(i)=edata(i)/size(md.elements,2);
     92            edata(i)=edata(i)/size(md.mesh.elements,2);
    9393        end
    9494    else

  • issm/trunk/src/m/kml/kml_part_edges.m

    r9725 r9733  
    8181        display('Averaging nodal data to element data.');
    8282        edata=zeros(1,md.mesh.numberofelements);
    83         for i=1:size(md.elements,1)
    84             for j=1:size(md.elements,2)
    85                 edata(i)=edata(i)+ndata(md.elements(i,j));
     83        for i=1:size(md.mesh.elements,1)
     84            for j=1:size(md.mesh.elements,2)
     85                edata(i)=edata(i)+ndata(md.mesh.elements(i,j));
    8686            end
    87             edata(i)=edata(i)/size(md.elements,2);
     87            edata(i)=edata(i)/size(md.mesh.elements,2);
    8888        end
    8989    else
    … …  
    129129
    130130    disp(['Writing ' num2str(md.qmu.numberofpartitions) ' partitions as KML linestrings.']);
    131     epart=md.qmu.partition(md.elements)+1;
     131    epart=md.qmu.partition(md.mesh.elements)+1;
    132132    if exist('ndata','var') || exist('edata','var')
    133133        pdata=zeros(1,md.qmu.numberofpartitions);
    … …  
    148148        end
    149149        irow=unique(irow);
    150         elemp=md.elements(irow,:);
     150        elemp=md.mesh.elements(irow,:);
    151151        epartp=epart(irow,:);
    152152        nodeconp=nodeconnectivity(elemp,md.mesh.numberofvertices);

  • issm/trunk/src/m/kml/kml_part_elems.m

    r9725 r9733  
    8181        display('Averaging nodal data to element data.');
    8282        edata=zeros(1,md.mesh.numberofelements);
    83         for i=1:size(md.elements,1)
    84             for j=1:size(md.elements,2)
    85                 edata(i)=edata(i)+ndata(md.elements(i,j));
    86             end
    87             edata(i)=edata(i)/size(md.elements,2);
     83        for i=1:size(md.mesh.elements,1)
     84            for j=1:size(md.mesh.elements,2)
     85                edata(i)=edata(i)+ndata(md.mesh.elements(i,j));
     86            end
     87            edata(i)=edata(i)/size(md.mesh.elements,2);
    8888        end
    8989    else
    … …  
    129129
    130130    disp(['Writing ' num2str(md.qmu.numberofpartitions) ' partitions as KML polygons.']);
    131     epart=md.qmu.partition(md.elements)+1;
     131    epart=md.qmu.partition(md.mesh.elements)+1;
    132132    if exist('ndata','var') || exist('edata','var')
    133133        pdata=zeros(1,md.qmu.numberofpartitions);
    … …  
    146146        end
    147147        irow=unique(irow);
    148         elem=md.elements(irow,:);
     148        elem=md.mesh.elements(irow,:);
    149149
    150150%  determine the data to be used for the colors (if any)

  • issm/trunk/src/m/kml/kml_part_flagedges.m

    r9714 r9733  
    7474if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    7575    md.qmu.numberofpartitions
    76     [latseg,lonseg]=flagedges(md.elements,md.mesh.lat,md.mesh.long,md.qmu.partition);
     76    [latseg,lonseg]=flagedges(md.mesh.elements,md.mesh.lat,md.mesh.long,md.qmu.partition);
    7777    kfold=kml_folder();
    7878    kfold.name      ='Partition Segments';

  • issm/trunk/src/m/kml/kml_partitions.m

    r9725 r9733  
    8282        display('Averaging nodal data to element data.');
    8383        edata=zeros(1,md.mesh.numberofelements);
    84         for i=1:size(md.elements,1)
    85             for j=1:size(md.elements,2)
    86                 edata(i)=edata(i)+ndata(md.elements(i,j));
     84        for i=1:size(md.mesh.elements,1)
     85            for j=1:size(md.mesh.elements,2)
     86                edata(i)=edata(i)+ndata(md.mesh.elements(i,j));
    8787            end
    88             edata(i)=edata(i)/size(md.elements,2);
     88            edata(i)=edata(i)/size(md.mesh.elements,2);
    8989        end
    9090    else
    … …  
    130130
    131131    disp(['Writing ' num2str(md.qmu.numberofpartitions) ' partitions as KML polygons.']);
    132     epart=md.qmu.partition(md.elements)+1;
     132    epart=md.qmu.partition(md.mesh.elements)+1;
    133133    if exist('ndata','var') || exist('edata','var')
    134134        pdata=zeros(1,md.qmu.numberofpartitions);
    … …  
    149149        end
    150150        irow=unique(irow);
    151         elemp=md.elements(irow,:);
     151        elemp=md.mesh.elements(irow,:);
    152152        epartp=epart(irow,:);
    153153        nodeconp=nodeconnectivity(elemp,md.mesh.numberofvertices);

  • issm/trunk/src/m/kml/kml_unsh_edges.m

    r9714 r9733  
    7474if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    7575    md.qmu.numberofpartitions
    76     [edgeadj]=edgeadjacency(md.elements,md.nodeconnectivity);
     76    [edgeadj]=edgeadjacency(md.mesh.elements,md.nodeconnectivity);
    7777    [icol,irow]=find(edgeadj'==0);
    7878    edgeuns=zeros(length(irow),2);
    7979    for i=1:length(irow)
    80         edgeuns(i,1)=md.elements(irow(i),icol(i));
    81         edgeuns(i,2)=md.elements(irow(i),mod(icol(i),size(md.elements,2))+1);
     80        edgeuns(i,1)=md.mesh.elements(irow(i),icol(i));
     81        edgeuns(i,2)=md.mesh.elements(irow(i),mod(icol(i),size(md.mesh.elements,2))+1);
    8282    end
    8383    kfold=kml_folder();

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

    r9725 r9733  
    3333                end
    3434                %ok, flag elements and nodes
    35                 [vertexondomain elementondomain]=ContourToMesh(md.elements(:,1:3),md.x,md.y,domain,'element and node',2);
     35                [vertexondomain elementondomain]=ContourToMesh(md.mesh.elements(:,1:3),md.x,md.y,domain,'element and node',2);
    3636        end
    3737        if invert,
    … …  
    5454%now, make sure all elements on water have nodes that are spc'd, otherwise, we'll get a singular problem.
    5555pos=find(~md.mask.elementonwater);
    56 numpos=unique(md.elements(pos,:));
     56numpos=unique(md.mesh.elements(pos,:));
    5757nodes=setdiff(1:1:md.mesh.numberofvertices,numpos);
    5858md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes);

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

    r9725 r9733  
    3333                end
    3434                %ok, flag elements and nodes
    35                 [vertexondomain elementondomain]=ContourToMesh(md.elements(:,1:3),md.x,md.y,domain,'element and node',2);
     35                [vertexondomain elementondomain]=ContourToMesh(md.mesh.elements(:,1:3),md.x,md.y,domain,'element and node',2);
    3636        end
    3737        if invert,
    … …  
    5454%now, make sure all elements on water have nodes that are spc'd, otherwise, we'll get a singular problem.
    5555pos=find(~md.mask.elementonwater);
    56 numpos=unique(md.elements(pos,:));
     56numpos=unique(md.mesh.elements(pos,:));
    5757nodes=setdiff(1:1:md.mesh.numberofvertices,numpos);
    5858md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes);

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

    r9641 r9733  
    88%get nodes on ice sheet and on ice shelf
    99pos_shelf=find(~md.mask.vertexongroundedice);
    10 pos_GL=intersect(unique(md.elements(find(md.mask.elementongroundedice),:)),unique(md.elements(find(md.mask.elementonfloatingice),:)));
     10pos_GL=intersect(unique(md.mesh.elements(find(md.mask.elementongroundedice),:)),unique(md.mesh.elements(find(md.mask.elementonfloatingice),:)));
    1111
    1212for i=1:length(pos_shelf)

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

    r9731 r9733  
    1515        md.x=md.mesh.x2d;
    1616        md.y=md.mesh.y2d;
    17         md.elements=md.mesh.elements2d;
     17        md.mesh.elements=md.mesh.elements2d;
    1818end
    1919
    … …  
    2727
    2828%average x and y over elements:
    29 x_elem=md.x(md.elements)*[1;1;1]/3;
    30 y_elem=md.y(md.elements)*[1;1;1]/3;
     29x_elem=md.x(md.mesh.elements)*[1;1;1]/3;
     30y_elem=md.y(md.mesh.elements)*[1;1;1]/3;
    3131
    3232while 1,

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

    r9731 r9733  
    8282
    8383        %Interpolation of data on specified points
    84         data_interp=InterpFromMeshToMesh2d(md.elements,md.x,md.y,data,X,Y);
     84        data_interp=InterpFromMeshToMesh2d(md.mesh.elements,md.x,md.y,data,X,Y);
    8585        %data_interp=griddata(md.x,md.y,data,X,Y);
    8686
    … …  
    120120
    121121        %Interpolation of data on specified points
    122         data_interp=InterpFromMeshToMesh3d(md.elements,md.x,md.y,md.z,data,X3,Y3,Z3,NaN);
     122        data_interp=InterpFromMeshToMesh3d(md.mesh.elements,md.x,md.y,md.z,data,X3,Y3,Z3,NaN);
    123123
    124124        %build outputs

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

    r9691 r9733  
    2424%get nodes on ice sheet and on ice shelf
    2525pos_shelf=find(~md.mask.vertexongroundedice);
    26 pos_GL=intersect(unique(md.elements(find(md.mask.elementongroundedice),:)),unique(md.elements(find(md.mask.elementonfloatingice),:)));
     26pos_GL=intersect(unique(md.mesh.elements(find(md.mask.elementongroundedice),:)),unique(md.mesh.elements(find(md.mask.elementonfloatingice),:)));
    2727debug=(length(pos_shelf)>50000);
    2828

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

    r9725 r9733  
    77nnz=0;
    88for i=1:md.mesh.numberofvertices,
    9         nnz=nnz+length(find(md.elements==i));
     9        nnz=nnz+length(find(md.mesh.elements==i));
    1010end
    1111conn=nnz/md.mesh.numberofvertices;

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

    r9725 r9733  
    2525
    2626%load some variables (it is much faster if the variab;es are loaded from md once for all)
    27 index=md.elements;
     27index=md.mesh.elements;
    2828numberofnodes=md.mesh.numberofvertices;
    2929numberofelements=md.mesh.numberofelements;

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

    r9732 r9733  
    271271        else
    272272                bamg_mesh.Vertices=[md.x md.y ones(md.mesh.numberofvertices,1)];
    273                 bamg_mesh.Triangles=[md.elements ones(md.mesh.numberofelements,1)];
     273                bamg_mesh.Triangles=[md.mesh.elements ones(md.mesh.numberofelements,1)];
    274274        end
    275275
    … …  
    319319md.x=bamgmesh_out.Vertices(:,1);
    320320md.y=bamgmesh_out.Vertices(:,2);
    321 md.elements=bamgmesh_out.Triangles(:,1:3);
    322 md.edges=bamgmesh_out.IssmEdges;
     321md.mesh.elements=bamgmesh_out.Triangles(:,1:3);
     322md.mesh.edges=bamgmesh_out.IssmEdges;
    323323md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3);
    324324md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4);
    … …  
    326326%Fill in rest of fields:
    327327md.mesh.dimension=2;
    328 md.mesh.numberofelements=size(md.elements,1);
     328md.mesh.numberofelements=size(md.mesh.elements,1);
    329329md.mesh.numberofvertices=length(md.x);
    330 md.mesh.numberofedges=size(md.edges,1);
     330md.mesh.numberofedges=size(md.mesh.edges,1);
    331331md.z=zeros(md.mesh.numberofvertices,1);
    332332md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    … …  
    340340
    341341%Check for orphan
    342 if any(~ismember(1:md.mesh.numberofvertices,sort(unique(md.elements(:)))))
     342if any(~ismember(1:md.mesh.numberofvertices,sort(unique(md.mesh.elements(:)))))
    343343        error('Output mesh has orphans. Decrease MaxCornerAngle to prevent outside points (ex: 0.01)');
    344344end

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

    r9725 r9733  
    1414
    1515for n=1:md.mesh.numberofelements
    16         X=inv([md.x(md.elements(n,:)) md.y(md.elements(n,:)) ones(3,1)]);
     16        X=inv([md.x(md.mesh.elements(n,:)) md.y(md.mesh.elements(n,:)) ones(3,1)]);
    1717        alpha(n,:)=X(1,:);
    1818        beta(n,:)=X(2,:);
    … …  
    2424
    2525summation=[1;1;1];
    26 hux=(hu(md.elements).*alpha)*summation;
    27 hvy=(hv(md.elements).*beta)*summation;
     26hux=(hu(md.mesh.elements).*alpha)*summation;
     27hvy=(hv(md.mesh.elements).*beta)*summation;
    2828
    29 uelem=md.initialization.vx(md.elements)*summation/3;
    30 velem=md.initialization.vy(md.elements)*summation/3;
     29uelem=md.initialization.vx(md.mesh.elements)*summation/3;
     30velem=md.initialization.vy(md.mesh.elements)*summation/3;
    3131
    32 dbdx=(md.geometry.bed(md.elements).*alpha)*summation;
    33 dbdy=(md.geometry.bed(md.elements).*beta)*summation;
     32dbdx=(md.geometry.bed(md.mesh.elements).*alpha)*summation;
     33dbdy=(md.geometry.bed(md.mesh.elements).*beta)*summation;
    3434
    3535wb=-md.materials.rho_ice/md.materials.rho_water*(hux+hvy)+uelem.*dbdx+velem.*dbdy;

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

    r9731 r9733  
    99        numberofelements=md.mesh.numberofelements;
    1010        numberofnodes=md.mesh.numberofvertices;
    11         index=md.elements;
     11        index=md.mesh.elements;
    1212        x=md.x; y=md.y;
    1313else

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

    r9731 r9733  
    9595md.mesh.numberofvertices=md.mesh.numberofvertices2d;
    9696md.mesh.numberofelements=md.mesh.numberofelements2d;
    97 md.elements=md.mesh.elements2d;
     97md.mesh.elements=md.mesh.elements2d;
    9898
    9999%Keep a trace of lower and upper nodes

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

    r9729 r9733  
    3636%Computing connectivity
    3737if size(md.mesh.vertexconnectivity,1)~=md.mesh.numberofvertices,
    38         md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     38        md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
    3939end
    4040if size(md.mesh.elementconnectivity,1)~=md.mesh.numberofelements,
    41         md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     41        md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    4242end
    4343
    … …  
    4747        if isfile,
    4848                %get flag list of elements and nodes inside the contour
    49                 nodein=ContourToMesh(md.elements,md.x,md.y,file,'node',1);
    50                 elemin=(sum(nodein(md.elements),2)==size(md.elements,2));
     49                nodein=ContourToMesh(md.mesh.elements,md.x,md.y,file,'node',1);
     50                elemin=(sum(nodein(md.mesh.elements),2)==size(md.mesh.elements,2));
    5151                %modify element connectivity
    5252                elemout=find(~elemin);
    … …  
    6060                pos=find(flags);
    6161                elemin(pos)=1;
    62                 nodein(md.elements(pos,:))=1;
     62                nodein(md.mesh.elements(pos,:))=1;
    6363
    6464                %modify element connectivity
    … …  
    8787        els2=mesh.elementconnectivity(el1,find(mesh.elementconnectivity(el1,:)));
    8888        if length(els2)>1,
    89                 flag=intersect(md.elements(els2(1),:),md.elements(els2(2),:));
    90                 nods1=md.elements(el1,:);
     89                flag=intersect(md.mesh.elements(els2(1),:),md.mesh.elements(els2(2),:));
     90                nods1=md.mesh.elements(el1,:);
    9191                nods1(find(nods1==flag))=[];
    9292                segments(count,:)=[nods1 el1];
    9393
    94                 ord1=find(nods1(1)==md.elements(el1,:));
    95                 ord2=find(nods1(2)==md.elements(el1,:));
     94                ord1=find(nods1(1)==md.mesh.elements(el1,:));
     95                ord2=find(nods1(2)==md.mesh.elements(el1,:));
    9696
    9797                %swap segment nodes if necessary
    … …  
    104104                count=count+1;
    105105        else
    106                 nods1=md.elements(el1,:);
    107                 flag=setdiff(nods1,md.elements(els2,:));
     106                nods1=md.mesh.elements(el1,:);
     107                flag=setdiff(nods1,md.mesh.elements(els2,:));
    108108                for j=1:3,
    109109                        nods=nods1; nods(j)=[];
    110110                        if any(ismember(flag,nods)),
    111111                                segments(count,:)=[nods el1];
    112                                 ord1=find(nods(1)==md.elements(el1,:));
    113                                 ord2=find(nods(2)==md.elements(el1,:));
     112                                ord1=find(nods(1)==md.mesh.elements(el1,:));
     113                                ord2=find(nods(2)==md.mesh.elements(el1,:));
    114114                                if ( (ord1==1 & ord2==2) | (ord1==2 & ord2==3) | (ord1==3 & ord2==1) ),
    115115                                        temp=segments(count,1);

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

    r9725 r9733  
    2222
    2323%get flag list of elements and nodes inside the contour
    24 nodein=ContourToMesh(md.elements,md.x,md.y,file,'node',1);
    25 elemin=(sum(nodein(md.elements),2)==size(md.elements,2));
     24nodein=ContourToMesh(md.mesh.elements,md.x,md.y,file,'node',1);
     25elemin=(sum(nodein(md.mesh.elements),2)==size(md.mesh.elements,2));
    2626
    2727%conputing Mass flux
    … …  
    3636flux = - md.materials.rho_ice*sum(L.*H.*(vx.*nx+vy.*ny)); %outflux is negative!
    3737disp(['mass outflux on ' file ' = ' num2str(-flux/10^9) ' Gt/yr']);
    38 areas=GetAreas(md.elements,md.x,md.y);
     38areas=GetAreas(md.mesh.elements,md.x,md.y);
    3939dhdt=flux/(sum(areas(find(elemin)))*md.materials.rho_ice);
    4040disp(['dhdt on ' file ' (Flux  method) = ' num2str(dhdt) ' m/yr']);

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

    r9731 r9733  
    88        numberofelements=md.mesh.numberofelements;
    99        numberofnodes=md.mesh.numberofvertices;
    10         index=md.elements;
     10        index=md.mesh.elements;
    1111        x=md.x; y=md.y; z=md.z;
    1212else

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

    r9691 r9733  
    1212
    1313%Average thickness over elements
    14 thickness_bar=(md.geometry.thickness(md.elements(:,1))+md.geometry.thickness(md.elements(:,2))+md.geometry.thickness(md.elements(:,3)))/3;
     14thickness_bar=(md.geometry.thickness(md.mesh.elements(:,1))+md.geometry.thickness(md.mesh.elements(:,2))+md.geometry.thickness(md.mesh.elements(:,3)))/3;
    1515
    1616px=md.materials.rho_ice*md.constants.g*thickness_bar.*sx;

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

    r9731 r9733  
    8282elements3d=[];
    8383for i=1:numlayers-1,
    84         elements3d=[elements3d;[md.elements+(i-1)*md.mesh.numberofvertices md.elements+i*md.mesh.numberofvertices]]; %Create the elements of the 3d mesh for the non extruded part
     84        elements3d=[elements3d;[md.mesh.elements+(i-1)*md.mesh.numberofvertices md.mesh.elements+i*md.mesh.numberofvertices]]; %Create the elements of the 3d mesh for the non extruded part
    8585end
    8686number_el3d=size(elements3d,1); %number of 3d nodes for the non extruded part of the mesh
    … …  
    105105md.mesh.x2d=md.x;
    106106md.mesh.y2d=md.y;
    107 md.mesh.elements2d=md.elements;
     107md.mesh.elements2d=md.mesh.elements;
    108108md.mesh.numberofelements2d=md.mesh.numberofelements;
    109109md.mesh.numberofvertices2d=md.mesh.numberofvertices;
    … …  
    113113
    114114%Build global 3d mesh
    115 md.elements=elements3d;
     115md.mesh.elements=elements3d;
    116116md.x=x3d;
    117117md.y=y3d;

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

    r9714 r9733  
    4949
    5050%regrid to lat,long grid
    51 [x_m,y_m,field]=InterpFromMeshToGrid(md.elements,md.mesh.long,md.mesh.lat,field,minlong,maxlat,posting,posting,nlines,ncols,NaN);
     51[x_m,y_m,field]=InterpFromMeshToGrid(md.mesh.elements,md.mesh.long,md.mesh.lat,field,minlong,maxlat,posting,posting,nlines,ncols,NaN);
    5252field=flipud(field);
    5353

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

    r9725 r9733  
    2626%initialization
    2727numberofelements=md.mesh.numberofelements;
    28 index=md.elements;
     28index=md.mesh.elements;
    2929summation=[1;1;1];
    3030directionsstress=zeros(numberofelements,4);

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

    r9729 r9733  
    1919                error(' ''mesh.elementconnectivity'' option does not have thge right size.');
    2020        else
    21                 mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     21                mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    2222        end
    2323end
    … …  
    4343
    4444                %get nodes of el1
    45                 nods1=md.elements(el1,:);
     45                nods1=md.mesh.elements(el1,:);
    4646
    4747                %find the common vertices to the two elements connected to el1 (1 or 2)
    48                 flag=intersect(md.elements(els2(1),:),md.elements(els2(2),:));
     48                flag=intersect(md.mesh.elements(els2(1),:),md.mesh.elements(els2(2),:));
    4949
    5050                %get the vertices on the boundary and build segment
    … …  
    5353
    5454                %swap segment nodes if necessary
    55                 ord1=find(nods1(1)==md.elements(el1,:));
    56                 ord2=find(nods1(2)==md.elements(el1,:));
     55                ord1=find(nods1(1)==md.mesh.elements(el1,:));
     56                ord2=find(nods1(2)==md.mesh.elements(el1,:));
    5757                if ( (ord1==1 & ord2==2) | (ord1==2 & ord2==3) | (ord1==3 & ord2==1) ),
    5858                        temp=segments(count,1);
    … …  
    6666        else
    6767                %get nodes of el1
    68                 nods1=md.elements(el1,:);
     68                nods1=md.mesh.elements(el1,:);
    6969
    7070                %find the vertex  the el1 to not share with els2
    71                 flag=setdiff(nods1,md.elements(els2,:));
     71                flag=setdiff(nods1,md.mesh.elements(els2,:));
    7272
    7373                for j=1:3,
    … …  
    7878
    7979                                %swap segment nodes if necessary
    80                                 ord1=find(nods(1)==md.elements(el1,:));
    81                                 ord2=find(nods(2)==md.elements(el1,:));
     80                                ord1=find(nods(1)==md.mesh.elements(el1,:));
     81                                ord2=find(nods(2)==md.mesh.elements(el1,:));
    8282                                if ( (ord1==1 & ord2==2) | (ord1==2 & ord2==3) | (ord1==3 & ord2==1) ),
    8383                                        temp=segments(count,1);

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

    r9725 r9733  
    2424
    2525%initialization
    26 index=md.elements;
     26index=md.mesh.elements;
    2727numberofnodes=md.mesh.numberofvertices;
    2828numberofelements=md.mesh.numberofelements;

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

    r9725 r9733  
    9797        %set nodeonwater field
    9898        if ~strcmp(groundeddomain,'N/A'),
    99                 nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);
     99                nodeground=ContourToMesh(md.mesh.elements,md.x,md.y,groundeddomain,'node',2);
    100100                md.nodeonwater=ones(md.mesh.numberofvertices,1);
    101101                md.nodeonwater(find(nodeground))=0;

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

    r9732 r9733  
    1414        x=md.x;
    1515        y=md.y;
    16         index=md.elements;
     16        index=md.mesh.elements;
    1717else
    1818        x=varargin{1};
    … …  
    3030md.x=bamgmesh_out.Vertices(:,1);
    3131md.y=bamgmesh_out.Vertices(:,2);
    32 md.elements=bamgmesh_out.Triangles(:,1:3);
    33 md.edges=bamgmesh_out.IssmEdges;
     32md.mesh.elements=bamgmesh_out.Triangles(:,1:3);
     33md.mesh.edges=bamgmesh_out.IssmEdges;
    3434md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3);
    3535md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4);
    … …  
    3737%Fill in rest of fields:
    3838md.mesh.dimension=2;
    39 md.mesh.numberofelements=size(md.elements,1);
     39md.mesh.numberofelements=size(md.mesh.elements,1);
    4040md.mesh.numberofvertices=length(md.x);
    41 md.mesh.numberofedges=size(md.edges,1);
     41md.mesh.numberofedges=size(md.mesh.edges,1);
    4242md.z=zeros(md.mesh.numberofvertices,1);
    4343md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);

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

    r9451 r9733  
    3535
    3636%Read domainame file into a matlab array (x,y):
    37 refinearea=ContourToMesh(md.elements,md.x,md.y,domainname,'element',1);
    38 aires=GetAreas(md.elements,md.x,md.y);
     37refinearea=ContourToMesh(md.mesh.elements,md.x,md.y,domainname,'element',1);
     38aires=GetAreas(md.mesh.elements,md.x,md.y);
    3939
    4040%flags areas within the domain

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

    r9729 r9733  
    2525%Mesh using TriMeshNoDensity
    2626if strcmp(riftname,''),
    27         [md.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMeshNoDensity(domainname);
     27        [md.mesh.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMeshNoDensity(domainname);
    2828else
    2929        [elements,x,y,segments,segmentmarkers]=TriMeshNoDensity(domainname,riftname);
    … …  
    4949        md.x=x;
    5050        md.y=y;
    51         md.elements=elements;
     51        md.mesh.elements=elements;
    5252        md.mesh.segments=segments;
    5353        md.mesh.segmentmarkers=segmentmarkers;
    … …  
    5555
    5656%Fill in rest of fields:
    57 md.mesh.numberofelements=length(md.elements);
     57md.mesh.numberofelements=length(md.mesh.elements);
    5858md.mesh.numberofvertices=length(md.x);
    5959md.z=zeros(md.mesh.numberofvertices,1);
    … …  
    6565
    6666%Now, build the connectivity tables for this mesh.
    67 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    68 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     67md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     68md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    6969
    7070%type of model

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

    r9729 r9733  
    1616
    1717%Refine using TriMeshRefine
    18 [md.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMeshRefine(md.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers,areas,'yes');
     18[md.mesh.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMeshRefine(md.mesh.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers,areas,'yes');
    1919
    2020%Fill in rest of fields:
    21 md.mesh.numberofelements=length(md.elements);
     21md.mesh.numberofelements=length(md.mesh.elements);
    2222md.mesh.numberofvertices=length(md.x);
    2323md.z=zeros(md.mesh.numberofvertices,1);
    … …  
    2929
    3030%Now, build the connectivity tables for this mesh.
    31 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    32 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     31md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     32md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    3333
    3434%type of model

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

    r9729 r9733  
    8181        %set nodeonwater field
    8282        if ~strcmp(groundeddomain,'N/A'),
    83                 nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);
     83                nodeground=ContourToMesh(md.mesh.elements,md.x,md.y,groundeddomain,'node',2);
    8484                md.nodeonwater=ones(md.mesh.numberofvertices,1);
    8585                md.nodeonwater(find(nodeground))=0;
    … …  
    9595        %rifts, because the segments are used in YamsCall to freeze the rifts elements during refinement.
    9696        if md.rifts.numrifts,
    97                 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    98                 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     97                md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     98                md.mesh.elementconnectivity=ElementConnectivity(md.mesh.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.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    109 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     108md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     109md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    110110
    111111%recreate segments
    … …  
    120120md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    121121if ~strcmp(groundeddomain,'N/A'),
    122         nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);
     122        nodeground=ContourToMesh(md.mesh.elements,md.x,md.y,groundeddomain,'node',2);
    123123        md.nodeonwater=ones(md.mesh.numberofvertices,1);
    124124        md.nodeonwater(find(nodeground))=0;

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

    r9725 r9733  
    2020
    2121%update all fields
    22 md.elements=tnewnodes(md.elements(newelements,:));
     22md.mesh.elements=tnewnodes(md.mesh.elements(newelements,:));
    2323md.mesh.segments=[tnewnodes(md.mesh.segments(:,1)) tnewnodes(md.mesh.segments(:,2)) tnewelements(md.mesh.segments(:,3))];
    2424md.x=md.x(newnodes);

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

    r9729 r9733  
    5656       
    5757        %plug md2 mesh into md mesh:
    58         [md.elements,md.x,md.y,md.z,md.mesh.numberofelements,md.mesh.numberofvertices,elconv,nodeconv,elconv2,nodeconv2]=meshplug(md.elements,md.x,md.y,md.z,...
    59                                                                 md2.elements,md2.x,md2.y,md2.z,md2.extractednodes,md2.extractedelements,domain_index);
     58        [md.mesh.elements,md.x,md.y,md.z,md.mesh.numberofelements,md.mesh.numberofvertices,elconv,nodeconv,elconv2,nodeconv2]=meshplug(md.mesh.elements,md.x,md.y,md.z,...
     59                                                                md2.mesh.elements,md2.x,md2.y,md2.z,md2.extractednodes,md2.extractedelements,domain_index);
    6060
    6161        %update md2 rifts using elconv and nodeconv, and plug them into md:
    … …  
    8787
    8888%Now, build the connectivity tables for this mesh.
    89 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    90 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     89md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     90md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    9191
    9292%type of model

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

    r9729 r9733  
    1212       
    1313        %first, flag nodes that belong to the domain outline
    14         flags=ContourToMesh(md.elements,md.x,md.y,domainoutline,'node',0);
     14        flags=ContourToMesh(md.mesh.elements,md.x,md.y,domainoutline,'node',0);
    1515
    1616        rift=md.rifts.riftstruct(i);
    … …  
    4343                while  flags(B), %as long as B does not belong to the domain outline, keep looking.
    4444                        %detect elements on edge A,B:
    45                         edgeelements=ElementsFromEdge(md.elements,A,B);
     45                        edgeelements=ElementsFromEdge(md.mesh.elements,A,B);
    4646                        %rule out those we already detected
    4747                        already_detected=ismember(edgeelements,elements);
    … …  
    5050                        elements=[elements;nextelement];
    5151                        %new B:
    52                         B=md.elements(nextelement,find(~ismember(md.elements(nextelement,:),[A B])));
     52                        B=md.mesh.elements(nextelement,find(~ismember(md.mesh.elements(nextelement,:),[A B])));
    5353                end
    5454               
    … …  
    6161               
    6262                %replace tip in elements
    63                 newelements=md.elements(elements,:);
     63                newelements=md.mesh.elements(elements,:);
    6464                pos=find(newelements==tip);
    6565                newelements(pos)=num;
    66                 md.elements(elements,:)=newelements;
     66                md.mesh.elements(elements,:)=newelements;
    6767                md.rifts.riftstruct(i).tips=[md.rifts.riftstruct(i).tips num];
    6868
    … …  
    7373                        pos=find(md.mesh.segments(segment_index,1:2)~=tip);
    7474                        other_node=md.mesh.segments(segment_index,pos);
    75                         if ~isconnected(md.elements,other_node,tip),
     75                        if ~isconnected(md.mesh.elements,other_node,tip),
    7676                                pos=find(md.mesh.segments(segment_index,1:2)==tip);
    7777                                md.mesh.segments(segment_index,pos)=num;
    … …  
    8383
    8484%Fill in rest of fields:
    85 md.mesh.numberofelements=length(md.elements);
     85md.mesh.numberofelements=length(md.mesh.elements);
    8686md.mesh.numberofvertices=length(md.x);
    8787md.z=zeros(md.mesh.numberofvertices,1);

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

    r9729 r9733  
    2525
    2626%Call MEX file
    27 [md.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers,md.rifts.riftstruct]=TriMeshProcessRifts(md.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers);
     27[md.mesh.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers,md.rifts.riftstruct]=TriMeshProcessRifts(md.mesh.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers);
    2828md.rifts
    2929md.rifts.riftstruct
    … …  
    3333
    3434%Fill in rest of fields:
    35 md.mesh.numberofelements=length(md.elements);
     35md.mesh.numberofelements=length(md.mesh.elements);
    3636md.mesh.numberofvertices=length(md.x);
    3737md.z=zeros(md.mesh.numberofvertices,1);
    … …  
    5151
    5252%In case we have rifts that open up the domain outline, we need to open them:
    53 flags=ContourToMesh(md.elements,md.x,md.y,domainoutline,'node',0);
     53flags=ContourToMesh(md.mesh.elements,md.x,md.y,domainoutline,'node',0);
    5454found=0;
    5555for i=1:md.rifts.numrifts,
    … …  
    6868
    6969%get elements that are not correctly oriented in the correct direction:
    70 aires=GetAreas(md.elements,md.x,md.y);
     70aires=GetAreas(md.mesh.elements,md.x,md.y);
    7171pos=find(aires<0);
    72 md.elements(pos,:)=[md.elements(pos,2) md.elements(pos,1) md.elements(pos,3)];
     72md.mesh.elements(pos,:)=[md.mesh.elements(pos,2) md.mesh.elements(pos,1) md.mesh.elements(pos,3)];

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

    r9729 r9733  
    3939%Mesh using TriMesh
    4040if strcmp(riftname,''),
    41         [md.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMesh(domainname,area,'yes');
     41        [md.mesh.elements,md.x,md.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMesh(domainname,area,'yes');
    4242else
    4343        [elements,x,y,segments,segmentmarkers]=TriMesh(domainname,riftname,area,'yes');
    … …  
    6363        md.x=x;
    6464        md.y=y;
    65         md.elements=elements;
     65        md.mesh.elements=elements;
    6666        md.mesh.segments=segments;
    6767        md.mesh.segmentmarkers=segmentmarkers;
    … …  
    6969
    7070%Fill in rest of fields:
    71 md.mesh.numberofelements=length(md.elements);
     71md.mesh.numberofelements=length(md.mesh.elements);
    7272md.mesh.numberofvertices=length(md.x);
    7373md.z=zeros(md.mesh.numberofvertices,1);
    … …  
    7979
    8080%Now, build the connectivity tables for this mesh.
    81 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    82 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     81md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     82md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    8383
    8484%type of model

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

    r9731 r9733  
    1010
    1111if md.mesh.dimension==2,
    12         elements=md.elements;
     12        elements=md.mesh.elements;
    1313        x=md.x;
    1414        y=md.y;

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

    r9731 r9733  
    3838%kick out all elements with 3 dirichlets
    3939spc_elem=find(~flag_elem);
    40 spc_node=sort(unique(md1.elements(spc_elem,:)));
     40spc_node=sort(unique(md1.mesh.elements(spc_elem,:)));
    4141flag=ones(md1.numberofnodes,1);
    4242flag(spc_node)=0;
    43 pos=find(sum(flag(md1.elements),2)==0);
     43pos=find(sum(flag(md1.mesh.elements),2)==0);
    4444flag_elem(pos)=0;
    4545
    4646%extracted elements and nodes lists
    4747pos_elem=find(flag_elem);
    48 pos_node=sort(unique(md1.elements(pos_elem,:)));
     48pos_node=sort(unique(md1.mesh.elements(pos_elem,:)));
    4949
    5050%keep track of some fields
    … …  
    6363
    6464%renumber the elements (some node won't exist anymore)
    65 elements_1=md1.elements;
     65elements_1=md1.mesh.elements;
    6666elements_2=elements_1(pos_elem,:);
    6767elements_2(:,1)=Pnode(elements_2(:,1));
    … …  
    121121        md2.numberofelements=numberofelements2;
    122122        md2.numberofnodes=numberofnodes2;
    123         md2.elements=elements_2;
     123        md2.mesh.elements=elements_2;
    124124
    125125        %mesh.uppervertex mesh.lowervertex
    … …  
    161161
    162162        %Edges
    163         if size(md2.edges,2)>1, %do not use ~isnan because there are some NaNs...
     163        if size(md2.mesh.edges,2)>1, %do not use ~isnan because there are some NaNs...
    164164                %renumber first two columns
    165                 pos=find(~isnan(md2.edges(:,4)));
    166                 md2.edges(:  ,1)=Pnode(md2.edges(:,1));
    167                 md2.edges(:  ,2)=Pnode(md2.edges(:,2));
    168                 md2.edges(:  ,3)=Pelem(md2.edges(:,3));
    169                 md2.edges(pos,4)=Pelem(md2.edges(pos,4));
     165                pos=find(~isnan(md2.mesh.edges(:,4)));
     166                md2.mesh.edges(:  ,1)=Pnode(md2.mesh.edges(:,1));
     167                md2.mesh.edges(:  ,2)=Pnode(md2.mesh.edges(:,2));
     168                md2.mesh.edges(:  ,3)=Pelem(md2.mesh.edges(:,3));
     169                md2.mesh.edges(pos,4)=Pelem(md2.mesh.edges(pos,4));
    170170                %remove edges when the 2 vertices are not in the domain.
    171                 md2.edges=md2.edges(find(md2.edges(:,1) & md2.edges(:,2)),:);
     171                md2.mesh.edges=md2.mesh.edges(find(md2.mesh.edges(:,1) & md2.mesh.edges(:,2)),:);
    172172                %Replace all zeros by NaN in the last two columns;
    173                 pos=find(md2.edges(:,3)==0);
    174                 md2.edges(pos,3)=NaN;
    175                 pos=find(md2.edges(:,4)==0);
    176                 md2.edges(pos,4)=NaN;
     173                pos=find(md2.mesh.edges(:,3)==0);
     174                md2.mesh.edges(pos,3)=NaN;
     175                pos=find(md2.mesh.edges(:,4)==0);
     176                md2.mesh.edges(pos,4)=NaN;
    177177                %Invert NaN of the third column with last column (Also invert first two columns!!)
    178                 pos=find(isnan(md2.edges(:,3)));
    179                 md2.edges(pos,3)=md2.edges(pos,4);
    180                 md2.edges(pos,4)=NaN;
    181                 values=md2.edges(pos,2);
    182                 md2.edges(pos,2)=md2.edges(pos,1);
    183                 md2.edges(pos,1)=values;
     178                pos=find(isnan(md2.mesh.edges(:,3)));
     179                md2.mesh.edges(pos,3)=md2.mesh.edges(pos,4);
     180                md2.mesh.edges(pos,4)=NaN;
     181                values=md2.mesh.edges(pos,2);
     182                md2.mesh.edges(pos,2)=md2.mesh.edges(pos,1);
     183                md2.mesh.edges(pos,1)=values;
    184184                %Finally remove edges that do not belong to any element
    185                 pos=find(isnan(md2.edges(:,3)) & isnan(md2.edges(:,4)));
    186                 md2.edges(pos,:)=[];
     185                pos=find(isnan(md2.mesh.edges(:,3)) & isnan(md2.mesh.edges(:,4)));
     186                md2.mesh.edges(pos,:)=[];
    187187        end
    188188
    … …  
    203203        %recreate segments
    204204        if md1.dim==2
    205                 md2.mesh.vertexconnectivity=NodeConnectivity(md2.elements,md2.numberofnodes);
    206                 md2.mesh.elementconnectivity=ElementConnectivity(md2.elements,md2.mesh.vertexconnectivity);
     205                md2.mesh.vertexconnectivity=NodeConnectivity(md2.mesh.elements,md2.numberofnodes);
     206                md2.mesh.elementconnectivity=ElementConnectivity(md2.mesh.elements,md2.mesh.vertexconnectivity);
    207207                md2.segments=contourenvelope(md2);
    208208                md2.mesh.vertexonboundary=zeros(numberofnodes2,1); md2.nodeonboundary(md2.segments(:,1:2))=1;
    … …  
    212212        %Catch the elements that have not been extracted
    213213        orphans_elem=find(~flag_elem);
    214         orphans_node=unique(md1.elements(orphans_elem,:))';
     214        orphans_node=unique(md1.mesh.elements(orphans_elem,:))';
    215215        %Figure out which node are on the boundary between md2 and md1
    216216        nodestoflag1=intersect(orphans_node,pos_node);

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

    r9731 r9733  
    1616        md3d=md;
    1717       
    18         md.elements=md.mesh.elements2d;
     18        md.mesh.elements=md.mesh.elements2d;
    1919        md.x=md.mesh.x2d;
    2020        md.y=md.mesh.y2d;

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

    r9729 r9733  
    88%    md.qmu.vertex_weight        (double [nv], vertex weights)
    99
    10 indi=[md.elements(:,1);md.elements(:,2);md.elements(:,3)];
    11 indj=[md.elements(:,2);md.elements(:,3);md.elements(:,1)];
     10indi=[md.mesh.elements(:,1);md.mesh.elements(:,2);md.mesh.elements(:,3)];
     11indj=[md.mesh.elements(:,2);md.mesh.elements(:,3);md.mesh.elements(:,1)];
    1212values=1;
    1313
    … …  
    1616
    1717%now, build vwgt:
    18 areas=GetAreas(md.elements,md.x,md.y);
     18areas=GetAreas(md.mesh.elements,md.x,md.y);
    1919
    2020%get node connectivity
    21 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     21md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
    2222
    2323connectivity=md.mesh.vertexconnectivity(:,1:end-1);

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

    r9731 r9733  
    3434        %extrude the partition vector vertically.
    3535        md3d=md; %save  for later
    36         md.elements=md.mesh.elements2d;
     36        md.mesh.elements=md.mesh.elements2d;
    3737        md.x=md.mesh.x2d;
    3838        md.y=md.mesh.y2d;

  • issm/trunk/src/m/model/plot/applyoptions.m

    r9719 r9733  
    437437%flag edges of a partition
    438438if exist(options,'partitionedges')
    439 [xsegments ysegments]=flagedges(md.elements,md.x,md.y,md.qmu.partition);
     439[xsegments ysegments]=flagedges(md.mesh.elements,md.x,md.y,md.qmu.partition);
    440440xsegments=xsegments*getfieldvalue(options,'unit',1);
    441441ysegments=ysegments*getfieldvalue(options,'unit',1);

  • issm/trunk/src/m/model/plot/plot_edges.m

    r9719 r9733  
    1212%process mesh and data
    1313[x y z elements is2d isplanet]=processmesh(md,[],options);
    14 edges=md.edges;
     14edges=md.mesh.edges;
    1515if isnan(edges)
    1616        error('edges in NaN')

  • issm/trunk/src/m/model/plot/plot_rifts.m

    r9619 r9733  
    3030                        tip=md.rifts.riftstruct(i).tips(3);
    3131                        %who is tip connected to?
    32                         if isconnected(md.elements,penaltypairs(1,1),tip),
     32                        if isconnected(md.mesh.elements,penaltypairs(1,1),tip),
    3333                                normal(1)=penaltypairs(1,5);
    3434                                normal(2)=penaltypairs(1,6);
    … …  
    3737                        end
    3838
    39                         if isconnected(md.elements,penaltypairs(1,2),tip),
     39                        if isconnected(md.mesh.elements,penaltypairs(1,2),tip),
    4040                                normal(1)=penaltypairs(1,5);
    4141                                normal(2)=penaltypairs(1,6);
    … …  
    4343                                y(tip)=y(tip)+normal(2)*offset;
    4444                        end
    45                         if isconnected(md.elements,penaltypairs(end,1),tip),
     45                        if isconnected(md.mesh.elements,penaltypairs(end,1),tip),
    4646                                normal(1)=penaltypairs(end,5);
    4747                                normal(2)=penaltypairs(end,6);
    … …  
    4949                                y(tip)=y(tip)-normal(2)*offset;
    5050                        end
    51                         if isconnected(md.elements,penaltypairs(end,2),tip),
     51                        if isconnected(md.mesh.elements,penaltypairs(end,2),tip),
    5252                                normal(1)=penaltypairs(end,5);
    5353                                normal(2)=penaltypairs(end,6);

  • issm/trunk/src/m/model/plot/plot_section.m

    r9731 r9733  
    3232md3d=md;
    3333if exist(options,'layer')
    34         md.x=md.mesh.x2d; md.y=md.mesh.y2d; md.elements=md.mesh.elements2d; md.mesh.dimension=2;
     34        md.x=md.mesh.x2d; md.y=md.mesh.y2d; md.mesh.elements=md.mesh.elements2d; md.mesh.dimension=2;
    3535end
    3636

  • issm/trunk/src/m/model/plot/plot_tensor_principalaxis.m

    r9719 r9733  
    2929%take the center of each element if ~isonnode
    3030if datatype==1,
    31         x=mean(md.x(md.elements'))'; y=mean(md.y(md.elements'))'; z=mean(md.z(md.elements'))';
     31        x=mean(md.x(md.mesh.elements'))'; y=mean(md.y(md.mesh.elements'))'; z=mean(md.z(md.mesh.elements'))';
    3232end
    3333

  • issm/trunk/src/m/model/plot/processdata.m

    r9725 r9733  
    123123                pos=find(~flags);
    124124                if length(flags)==md.mesh.numberofvertices,
    125                         [pos2 dummy]=find(ismember(md.elements,pos));
     125                        [pos2 dummy]=find(ismember(md.mesh.elements,pos));
    126126                        data(pos2,:)=NaN;
    127127                elseif length(flags)==md.mesh.numberofelements
    … …  
    155155                        data(pos,:)=NaN;
    156156                elseif length(flags)==md.mesh.numberofelements
    157                         data(md.elements(pos,:),:)=NaN;
     157                        data(md.mesh.elements(pos,:),:)=NaN;
    158158                else
    159159                        disp('plotmodel warning: mask length not supported yet (supported length are md.mesh.numberofvertices and md.mesh.numberofelements');

  • issm/trunk/src/m/model/plot/processmesh.m

    r9731 r9733  
    3838
    3939        elements2d=md.mesh.elements2d;
    40         elements=md.elements;
     40        elements=md.mesh.elements;
    4141
    4242        %is it a 2d plot?

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

    r9725 r9733  
    7272%1: Hutter elements
    7373nodeonhutter=zeros(md.mesh.numberofvertices,1);
    74 nodeonhutter(md.elements(find(hutterflag),:))=1;
     74nodeonhutter(md.mesh.elements(find(hutterflag),:))=1;
    7575md.flowequation.element_equation(find(hutterflag))=1;
    7676
    7777%2: MacAyeal elements
    7878nodeonmacayeal=zeros(md.mesh.numberofvertices,1);
    79 nodeonmacayeal(md.elements(find(macayealflag),:))=1;
     79nodeonmacayeal(md.mesh.elements(find(macayealflag),:))=1;
    8080md.flowequation.bordermacayeal=nodeonmacayeal;
    8181md.flowequation.element_equation(find(macayealflag))=2;
    … …  
    8383%3: Pattyn elements
    8484nodeonpattyn=zeros(md.mesh.numberofvertices,1);
    85 nodeonpattyn(md.elements(find(pattynflag),:))=1;
     85nodeonpattyn(md.mesh.elements(find(pattynflag),:))=1;
    8686md.flowequation.borderpattyn=nodeonpattyn;
    8787md.flowequation.element_equation(find(pattynflag))=3;
    … …  
    9191if any(stokesflag),
    9292        nodeonstokes=zeros(md.mesh.numberofvertices,1);
    93         nodeonstokes(md.elements(find(stokesflag),:))=1;
     93        nodeonstokes(md.mesh.elements(find(stokesflag),:))=1;
    9494        fullspcnodes=double((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy)+~isnan(md.diagnostic.spcvz))==3 | (nodeonpattyn & nodeonstokes));         %find all the nodes on the boundary of the domain without icefront
    95         fullspcelems=double(sum(fullspcnodes(md.elements),2)==6);         %find all the nodes on the boundary of the domain without icefront
     95        fullspcelems=double(sum(fullspcnodes(md.mesh.elements),2)==6);         %find all the nodes on the boundary of the domain without icefront
    9696        stokesflag(find(fullspcelems))=0;
    9797end
    9898nodeonstokes=zeros(md.mesh.numberofvertices,1);
    99 nodeonstokes(md.elements(find(stokesflag),:))=1;
     99nodeonstokes(md.mesh.elements(find(stokesflag),:))=1;
    100100md.flowequation.borderstokes=nodeonstokes;
    101101md.flowequation.element_equation(find(stokesflag))=4;
    … …  
    105105        if any(pattynflag), %fill with pattyn
    106106                pattynflag(~stokesflag)=1;
    107                 nodeonpattyn(md.elements(find(pattynflag),:))=1;
     107                nodeonpattyn(md.mesh.elements(find(pattynflag),:))=1;
    108108                md.flowequation.borderpattyn=nodeonpattyn;
    109109                md.flowequation.element_equation(find(~stokesflag))=3;
    110110        elseif any(macayealflag), %fill with macayeal
    111111                macayealflag(~stokesflag)=1;
    112                 nodeonmacayeal(md.elements(find(macayealflag),:))=1;
     112                nodeonmacayeal(md.mesh.elements(find(macayealflag),:))=1;
    113113                md.flowequation.bordermacayeal=nodeonmacayeal;
    114114                md.flowequation.element_equation(find(~stokesflag))=2;
    … …  
    143143                nodeonmacayealpattyn(find(nodeonmacayeal & nodeonpattyn))=1;
    144144                %Macayeal elements in contact with this layer become MacAyealPattyn elements
    145                 matrixelements=ismember(md.elements,find(nodeonmacayealpattyn));
     145                matrixelements=ismember(md.mesh.elements,find(nodeonmacayealpattyn));
    146146                commonelements=sum(matrixelements,2)~=0;
    147147                commonelements(find(pattynflag))=0; %only one layer: the elements previously in macayeal
    … …  
    150150                macayealpattynflag(find(commonelements))=1;
    151151                nodeonmacayeal=zeros(md.mesh.numberofvertices,1);
    152                 nodeonmacayeal(md.elements(find(macayealflag),:))=1;
     152                nodeonmacayeal(md.mesh.elements(find(macayealflag),:))=1;
    153153                md.flowequation.bordermacayeal=nodeonmacayeal;
    154154
    … …  
    157157
    158158                %Now recreate nodeonmacayeal and nodeonmacayealpattyn
    159                 nodeonmacayealpattyn(md.elements(find(macayealpattynflag),:))=1;
     159                nodeonmacayealpattyn(md.mesh.elements(find(macayealpattynflag),:))=1;
    160160        elseif any(pattynflag) & any(stokesflag), %coupling pattyn stokes
    161161                %Find node at the border
    162162                nodeonpattynstokes(find(nodeonpattyn & nodeonstokes))=1;
    163163                %Stokes elements in contact with this layer become PattynStokes elements
    164                 matrixelements=ismember(md.elements,find(nodeonpattynstokes));
     164                matrixelements=ismember(md.mesh.elements,find(nodeonpattynstokes));
    165165                commonelements=sum(matrixelements,2)~=0;
    166166                commonelements(find(pattynflag))=0; %only one layer: the elements previously in macayeal
    … …  
    169169                pattynstokesflag(find(commonelements))=1;
    170170                nodeonstokes=zeros(md.mesh.numberofvertices,1);
    171                 nodeonstokes(md.elements(find(stokesflag),:))=1;
     171                nodeonstokes(md.mesh.elements(find(stokesflag),:))=1;
    172172                md.flowequation.borderstokes=nodeonstokes;
    173173
    … …  
    177177                %Now recreate nodeonpattynstokes
    178178                nodeonpattynstokes=zeros(md.mesh.numberofvertices,1);
    179                 nodeonpattynstokes(md.elements(find(pattynstokesflag),:))=1;
     179                nodeonpattynstokes(md.mesh.elements(find(pattynstokesflag),:))=1;
    180180        elseif any(stokesflag) & any(macayealflag),
    181181                %Find node at the border
    182182                nodeonmacayealstokes(find(nodeonmacayeal & nodeonstokes))=1;
    183183                %Stokes elements in contact with this layer become MacAyealStokes elements
    184                 matrixelements=ismember(md.elements,find(nodeonmacayealstokes));
     184                matrixelements=ismember(md.mesh.elements,find(nodeonmacayealstokes));
    185185                commonelements=sum(matrixelements,2)~=0;
    186186                commonelements(find(macayealflag))=0; %only one layer: the elements previously in macayeal
    … …  
    189189                macayealstokesflag(find(commonelements))=1;
    190190                nodeonstokes=zeros(md.mesh.numberofvertices,1);
    191                 nodeonstokes(md.elements(find(stokesflag),:))=1;
     191                nodeonstokes(md.mesh.elements(find(stokesflag),:))=1;
    192192                md.flowequation.borderstokes=nodeonstokes;
    193193
    … …  
    197197                %Now recreate nodeonmacayealstokes
    198198                nodeonmacayealstokes=zeros(md.mesh.numberofvertices,1);
    199                 nodeonmacayealstokes(md.elements(find(macayealstokesflag),:))=1;
     199                nodeonmacayealstokes(md.mesh.elements(find(macayealstokesflag),:))=1;
    200200        elseif any(stokesflag) & any(hutterflag),
    201201                error('type of coupling not supported yet');

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

    r9725 r9733  
    2323x=md.x;
    2424y=md.y;
    25 elements=md.elements;
     25elements=md.mesh.elements;
    2626
    2727%Assign elementonfloatingice, elementongroundedice, vertexongroundedice and vertexonfloatingice. Only change at your own peril! This is synchronized heavily with the GroundingLineMigration module. {{{1
    … …  
    3737vertexonfloatingice=zeros(md.mesh.numberofvertices,1);
    3838vertexongroundedice=zeros(md.mesh.numberofvertices,1);
    39 vertexongroundedice(md.elements(find(elementongroundedice),:))=1;
     39vertexongroundedice(md.mesh.elements(find(elementongroundedice),:))=1;
    4040vertexonfloatingice(find(~vertexongroundedice))=1;
    4141%}}}

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

    r9729 r9733  
    1111x=md.x;
    1212y=md.y;
    13 elements=md.elements;
     13elements=md.mesh.elements;
    1414
    1515%recover elements and nodes on land.
    … …  
    2222        elementonland=landname;
    2323        vertexonland=zeros(md.mesh.numberofvertices,1);
    24         vertexonland(md.elements(find(elementonland),:))=1;
     24        vertexonland(md.mesh.elements(find(elementonland),:))=1;
    2525else
    2626        error('Invalid area option option');
    … …  
    2929%Now, build the connectivity tables for this mesh.
    3030if size(md.mesh.vertexconnectivity,1)~=md.mesh.numberofvertices,
    31         md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
     31        md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
    3232end
    3333if size(md.mesh.elementconnectivity,1)~=md.mesh.numberofelements,
    34         md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     34        md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    3535end
    3636
    3737%any element with 3 nodes on land should be on land:
    3838elementsonwater=find(~elementonland);
    39 wrongelements=elementsonwater(find(( vertexonland(md.elements(elementsonwater,1)) + vertexonland(md.elements(elementsonwater,2)) + vertexonland(md.elements(elementsonwater,3)) ...
     39wrongelements=elementsonwater(find(( vertexonland(md.mesh.elements(elementsonwater,1)) + vertexonland(md.mesh.elements(elementsonwater,2)) + vertexonland(md.mesh.elements(elementsonwater,3)) ...
    4040                  )==3));
    4141elementonland(wrongelements)=1;
    … …  
    4545weights={[1;1;1],[2;1;1],[1;2;1],[1;1;2]};
    4646        for i=1:length(weights),
    47                 xelem=x(md.elements)*weights{i}/sum(weights{i});
    48                 yelem=y(md.elements)*weights{i}/sum(weights{i});
     47                xelem=x(md.mesh.elements)*weights{i}/sum(weights{i});
     48                yelem=y(md.mesh.elements)*weights{i}/sum(weights{i});
    4949        end
    5050        baryonland=ContourToNodes(xelem,yelem,landname,1);
    … …  
    7979elementonfloatingice=double((elementonfloatingice & ~elementongroundedice));
    8080elementongroundedice=double(~elementonfloatingice);
    81 vertexonfloatingice(md.elements(find(elementonfloatingice),:))=1;
    82 vertexongroundedice(md.elements(find(elementongroundedice),:))=1;
     81vertexonfloatingice(md.mesh.elements(find(elementonfloatingice),:))=1;
     82vertexongroundedice(md.mesh.elements(find(elementongroundedice),:))=1;
    8383
    8484%now correct, so that none of the floatingice and groundedice elements and nodes are in the water.

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

    r9684 r9733  
    88%      s=shear2d(md);
    99
    10 [alpha beta]=GetNodalFunctionsCoeff(md.elements,md.x,md.y);
     10[alpha beta]=GetNodalFunctionsCoeff(md.mesh.elements,md.x,md.y);
    1111
    1212summation=[1;1;1];
    13 sx=(md.initialization.vx(md.elements).*alpha)*summation;
    14 uy=(md.initialization.vx(md.elements).*beta)*summation;
    15 vx=(md.initialization.vy(md.elements).*alpha)*summation;
    16 sy=(md.initialization.vy(md.elements).*beta)*summation;                                         
     13sx=(md.initialization.vx(md.mesh.elements).*alpha)*summation;
     14uy=(md.initialization.vx(md.mesh.elements).*beta)*summation;
     15vx=(md.initialization.vy(md.mesh.elements).*alpha)*summation;
     16sy=(md.initialization.vy(md.mesh.elements).*beta)*summation;                                           
    1717sxy=(uy+vx)/2;
    1818s=sqrt(sx.^2+sy.^2+sxy.^2+sx.*sy);

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

    r9719 r9733  
    1717%Average thickness and B over all elements.
    1818summer=[1;1;1];
    19 hel=md.geometry.thickness(md.elements)*summer/3;
    20 Bel=md.B(md.elements)*summer/3;
     19hel=md.geometry.thickness(md.mesh.elements)*summer/3;
     20Bel=md.B(md.mesh.elements)*summer/3;
    2121
    2222Ael=Bel.^(-3);

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

    r9731 r9733  
    99        numberofelements=md.mesh.numberofelements;
    1010        numberofnodes=md.mesh.numberofvertices;
    11         index=md.elements;
     11        index=md.mesh.elements;
    1212        x=md.x; y=md.y;
    1313else

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

    r9725 r9733  
    1717vx=md.initialization.vx;
    1818vy=md.initialization.vy;
    19 index=md.elements;
     19index=md.mesh.elements;
    2020
    2121%compute nodal functions coefficients N(x,y)=alpha x + beta y + gamma
    22 [alpha beta]=GetNodalFunctionsCoeff(md.elements,md.x,md.y);
     22[alpha beta]=GetNodalFunctionsCoeff(md.mesh.elements,md.x,md.y);
    2323
    2424%compute dhdt=div(Hu)

  • issm/trunk/src/m/planet/planetmixedmesh.m

    r9725 r9733  
    8686
    8787
    88 md.elements=quads;
     88md.mesh.elements=quads;
    8989md.x=x;
    9090md.y=y;
    … …  
    9595
    9696md.mesh.numberofvertices=length(md.x);
    97 md.mesh.numberofelements=size(md.elements,1);
     97md.mesh.numberofelements=size(md.mesh.elements,1);
    9898
    9999md.mesh.dimension=3;

  • issm/trunk/src/m/planet/planettrimesh.m

    r9725 r9733  
    99md.y=results.vertices(:,2);
    1010md.z=results.vertices(:,3);
    11 md.elements=results.faces;
     11md.mesh.elements=results.faces;
    1212
    1313md.r=sqrt(md.x.^2+md.y.^2+md.z.^2);
    … …  
    1616
    1717md.mesh.numberofvertices=length(md.x);
    18 md.mesh.numberofelements=size(md.elements,1);
     18md.mesh.numberofelements=size(md.mesh.elements,1);
    1919
    2020md.mesh.dimension=3;

  • issm/trunk/src/m/qmu/importancefactors.m

    r9725 r9733  
    5353%if numel(factors)==md.mesh.numberofvertices,
    5454%       %get areas for each vertex.
    55 %       aire=GetAreas(md.elements,md.x,md.y);
     55%       aire=GetAreas(md.mesh.elements,md.x,md.y);
    5656%       num_elements_by_node=md.nodeconnectivity(:,end);
    5757%       grid_aire=zeros(md.mesh.numberofvertices,1);

  • issm/trunk/src/m/qmu/process_qmu_response_data.m

    r9650 r9733  
    4747
    4848        for i=1:num_mass_flux,
    49                 md.qmu.mass_flux_segments{i}=MeshProfileIntersection(md.elements,md.x,md.y,[md.qmu.mass_flux_profile_directory '/' md.qmu.mass_flux_profiles{i}]);
     49                md.qmu.mass_flux_segments{i}=MeshProfileIntersection(md.mesh.elements,md.x,md.y,[md.qmu.mass_flux_profile_directory '/' md.qmu.mass_flux_profiles{i}]);
    5050        end
    5151

  • issm/trunk/src/m/solutions/flaim.m

    r9714 r9733  
    8080
    8181display('Calling KMLMeshWrite.');
    82 KMLMeshWrite(md.miscellaneous.name,md.miscellaneous.notes,md.elements,md.nodeconnectivity,md.mesh.lat,md.mesh.long,md.qmu.partition,md.flaim.criterion,options.cmap,filekml);
     82KMLMeshWrite(md.miscellaneous.name,md.miscellaneous.notes,md.mesh.elements,md.nodeconnectivity,md.mesh.lat,md.mesh.long,md.qmu.partition,md.flaim.criterion,options.cmap,filekml);
    8383%  for testing
    8484%filekml='issm-split-geikie1-targets.kml';

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

    r9729 r9733  
    1919        icefrontfile=varargin{1};
    2020        if ~exist(icefrontfile), error(['SetIceShelfBC error message: ice front file ' icefrontfile ' not found']); end
    21         nodeinsideicefront=ContourToMesh(md.elements,md.x,md.y,icefrontfile,'node',2);
     21        nodeinsideicefront=ContourToMesh(md.mesh.elements,md.x,md.y,icefrontfile,'node',2);
    2222        nodeonicefront=double(md.mesh.vertexonboundary & nodeinsideicefront);
    2323elseif nargin==1,

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

    r9729 r9733  
    2323                error(['SetMarineIceSheetBC error message: ice front file ' icefrontfile ' not found']);
    2424        end
    25         nodeinsideicefront=ContourToMesh(md.elements,md.x,md.y,icefrontfile,'node',2);
     25        nodeinsideicefront=ContourToMesh(md.mesh.elements,md.x,md.y,icefrontfile,'node',2);
    2626        vertexonicefront=double(md.mesh.vertexonboundary & nodeinsideicefront);
    2727else
    2828        %Guess where the ice front is
    2929        vertexonfloatingice=zeros(md.mesh.numberofvertices,1);
    30         vertexonfloatingice(md.elements(find(md.mask.elementonfloatingice),:))=1;
     30        vertexonfloatingice(md.mesh.elements(find(md.mask.elementonfloatingice),:))=1;
    3131        vertexonicefront=double(md.mesh.vertexonboundary & vertexonfloatingice);
    3232end

  • issm/trunk/src/m/utils/Exp/clicktoflowline.m

    r9681 r9733  
    44% Usage: clicktoflowline(index,x,y,u,v,x0,y0,filename)
    55%
    6 % Ex: clicktoflowline(md.elements,md.x,md.y,md.inversion.vx_obs,md.inversion.vy_obs,'flowline1.exp')
     6% Ex: clicktoflowline(md.mesh.elements,md.x,md.y,md.inversion.vx_obs,md.inversion.vy_obs,'flowline1.exp')
    77
    88

  • issm/trunk/src/m/utils/Exp/downstreamflowlines.m

    r9684 r9733  
    1010%
    1111%   Example:
    12 %      flowpath=downstreamflowlines(md.elements,md.x,md.y,md.vx,md.initialization.vy,x0,y0)
     12%      flowpath=downstreamflowlines(md.mesh.elements,md.x,md.y,md.vx,md.initialization.vy,x0,y0)
    1313
    1414%check input size

  • issm/trunk/src/m/utils/Exp/flowlines.m

    r9684 r9733  
    1010%
    1111%   Example:
    12 %      flowpath=flowlines(md.elements,md.x,md.y,md.vx,md.initialization.vy,x0,y0)
     12%      flowpath=flowlines(md.mesh.elements,md.x,md.y,md.vx,md.initialization.vy,x0,y0)
    1313
    1414%check input size

  • issm/trunk/src/m/utils/Geometry/FlagElements.m

    r9725 r9733  
    3434                                [xlim,ylim]=basinzoom('basin',region);
    3535                                flag_nodes=double(md.x<xlim(2) & md.x>xlim(1) &  md.y<ylim(2) & md.y>ylim(1));
    36                                 flag=prod(flag_nodes(md.elements),2);
     36                                flag=prod(flag_nodes(md.mesh.elements),2);
    3737                        else
    3838                                %ok, flag elements
    39                                 flag=ContourToMesh(md.elements(:,1:3),md.x,md.y,region,'element',1);
     39                                flag=ContourToMesh(md.mesh.elements(:,1:3),md.x,md.y,region,'element',1);
    4040                        end
    4141                end

  • issm/trunk/src/m/utils/Interp/FillHole.m

    r9691 r9733  
    66%
    77%   Example:
    8 %      md.geometry.surface=FillHole(md.elements,x,md.y,md.geometry.surface)
     8%      md.geometry.surface=FillHole(md.mesh.elements,x,md.y,md.geometry.surface)
    99%
    1010

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

    r9725 r9733  
    2020%Compute Hessian
    2121t1=clock; fprintf('%s','      computing Hessian...');
    22 hessian=ComputeHessian(md.elements,md.x,md.y,field,'node');
     22hessian=ComputeHessian(md.mesh.elements,md.x,md.y,field,'node');
    2323t2=clock;fprintf('%s\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    2424
    … …  
    5454%Triangles
    5555fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.mesh.numberofelements);
    56 fprintf(fid,'%i %i %i %i\n',[md.elements ones(md.mesh.numberofelements,1)]');
     56fprintf(fid,'%i %i %i %i\n',[md.mesh.elements ones(md.mesh.numberofelements,1)]');
    5757numberofelements1=md.mesh.numberofelements;
    5858
    … …  
    7171md.y=A.y;
    7272md.z=zeros(A.nods,1);
    73 md.elements=A.index;
     73md.mesh.elements=A.index;
    7474md.mesh.numberofvertices=A.nods;
    7575md.mesh.numberofelements=A.nels;

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

    r9725 r9733  
    3535%Triangles
    3636fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.mesh.numberofelements);
    37 fprintf(fid,'%i %i %i %i\n',[md.elements ones(md.mesh.numberofelements,1)]');
     37fprintf(fid,'%i %i %i %i\n',[md.mesh.elements ones(md.mesh.numberofelements,1)]');
    3838numberofelements1=md.mesh.numberofelements;
    3939
    … …  
    5252md.y=A.y;
    5353md.z=zeros(A.nods,1);
    54 md.elements=A.index;
     54md.mesh.elements=A.index;
    5555md.mesh.numberofvertices=A.nods;
    5656md.mesh.numberofelements=A.nels;

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

    r9681 r9733  
    1010%
    1111%   Example:
    12 %      hessian=ComputeHessian(md.elements,md.x,md.y,md.inversion.vel_obs,'node')
     12%      hessian=ComputeHessian(md.mesh.elements,md.x,md.y,md.inversion.vel_obs,'node')
    1313
    1414%some variables

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

    r3258 r9733  
    44% Usage: edgeelements=ElementsFromEdge(elements,A,B)
    55%
    6 % Eg:    edgeelements=ElementsFromEdge(md.elements,tip1,tip2)
     6% Eg:    edgeelements=ElementsFromEdge(md.mesh.elements,tip1,tip2)
    77%
    88%

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

    r2890 r9733  
    1010%
    1111%   Examples:
    12 %      areas  =GetAreas(md.elements,md.x,md.y);
    13 %      volumes=GetAreas(md.elements,md.x,md.y,md.z);
     12%      areas  =GetAreas(md.mesh.elements,md.x,md.y);
     13%      volumes=GetAreas(md.mesh.elements,md.x,md.y,md.z);
    1414
    1515%get number of elements and number of nodes

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

    r1269 r9733  
    99%
    1010%   Examples:
    11 %      length  =GetCharacteristicLength(md.elements,md.x,md.y);
    12 %      length  =GetCharacteristicLength(md.elements,md.x,md.y,md.z);
     11%      length  =GetCharacteristicLength(md.mesh.elements,md.x,md.y);
     12%      length  =GetCharacteristicLength(md.mesh.elements,md.x,md.y,md.z);
    1313
    1414

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

    r1235 r9733  
    1212%
    1313%   Example:
    14 %      [alpha beta gamma]=GetNodalFunctionsCoeff(md.elements,md.x,md.y);
     14%      [alpha beta gamma]=GetNodalFunctionsCoeff(md.mesh.elements,md.x,md.y);
    1515
    1616%make columns out of x and y

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

    r9725 r9733  
    66
    77%Get some variables from the model
    8 index=md.elements;
     8index=md.mesh.elements;
    99x=md.x;
    1010y=md.y;

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

    r9729 r9733  
    88
    99%make a curve out of the mesh, to use the intersections routine.
    10 rows=[md.elements md.elements(:,1)]'; rows=rows(:);
     10rows=[md.mesh.elements md.mesh.elements(:,1)]'; rows=rows(:);
    1111x=md.x(rows);
    1212y=md.y(rows);
    … …  
    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.vertexconnectivity);
     50node_in_element=NodeInElement(newx,newy,md.mesh.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/YamsCall.m

    r9725 r9733  
    2020%Compute Hessian
    2121t1=clock; fprintf('%s','      computing Hessian...');
    22 hessian=ComputeHessian(md.elements,md.x,md.y,field,'node');
     22hessian=ComputeHessian(md.mesh.elements,md.x,md.y,field,'node');
    2323t2=clock;fprintf('%s\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    2424
    … …  
    5151%Triangles
    5252fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.mesh.numberofelements);
    53 fprintf(fid,'%i %i %i %i\n',[md.elements zeros(md.mesh.numberofelements,1)]');
     53fprintf(fid,'%i %i %i %i\n',[md.mesh.elements zeros(md.mesh.numberofelements,1)]');
    5454numberofelements1=md.mesh.numberofelements;
    5555       
    … …  
    9191md.y=Coor(:,2);
    9292md.z=zeros(size(Coor,1),1);
    93 md.elements=Tria;
     93md.mesh.elements=Tria;
    9494md.mesh.numberofvertices=size(Coor,1);
    9595md.mesh.numberofelements=size(Tria,1);

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

    r9729 r9733  
    7777
    7878%Finally, use model constructor to build a complete model:
    79 md.elements=elements;
     79md.mesh.elements=elements;
    8080md.x=x;
    8181md.y=y;
    8282md.z=z;
    8383md.mesh.numberofvertices=size(md.x,1);
    84 md.mesh.numberofelements=size(md.elements,1);
     84md.mesh.numberofelements=size(md.mesh.elements,1);
    8585md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    8686md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);

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

    r9729 r9733  
    6565
    6666%plug elements
    67 md.elements=index;
     67md.mesh.elements=index;
    6868md.mesh.segments=segments;
    6969md.mesh.numberofelements=nel;
    … …  
    7272
    7373%Now, build the connectivity tables for this mesh.
    74 md.mesh.vertexconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    75 md.mesh.elementconnectivity=ElementConnectivity(md.elements,md.mesh.vertexconnectivity);
     74md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
     75md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    7676
    7777%plug other field

  • issm/trunk/src/m/utils/Numerics/cfl_step.m

    r9725 r9733  
    1515end
    1616
    17 index=md.elements;
     17index=md.mesh.elements;
    1818edgex=max(md.x(index),[],2)-min(md.x(index),[],2);
    1919edgey=max(md.y(index),[],2)-min(md.y(index),[],2);

  • issm/trunk/test/Miscellaneous/Bump/Bump.par

    r9725 r9733  
    1717%Take care of iceshelves: no basal drag
    1818pos=find(md.mask.elementonfloatingice);
    19 md.drag_coefficient(md.elements(pos,:))=0;
     19md.drag_coefficient(md.mesh.elements(pos,:))=0;
    2020md.drag_p=ones(md.mesh.numberofelements,1);
    2121md.drag_q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Miscellaneous/GJM_test1/SquareShelf.par

    r9725 r9733  
    2020md.drag_type=2;
    2121md.drag_coefficient=20*ones(md.mesh.numberofvertices,1);
    22 md.drag_coefficient(md.elements(pos,:))=0;
     22md.drag_coefficient(md.mesh.elements(pos,:))=0;
    2323md.drag_p=ones(md.mesh.numberofelements,1);
    2424md.drag_q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Miscellaneous/connectivity/Square.par

    r9725 r9733  
    1919%Take care of iceshelves: no basal drag
    2020pos=find(md.mask.elementonfloatingice);
    21 md.drag_coefficient(md.elements(pos,:))=0;
     21md.drag_coefficient(md.mesh.elements(pos,:))=0;
    2222md.drag_p=ones(md.mesh.numberofelements,1);
    2323md.drag_q=ones(md.mesh.numberofelements,1);

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

    r9729 r9733  
    1818%       %Find elements at the corner and extract model
    1919%       posnodes=find((md.x==0 | md.x==max(md.x)) & (md.y==0 | md.y==max(md.y)));
    20 %       [a,b]=find(ismember(md.elements,posnodes));
     20%       [a,b]=find(ismember(md.mesh.elements,posnodes));
    2121%       elements=ones(md.mesh.numberofelements,1);
    2222%       elements(a)=0;

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

    r9729 r9733  
    5151set(gcf,'Position',[1 1 1580 1150])
    5252subplot(2,2,1)
    53 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     53p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    5454vel,'FaceColor','interp','EdgeColor','none');
    5555title('Modelled velocity','FontSize',14,'FontWeight','bold')
    … …  
    5858   
    5959subplot(2,2,2)
    60 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     60p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    6161vel_obs,'FaceColor','interp','EdgeColor','none');
    6262title('Analytical velocity','FontSize',14,'FontWeight','bold')
    … …  
    7676
    7777subplot(2,2,4)
    78 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     78p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    7979abs(vel-vel_obs)./vel_obs*100,'FaceColor','interp','EdgeColor','none');
    8080title('Relative misfit [%]','FontSize',14,'FontWeight','bold')

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

    r9729 r9733  
    5050figure(1)
    5151subplot(2,2,1)
    52 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     52p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    5353vel,'FaceColor','interp','EdgeColor','none');
    5454title('Modelled velocity','FontSize',14,'FontWeight','bold')
    … …  
    5757   
    5858subplot(2,2,2)
    59 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     59p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    6060vel_obs,'FaceColor','interp','EdgeColor','none');
    6161title('Analytical velocity','FontSize',14,'FontWeight','bold')
    … …  
    7575
    7676subplot(2,2,4)
    77 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     77p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    7878abs(vel-vel_obs)./vel_obs*100,'FaceColor','interp','EdgeColor','none');
    7979title('Relative misfit [%]','FontSize',14,'FontWeight','bold')

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

    r9729 r9733  
    5050figure(1)
    5151subplot(2,2,1)
    52 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     52p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    5353vel,'FaceColor','interp','EdgeColor','none');
    5454title('Modelled velocity','FontSize',14,'FontWeight','bold')
    … …  
    5757   
    5858subplot(2,2,2)
    59 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     59p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    6060vel_obs,'FaceColor','interp','EdgeColor','none');
    6161title('Analytical velocity','FontSize',14,'FontWeight','bold')
    … …  
    7575
    7676subplot(2,2,4)
    77 p=patch('Faces',md.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
     77p=patch('Faces',md.mesh.elements2d,'Vertices',[md.x2d md.y2d],'FaceVertexCData',...
    7878abs(vel-vel_obs)./vel_obs*100,'FaceColor','interp','EdgeColor','none');
    7979title('Relative misfit [%]','FontSize',14,'FontWeight','bold')

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

    r9729 r9733  
    1212
    1313%Thermal boundary conditions
    14 pos1=find(md.mesh.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
    15 pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
     14pos1=find(md.mesh.elementonbed);     md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10;
     15pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.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

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

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

    r9729 r9733  
    1212md=setflowequation(md,'Pattyn','all');
    1313
    14 pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
     14pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0;
    1515md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1616md.basalforcings.geothermalflux(:)=0.1; %100mW/m^2

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

    r9725 r9733  
    9696        ts = [starttime:res:endtime];
    9797
    98         index = md.elements;
     98        index = md.mesh.elements;
    9999        x1=md.x(index(:,1)); x2=md.x(index(:,2)); x3=md.x(index(:,3));
    100100        y1=md.y(index(:,1)); y2=md.y(index(:,2)); y3=md.y(index(:,3));

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

    r9725 r9733  
    102102        ts = [starttime:res:endtime];
    103103
    104         index = md.elements;
     104        index = md.mesh.elements;
    105105        x1=md.x(index(:,1)); x2=md.x(index(:,2)); x3=md.x(index(:,3));
    106106        y1=md.y(index(:,1)); y2=md.y(index(:,2)); y3=md.y(index(:,3));

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

    r9725 r9733  
    1010%}}}
    1111%put our grounding line 'shelfextent' meters from the icefront {{{1
    12 xelem=md.x(md.elements)*[1;1;1]/3;
    13 yelem=md.y(md.elements)*[1;1;1]/3;
     12xelem=md.x(md.mesh.elements)*[1;1;1]/3;
     13yelem=md.y(md.mesh.elements)*[1;1;1]/3;
    1414rad=sqrt((xelem).*xelem+(yelem).*yelem);
    1515flags=zeros(md.mesh.numberofelements,1);

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

    r9725 r9733  
    1414
    1515%refine existing mesh 1
    16 hessian=ComputeHessian(md.elements,md.x,md.y,md.inversion.vy_obs,'node');
     16hessian=ComputeHessian(md.mesh.elements,md.x,md.y,md.inversion.vy_obs,'node');
    1717metric=ComputeMetric(hessian,2/9,1,1000,25*10^3,[]);
    1818md.miscellaneous.dummy=metric;

  • issm/trunk/test/Par/79North.par

    r9725 r9733  
    1818pos=find(md.mask.elementonfloatingice);
    1919md.friction.coefficient=50*ones(md.mesh.numberofvertices,1);
    20 md.friction.coefficient(md.elements(pos,:))=0;
     20md.friction.coefficient(md.mesh.elements(pos,:))=0;
    2121md.friction.p=ones(md.mesh.numberofelements,1);
    2222md.friction.q=ones(md.mesh.numberofelements,1);
    … …  
    2525md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
    2626pos=zeros(md.mesh.numberofvertices,1);
    27 pos(md.elements(find(md.mask.elementonfloatingice),:))=1;
     27pos(md.mesh.elements(find(md.mask.elementonfloatingice),:))=1;
    2828md.basalforcings.melting_rate(find(pos))=10;
    2929md.surfaceforcings.mass_balance=15*ones(md.mesh.numberofvertices,1);

  • issm/trunk/test/Par/ISMIPA.par

    r9725 r9733  
    1010%Take care of iceshelves: no basal drag
    1111pos=find(md.mask.elementonfloatingice);
    12 md.friction.coefficient(md.elements(pos,:))=0;
     12md.friction.coefficient(md.mesh.elements(pos,:))=0;
    1313md.friction.p=ones(md.mesh.numberofelements,1);
    1414md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/ISMIPB.par

    r9725 r9733  
    1010%Take care of iceshelves: no basal drag
    1111pos=find(md.mask.elementonfloatingice);
    12 md.friction.coefficient(md.elements(pos,:))=0;
     12md.friction.coefficient(md.mesh.elements(pos,:))=0;
    1313md.friction.p=ones(md.mesh.numberofelements,1);
    1414md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/ISMIPC.par

    r9725 r9733  
    1111%Take care of iceshelves: no basal drag
    1212pos=find(md.mask.elementonfloatingice);
    13 md.friction.coefficient(md.elements(pos,:))=0;
     13md.friction.coefficient(md.mesh.elements(pos,:))=0;
    1414md.friction.p=ones(md.mesh.numberofelements,1);
    1515md.friction.q=zeros(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/ISMIPD.par

    r9725 r9733  
    1010%Take care of iceshelves: no basal drag
    1111pos=find(md.mask.elementonfloatingice);
    12 md.friction.coefficient(md.elements(pos,:))=0;
     12md.friction.coefficient(md.mesh.elements(pos,:))=0;
    1313md.friction.p=ones(md.mesh.numberofelements,1);
    1414md.friction.q=zeros(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/Pig.par

    r9725 r9733  
    2323pos=find(md.mask.elementonfloatingice);
    2424md.friction.coefficient=50*ones(md.mesh.numberofvertices,1);
    25 md.friction.coefficient(md.elements(pos,:))=0;
     25md.friction.coefficient(md.mesh.elements(pos,:))=0;
    2626md.friction.p=ones(md.mesh.numberofelements,1);
    2727md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/RoundSheetShelf.par

    r9725 r9733  
    5252pos=find(md.mask.elementonfloatingice);
    5353md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    54 md.friction.coefficient(md.elements(pos,:))=0;
     54md.friction.coefficient(md.mesh.elements(pos,:))=0;
    5555md.friction.p=ones(md.mesh.numberofelements,1);
    5656md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/RoundSheetStaticEISMINT.par

    r9725 r9733  
    1212%Take care of iceshelves: no basal drag
    1313pos=find(md.mask.elementonfloatingice);
    14 md.friction.coefficient(md.elements(pos,:))=0;
     14md.friction.coefficient(md.mesh.elements(pos,:))=0;
    1515md.friction.p=ones(md.mesh.numberofelements,1);
    1616md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/SquareEISMINT.par

    r9725 r9733  
    1212%Take care of iceshelves: no basal drag
    1313pos=find(md.mask.elementonfloatingice);
    14 md.friction.coefficient(md.elements(pos,:))=0;
     14md.friction.coefficient(md.mesh.elements(pos,:))=0;
    1515md.friction.p=ones(md.mesh.numberofelements,1);
    1616md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/SquareSheetConstrained.par

    r9725 r9733  
    2626pos=find(md.mask.elementonfloatingice);
    2727md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    28 md.friction.coefficient(md.elements(pos,:))=0;
     28md.friction.coefficient(md.mesh.elements(pos,:))=0;
    2929md.friction.p=ones(md.mesh.numberofelements,1);
    3030md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/SquareSheetShelf.par

    r9725 r9733  
    3333pos=find(md.mask.elementonfloatingice);
    3434md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    35 md.friction.coefficient(md.elements(pos,:))=0;
     35md.friction.coefficient(md.mesh.elements(pos,:))=0;
    3636md.friction.p=ones(md.mesh.numberofelements,1);
    3737md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/SquareShelf.par

    r9725 r9733  
    2626pos=find(md.mask.elementonfloatingice);
    2727md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    28 md.friction.coefficient(md.elements(pos,:))=0;
     28md.friction.coefficient(md.mesh.elements(pos,:))=0;
    2929md.friction.p=ones(md.mesh.numberofelements,1);
    3030md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/SquareShelfConstrained.par

    r9725 r9733  
    3030pos=find(md.mask.elementonfloatingice);
    3131md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    32 md.friction.coefficient(md.elements(pos,:))=0;
     32md.friction.coefficient(md.mesh.elements(pos,:))=0;
    3333md.friction.p=ones(md.mesh.numberofelements,1);
    3434md.friction.q=ones(md.mesh.numberofelements,1);

  • issm/trunk/test/Par/SquareThermal.par

    r9725 r9733  
    1818%Take care of iceshelves: no basal drag
    1919pos=find(md.mask.elementonfloatingice);
    20 md.friction.coefficient(md.elements(pos,:))=0;
     20md.friction.coefficient(md.mesh.elements(pos,:))=0;
    2121md.friction.p=ones(md.mesh.numberofelements,1);
    2222md.friction.q=ones(md.mesh.numberofelements,1);
    … …  
    4141md.thermal.spctemperature(:)=md.initialization.temperature;
    4242md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);
    43 pos=find(md.mask.elementongroundedice);md.basalforcings.geothermalflux(md.elements(pos,:))=1*10^-3; %1 mW/m^2
     43pos=find(md.mask.elementongroundedice);md.basalforcings.geothermalflux(md.mesh.elements(pos,:))=1*10^-3; %1 mW/m^2
Note: See TracChangeset for help on using the changeset viewer.